@zellio/chat-react-native 0.0.0-stage → 1.0.0

package/android/src/main/java/ai/zellio/chat/reactnative/ZellioChatModule.kt

@@ -0,0 +1,214 @@
+package ai.zellio.chat.reactnative
+
+import ai.zellio.chat.ZellioChat
+import ai.zellio.chat.ZellioChatListener
+import ai.zellio.chat.ZellioChatOptions
+import ai.zellio.chat.ZellioContext
+import ai.zellio.chat.ZellioLocale
+import ai.zellio.chat.ZellioLogLevel
+import ai.zellio.chat.ZellioTheme
+import ai.zellio.chat.ZellioThemeMode
+import ai.zellio.chat.ZellioTokenCallbackProvider
+import ai.zellio.chat.ZellioUnreadListener
+import android.os.Handler
+import android.os.Looper
+import android.util.Log
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableMap
+import java.util.UUID
+import java.util.concurrent.ConcurrentHashMap
+
+/**
+ * The Turbo Native Module. It holds no chat logic: every method calls the ZeeChat Android SDK and returns.
+ * No exception leaves a method; the SDK has the same rule.
+ */
+class ZellioChatModule(reactContext: ReactApplicationContext) : NativeZellioChatSpec(reactContext) {
+    private val main = Handler(Looper.getMainLooper())
+    private val pendingTokens = ConcurrentHashMap<String, ZellioTokenCallbackProvider.Callback>()
+
+    private val chatListener = object : ZellioChatListener {
+        override fun onChatOpened() = emitEvent("chatOpened", null)
+        override fun onChatClosed() = emitEvent("chatClosed", null)
+        override fun onMessageSent() = emitEvent("messageSent", null)
+        override fun onMessageReceived() = emitEvent("messageReceived", null)
+        override fun onError(code: String) = emitEvent("error", code)
+    }
+
+    private val unreadListener = ZellioUnreadListener { count ->
+        guarded("unread") {
+            val payload = Arguments.createMap()
+            payload.putDouble("count", count.toDouble())
+            emitOnUnread(payload)
+        }
+    }
+
+    init {
+        guarded("init") {
+            ZellioChat.addListener(chatListener)
+            ZellioChat.addUnreadListener(unreadListener)
+        }
+    }
+
+    override fun invalidate() {
+        guarded("invalidate") {
+            ZellioChat.removeListener(chatListener)
+            ZellioChat.removeUnreadListener(unreadListener)
+            failAllTokens("detached")
+        }
+        super.invalidate()
+    }
+
+    override fun configure(appKey: String, options: ReadableMap) = guarded("configure") {
+        val locale = when (options.string("locale")) {
+            "ar" -> ZellioLocale.ARABIC
+            "en" -> ZellioLocale.ENGLISH
+            else -> ZellioLocale.AUTO
+        }
+        val theme = ZellioTheme(
+            mode = when (options.string("themeMode")) {
+                "light" -> ZellioThemeMode.LIGHT
+                "dark" -> ZellioThemeMode.DARK
+                else -> null
+            },
+            primaryColor = options.string("primaryColor"),
+            customerMessageColor = options.string("customerMessageColor"),
+            surfaceColor = options.string("surfaceColor"),
+        )
+        val logLevel = when (options.string("logLevel")) {
+            "none" -> ZellioLogLevel.NONE
+            "error" -> ZellioLogLevel.ERROR
+            "info" -> ZellioLogLevel.INFO
+            "debug" -> ZellioLogLevel.DEBUG
+            else -> ZellioLogLevel.WARN
+        }
+        ZellioChat.configure(
+            reactApplicationContext,
+            appKey,
+            ZellioChatOptions(
+                baseUrl = options.string("baseUrl") ?: ZellioChatOptions.DEFAULT_BASE_URL,
+                locale = locale,
+                theme = theme,
+                logLevel = logLevel,
+                wrapper = options.string("wrapper"),
+                showsInAppBanner = options.bool("showsInAppBanner", true),
+                bannerShowsPreview = options.bool("bannerShowsPreview", true),
+            ),
+        )
+        // configure usually runs after the first Activity resumed, so tell the SDK which one is on screen.
+        ZellioChat.attachActivity(reactApplicationContext.currentActivity)
+    }
+
+    override fun identify() = guarded("identify") {
+        ZellioChat.identifyWithCallback(ZellioTokenCallbackProvider { callback -> requestToken(callback) })
+    }
+
+    override fun resolveToken(requestId: String, token: String?, errorCode: String?) = guarded("resolveToken") {
+        val callback = pendingTokens.remove(requestId) ?: return@guarded
+        when {
+            !token.isNullOrEmpty() -> callback.onToken(token)
+            // JavaScript says nobody is signed in: the SDK treats a null token as logged out.
+            errorCode == "no_token" -> callback.onToken(null)
+            else -> callback.onFailure(IllegalStateException(errorCode ?: "unknown"))
+        }
+    }
+
+    override fun logout() = guarded("logout") { ZellioChat.logout() }
+
+    override fun present() = guarded("present") { ZellioChat.present() }
+
+    override fun presentConversation(conversationId: String?) = guarded("presentConversation") {
+        ZellioChat.presentConversation(conversationId)
+    }
+
+    override fun dismiss() = guarded("dismiss") { ZellioChat.dismiss() }
+
+    override fun setContext(context: ReadableMap?) = guarded("setContext") {
+        ZellioChat.setContext(
+            context?.let {
+                ZellioContext(
+                    screen = it.string("screen"),
+                    itemType = it.string("itemType"),
+                    itemId = it.string("itemId"),
+                    itemTitle = it.string("itemTitle"),
+                    url = it.string("url"),
+                )
+            },
+        )
+    }
+
+    override fun getUnreadCount(promise: Promise) {
+        promise.resolve(safe(0) { ZellioChat.currentUnreadCount() }.toDouble())
+    }
+
+    override fun setPushToken(token: String, environment: String?) = guarded("setPushToken") {
+        ZellioChat.setPushToken(token, environment)
+    }
+
+    override fun isZellioPush(payloadJson: String): Boolean = safe(false) { ZellioChat.isZellioPush(payloadJson) }
+
+    override fun handlePush(payloadJson: String, promise: Promise) {
+        promise.resolve(safe(false) { ZellioChat.handlePush(payloadJson) })
+    }
+
+    override fun handleNotificationTap(payloadJson: String, promise: Promise) {
+        promise.resolve(safe(false) { ZellioChat.handleNotificationTap(payloadJson) })
+    }
+
+    // ---- token requests: native asks JavaScript, JavaScript answers through resolveToken ----
+
+    private fun requestToken(callback: ZellioTokenCallbackProvider.Callback) {
+        val requestId = UUID.randomUUID().toString()
+        pendingTokens[requestId] = callback
+        // The first answer wins. This timer is the safety net when JavaScript never answers.
+        main.postDelayed({
+            pendingTokens.remove(requestId)?.onFailure(IllegalStateException("timeout"))
+        }, TOKEN_TIMEOUT_MS)
+        val payload = Arguments.createMap()
+        payload.putString("requestId", requestId)
+        emitOnTokenRequest(payload)
+    }
+
+    private fun failAllTokens(reason: String) {
+        val ids = pendingTokens.keys.toList()
+        for (id in ids) pendingTokens.remove(id)?.onFailure(IllegalStateException(reason))
+    }
+
+    // ---- helpers ----
+
+    private fun emitEvent(name: String, code: String?) = guarded("event") {
+        val payload = Arguments.createMap()
+        payload.putString("name", name)
+        if (code != null) payload.putString("code", code)
+        emitOnEvent(payload)
+    }
+
+    private fun ReadableMap.string(key: String): String? =
+        if (hasKey(key) && !isNull(key)) getString(key) else null
+
+    private fun ReadableMap.bool(key: String, default: Boolean): Boolean =
+        if (hasKey(key) && !isNull(key)) getBoolean(key) else default
+
+    private inline fun guarded(name: String, block: () -> Unit) {
+        try {
+            block()
+        } catch (t: Throwable) {
+            // The kind of error only. Arguments can hold tokens, so they are never printed.
+            Log.w(TAG, "$name failed (${t.javaClass.simpleName})")
+        }
+    }
+
+    private inline fun <T> safe(fallback: T, block: () -> T): T = try {
+        block()
+    } catch (t: Throwable) {
+        Log.w(TAG, "call failed (${t.javaClass.simpleName})")
+        fallback
+    }
+
+    companion object {
+        const val NAME = NativeZellioChatSpec.NAME
+        private const val TAG = "ZellioChatRN"
+        private const val TOKEN_TIMEOUT_MS = 15_000L
+    }
+}

package/android/src/main/java/ai/zellio/chat/reactnative/ZellioChatPackage.kt

@@ -0,0 +1,25 @@
+package ai.zellio.chat.reactnative
+
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+
+class ZellioChatPackage : BaseReactPackage() {
+    override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? =
+        if (name == ZellioChatModule.NAME) ZellioChatModule(reactContext) else null
+
+    override fun getReactModuleInfoProvider() = ReactModuleInfoProvider {
+        mapOf(
+            ZellioChatModule.NAME to ReactModuleInfo(
+                ZellioChatModule.NAME,
+                ZellioChatModule.NAME,
+                false, // canOverrideExistingModule
+                false, // needsEagerInit
+                false, // isCxxModule
+                true, // isTurboModule
+            ),
+        )
+    }
+}

package/app.plugin.js

@@ -0,0 +1,4 @@
+// Expo loads this file for `plugins: ["@zellio/chat-react-native"]`. The TypeScript source is plugin/src;
+// `npm run build` (and every `npm pack`) compiles it to plugin/build.
+const built = require('./plugin/build');
+module.exports = built.default ?? built;

package/ios/RNZellioChat.h

@@ -0,0 +1,5 @@
+#import <RNZellioChatSpec/RNZellioChatSpec.h>
+
+/// The Turbo Native Module. It only forwards to ZCRNBridge (Swift), which calls the ZeeChat iOS SDK.
+@interface RNZellioChat : NativeZellioChatSpecBase <NativeZellioChatSpec>
+@end

package/ios/RNZellioChat.mm

@@ -0,0 +1,116 @@
+#import "RNZellioChat.h"
+
+#if __has_include("ZellioChatReactNative/ZellioChatReactNative-Swift.h")
+#import "ZellioChatReactNative/ZellioChatReactNative-Swift.h"
+#else
+#import "ZellioChatReactNative-Swift.h"
+#endif
+
+@implementation RNZellioChat
+
+RCT_EXPORT_MODULE(RNZellioChat)
+
++ (BOOL)requiresMainQueueSetup
+{
+  return NO;
+}
+
+- (instancetype)init
+{
+  if ((self = [super init])) {
+    __weak RNZellioChat *weakSelf = self;
+    [ZCRNBridge attachUnread:^(NSInteger count) {
+      [weakSelf emitOnUnread:@{@"count" : @(count)}];
+    }
+        event:^(NSString *name, NSString * _Nullable code) {
+          NSMutableDictionary *payload = [NSMutableDictionary dictionaryWithObject:name forKey:@"name"];
+          if (code != nil) {
+            payload[@"code"] = code;
+          }
+          [weakSelf emitOnEvent:payload];
+        }
+        tokenRequest:^(NSString *requestId) {
+          [weakSelf emitOnTokenRequest:@{@"requestId" : requestId}];
+        }];
+  }
+  return self;
+}
+
+- (void)invalidate
+{
+  [ZCRNBridge detach];
+}
+
+- (void)configure:(NSString *)appKey options:(NSDictionary *)options
+{
+  [ZCRNBridge configureWithAppKey:appKey options:options];
+}
+
+- (void)identify
+{
+  [ZCRNBridge identify];
+}
+
+- (void)resolveToken:(NSString *)requestId token:(NSString * _Nullable)token errorCode:(NSString * _Nullable)errorCode
+{
+  [ZCRNBridge resolveTokenWithRequestId:requestId token:token errorCode:errorCode];
+}
+
+- (void)logout
+{
+  [ZCRNBridge logout];
+}
+
+- (void)present
+{
+  [ZCRNBridge present];
+}
+
+- (void)presentConversation:(NSString * _Nullable)conversationId
+{
+  [ZCRNBridge presentConversationWithId:conversationId];
+}
+
+- (void)dismiss
+{
+  [ZCRNBridge dismiss];
+}
+
+- (void)setContext:(NSDictionary * _Nullable)context
+{
+  [ZCRNBridge setContext:context];
+}
+
+- (void)getUnreadCount:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject
+{
+  resolve(@([ZCRNBridge unreadCount]));
+}
+
+- (void)setPushToken:(NSString *)token environment:(NSString * _Nullable)environment
+{
+  [ZCRNBridge setPushTokenWithHex:token environment:environment];
+}
+
+- (NSNumber *)isZellioPush:(NSString *)payloadJson
+{
+  return @([ZCRNBridge isZellioPushWithJson:payloadJson]);
+}
+
+- (void)handlePush:(NSString *)payloadJson resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject
+{
+  resolve(@([ZCRNBridge handlePushWithJson:payloadJson]));
+}
+
+- (void)handleNotificationTap:(NSString *)payloadJson
+                      resolve:(RCTPromiseResolveBlock)resolve
+                       reject:(RCTPromiseRejectBlock)reject
+{
+  resolve(@([ZCRNBridge handleNotificationTapWithJson:payloadJson]));
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:(const facebook::react::ObjCTurboModule::InitParams &)params
+{
+  return std::make_shared<facebook::react::NativeZellioChatSpecJSI>(params);
+}
+
+@end

package/ios/ZCRNBridge.swift

@@ -0,0 +1,217 @@
+import Foundation
+import UIKit
+
+/// The only Swift file of this package. It sits between the Objective-C++ module (RNZellioChat.mm) and the
+/// ZeeChat iOS SDK, which is compiled into the same pod from ios/vendor. It holds no chat logic.
+@objc(ZCRNBridge)
+public final class ZCRNBridge: NSObject {
+    private static let lock = NSLock()
+    private static var unreadToken: Int?
+    private static var eventToken: Int?
+    private static var onTokenRequest: ((String) -> Void)?
+    private static let pending = PendingTokens()
+
+    /// How long native waits for JavaScript to answer a token request.
+    private static let tokenTimeout: TimeInterval = 15
+
+    // MARK: Events to JavaScript
+
+    @objc(attachUnread:event:tokenRequest:)
+    public static func attach(unread: @escaping (Int) -> Void, event: @escaping (String, String?) -> Void, tokenRequest: @escaping (String) -> Void) {
+        detach()
+        let unreadToken = ZellioChat.addUnreadListener { count in unread(count) }
+        let eventToken = ZellioChat.addEventListener { zellioEvent in event(zellioEvent.name, zellioEvent.code) }
+        lock.lock()
+        self.unreadToken = unreadToken
+        self.eventToken = eventToken
+        self.onTokenRequest = tokenRequest
+        lock.unlock()
+    }
+
+    @objc(detach)
+    public static func detach() {
+        lock.lock()
+        let unreadToken = self.unreadToken
+        let eventToken = self.eventToken
+        self.unreadToken = nil
+        self.eventToken = nil
+        self.onTokenRequest = nil
+        lock.unlock()
+        if let token = unreadToken { ZellioChat.removeUnreadListener(token) }
+        if let token = eventToken { ZellioChat.removeEventListener(token) }
+        pending.failAll()
+    }
+
+    // MARK: Configure and identity
+
+    @objc(configureWithAppKey:options:)
+    public static func configure(appKey: String, options: [String: Any]) {
+        var result = ZellioChatOptions()
+        if let base = options["baseUrl"] as? String, let url = URL(string: base) { result.baseURL = url }
+        switch options["locale"] as? String {
+        case "ar"?: result.locale = .arabic
+        case "en"?: result.locale = .english
+        default: result.locale = .auto
+        }
+        var theme = ZellioChatTheme()
+        switch options["themeMode"] as? String {
+        case "light"?: theme.mode = .light
+        case "dark"?: theme.mode = .dark
+        default: theme.mode = .auto
+        }
+        theme.primaryColor = color(options["primaryColor"])
+        theme.customerMessageColor = color(options["customerMessageColor"])
+        theme.surfaceColor = color(options["surfaceColor"])
+        result.theme = theme
+        switch options["logLevel"] as? String {
+        case "none"?: result.logLevel = .none
+        case "info"?: result.logLevel = .info
+        case "debug"?: result.logLevel = .debug
+        default: result.logLevel = .error
+        }
+        if let value = options["showsInAppBanner"] as? Bool { result.showsInAppBanner = value }
+        if let value = options["bannerShowsPreview"] as? Bool { result.bannerShowsPreview = value }
+        result.wrapper = options["wrapper"] as? String
+        ZellioChat.configure(appKey: appKey, options: result)
+    }
+
+    @objc(identify)
+    public static func identify() {
+        ZellioChat.identify { try await requestToken() }
+    }
+
+    @objc(resolveTokenWithRequestId:token:errorCode:)
+    public static func resolveToken(requestId: String, token: String?, errorCode: String?) {
+        if let token = token, !token.isEmpty {
+            pending.finish(requestId, .success(token))
+        } else {
+            pending.finish(requestId, .failure(ZCRNError.rejected(errorCode ?? "no_token")))
+        }
+    }
+
+    @objc(logout)
+    public static func logout() { ZellioChat.logout() }
+
+    // MARK: Presenting and context
+
+    @objc(present)
+    public static func present() { ZellioChat.present() }
+
+    @objc(presentConversationWithId:)
+    public static func presentConversation(id: String?) { ZellioChat.presentConversation(id: id) }
+
+    @objc(dismiss)
+    public static func dismiss() { ZellioChat.dismiss() }
+
+    @objc(setContext:)
+    public static func setContext(_ context: [String: Any]?) {
+        guard let context = context else {
+            ZellioChat.setContext(nil)
+            return
+        }
+        ZellioChat.setContext(ZellioChatContext(
+            screen: context["screen"] as? String,
+            itemType: context["itemType"] as? String,
+            itemId: context["itemId"] as? String,
+            itemTitle: context["itemTitle"] as? String,
+            url: context["url"] as? String
+        ))
+    }
+
+    @objc(unreadCount)
+    public static func unreadCount() -> Int { ZellioChat.unreadCount }
+
+    // MARK: Push
+
+    @objc(setPushTokenWithHex:environment:)
+    public static func setPushToken(hex: String, environment: String?) {
+        let env = (environment == "sandbox" || environment == "production") ? environment : nil
+        ZellioChat.setPushToken(hex: hex, environment: env)
+    }
+
+    @objc(isZellioPushWithJson:)
+    public static func isZellioPush(json: String) -> Bool {
+        guard let payload = object(json) else { return false }
+        return ZellioChat.isZellioPush(payload)
+    }
+
+    @objc(handlePushWithJson:)
+    public static func handlePush(json: String) -> Bool {
+        guard let payload = object(json) else { return false }
+        return ZellioChat.handlePush(payload)
+    }
+
+    @objc(handleNotificationTapWithJson:)
+    public static func handleNotificationTap(json: String) -> Bool {
+        guard let payload = object(json) else { return false }
+        return ZellioChat.handleNotificationTap(payload)
+    }
+
+    // MARK: Helpers
+
+    private static func object(_ json: String) -> [AnyHashable: Any]? {
+        guard let data = json.data(using: .utf8),
+              let parsed = try? JSONSerialization.jsonObject(with: data) as? [String: Any] else { return nil }
+        return parsed
+    }
+
+    /// `#RRGGBB` only. Anything else is ignored and the Studio color stays.
+    private static func color(_ value: Any?) -> UIColor? {
+        guard var text = value as? String else { return nil }
+        if text.hasPrefix("#") { text.removeFirst() }
+        guard text.count == 6, let number = UInt32(text, radix: 16) else { return nil }
+        return UIColor(red: CGFloat((number >> 16) & 0xFF) / 255, green: CGFloat((number >> 8) & 0xFF) / 255,
+                       blue: CGFloat(number & 0xFF) / 255, alpha: 1)
+    }
+
+    /// The SDK calls this when it needs a session. JavaScript answers through `resolveToken`.
+    /// If JavaScript does not answer in 15 seconds, the request fails. The token is never logged.
+    private static func requestToken() async throws -> String {
+        try await withCheckedThrowingContinuation { (continuation: CheckedContinuation<String, Error>) in
+            lock.lock()
+            let emit = onTokenRequest
+            lock.unlock()
+            guard let emit = emit else {
+                continuation.resume(throwing: ZCRNError.rejected("no_listener"))
+                return
+            }
+            let requestId = UUID().uuidString
+            pending.add(requestId, continuation)
+            DispatchQueue.global().asyncAfter(deadline: .now() + tokenTimeout) {
+                pending.finish(requestId, .failure(ZCRNError.rejected("timeout")))
+            }
+            emit(requestId)
+        }
+    }
+}
+
+enum ZCRNError: Error {
+    /// The code is a short fixed word such as "timeout" or "no_token". Never a token.
+    case rejected(String)
+}
+
+/// Token requests that wait for JavaScript. Each one finishes once: the first answer or the timeout wins.
+private final class PendingTokens {
+    private let lock = NSLock()
+    private var waiting: [String: CheckedContinuation<String, Error>] = [:]
+
+    func add(_ id: String, _ continuation: CheckedContinuation<String, Error>) {
+        lock.lock(); defer { lock.unlock() }
+        waiting[id] = continuation
+    }
+
+    func finish(_ id: String, _ result: Result<String, Error>) {
+        lock.lock()
+        let continuation = waiting.removeValue(forKey: id)
+        lock.unlock()
+        continuation?.resume(with: result)
+    }
+
+    func failAll() {
+        lock.lock()
+        let all = waiting
+        waiting.removeAll()
+        lock.unlock()
+        for (_, continuation) in all { continuation.resume(throwing: ZCRNError.rejected("detached")) }
+    }
+}

package/ios/vendor/resources/PrivacyInfo.xcprivacy

@@ -0,0 +1,99 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>NSPrivacyTracking</key>
+	<false/>
+	<key>NSPrivacyTrackingDomains</key>
+	<array/>
+	<key>NSPrivacyCollectedDataTypes</key>
+	<array>
+		<dict>
+			<key>NSPrivacyCollectedDataType</key>
+			<string>NSPrivacyCollectedDataTypeEmailAddress</string>
+			<key>NSPrivacyCollectedDataTypeLinked</key>
+			<true/>
+			<key>NSPrivacyCollectedDataTypeTracking</key>
+			<false/>
+			<key>NSPrivacyCollectedDataTypePurposes</key>
+			<array>
+				<string>NSPrivacyCollectedDataTypePurposeAppFunctionality</string>
+			</array>
+		</dict>
+		<dict>
+			<key>NSPrivacyCollectedDataType</key>
+			<string>NSPrivacyCollectedDataTypePhoneNumber</string>
+			<key>NSPrivacyCollectedDataTypeLinked</key>
+			<true/>
+			<key>NSPrivacyCollectedDataTypeTracking</key>
+			<false/>
+			<key>NSPrivacyCollectedDataTypePurposes</key>
+			<array>
+				<string>NSPrivacyCollectedDataTypePurposeAppFunctionality</string>
+			</array>
+		</dict>
+		<dict>
+			<key>NSPrivacyCollectedDataType</key>
+			<string>NSPrivacyCollectedDataTypeName</string>
+			<key>NSPrivacyCollectedDataTypeLinked</key>
+			<true/>
+			<key>NSPrivacyCollectedDataTypeTracking</key>
+			<false/>
+			<key>NSPrivacyCollectedDataTypePurposes</key>
+			<array>
+				<string>NSPrivacyCollectedDataTypePurposeAppFunctionality</string>
+			</array>
+		</dict>
+		<dict>
+			<key>NSPrivacyCollectedDataType</key>
+			<string>NSPrivacyCollectedDataTypeOtherUserContent</string>
+			<key>NSPrivacyCollectedDataTypeLinked</key>
+			<true/>
+			<key>NSPrivacyCollectedDataTypeTracking</key>
+			<false/>
+			<key>NSPrivacyCollectedDataTypePurposes</key>
+			<array>
+				<string>NSPrivacyCollectedDataTypePurposeAppFunctionality</string>
+			</array>
+		</dict>
+		<dict>
+			<key>NSPrivacyCollectedDataType</key>
+			<string>NSPrivacyCollectedDataTypeUserID</string>
+			<key>NSPrivacyCollectedDataTypeLinked</key>
+			<true/>
+			<key>NSPrivacyCollectedDataTypeTracking</key>
+			<false/>
+			<key>NSPrivacyCollectedDataTypePurposes</key>
+			<array>
+				<string>NSPrivacyCollectedDataTypePurposeAppFunctionality</string>
+			</array>
+		</dict>
+		<dict>
+			<key>NSPrivacyCollectedDataType</key>
+			<string>NSPrivacyCollectedDataTypeDeviceID</string>
+			<key>NSPrivacyCollectedDataTypeLinked</key>
+			<true/>
+			<key>NSPrivacyCollectedDataTypeTracking</key>
+			<false/>
+			<key>NSPrivacyCollectedDataTypePurposes</key>
+			<array>
+				<string>NSPrivacyCollectedDataTypePurposeAppFunctionality</string>
+			</array>
+		</dict>
+		<dict>
+			<key>NSPrivacyCollectedDataType</key>
+			<string>NSPrivacyCollectedDataTypePhotosorVideos</string>
+			<key>NSPrivacyCollectedDataTypeLinked</key>
+			<true/>
+			<key>NSPrivacyCollectedDataTypeTracking</key>
+			<false/>
+			<key>NSPrivacyCollectedDataTypePurposes</key>
+			<array>
+				<string>NSPrivacyCollectedDataTypePurposeAppFunctionality</string>
+			</array>
+		</dict>
+	</array>
+	<key>NSPrivacyAccessedAPITypes</key>
+	<array/>
+</dict>
+</plist>