@advenue/react-native 0.9.0 → 1.0.1

package/README.md

@@ -8,8 +8,7 @@ engine.
 ## Install
 
 ```sh
-npx expo install @advenue/react-native \
-  react-native-mmkv expo-secure-store
+npx expo install @advenue/react-native
 ```
 
 The iOS and Android Expo native modules ship inside this package (`ios/`, `android/`) and are built by
@@ -19,20 +18,22 @@ your app's own Gradle/Xcode build — no manual linking.
 
 ```ts
 import { Advenue } from '@advenue/react-native';
-import { MMKV } from 'react-native-mmkv';
-import * as SecureStore from 'expo-secure-store';
 
 await Advenue.initialize({
   apiKey: 'apk_live_...',        // from your Advenue dashboard
-  platform: 'ios',               // or 'android'
-  mmkv: new MMKV(),              // offline event buffering
-  secureStore: SecureStore,      // durable device identity
   // endpoint: 'https://ingest.your-domain.com',  // self-hosted only
 });
 
 Advenue.track('signup_completed', { plan: 'pro' });
 ```
 
+Storage and platform detection are built in. `track()` properties never become
+financial revenue; connect a verified S2S store source for revenue/LTV/ROAS.
+
+On iOS, the SDK fetches the versioned SKAN config and persists monotonic state.
+Use `Advenue.recordSkanRevenue({ amount: '9.99', currency: 'USD' })` only to
+advance Apple's local conversion value. It does not record Advenue revenue.
+
 > The `adv_` event-name prefix (e.g. `adv_meta_aem`) is reserved for
 > Advenue-internal signals — don't name your own custom events with it. Such
 > events are still accepted by `track()` (the pipeline relies on them) but are

package/android/src/main/java/expo/modules/advenue/AdvenueAndroidModule.kt

@@ -1,398 +1,147 @@
 package expo.modules.advenue
 
-import android.content.pm.ApplicationInfo
-import com.android.installreferrer.api.InstallReferrerClient
-import com.android.installreferrer.api.InstallReferrerStateListener
-import com.google.android.gms.ads.identifier.AdvertisingIdClient
-import com.google.android.gms.appset.AppSet
-import com.google.android.play.core.integrity.IntegrityManagerFactory
-import com.google.android.play.core.integrity.StandardIntegrityManager
-import com.google.android.play.core.integrity.StandardIntegrityManager.PrepareIntegrityTokenRequest
-import com.google.android.play.core.integrity.StandardIntegrityManager.StandardIntegrityTokenRequest
+import expo.modules.kotlin.Promise
 import expo.modules.kotlin.modules.Module
 import expo.modules.kotlin.modules.ModuleDefinition
-import expo.modules.kotlin.Promise
-
-// Advenue Android native module. Fetches the Google Play Install Referrer; the
-// referrer string is parsed in TS (@advenue/install-referrer).
+import io.advenue.Advenue
+import io.advenue.AdvenueConfig
+import io.advenue.platform.DEFAULT_ENDPOINT
+
+/**
+ * The React Native bridge to the Advenue Android SDK.
+ *
+ * It used to be a toolbox: the Play Install Referrer, the Meta install
+ * referrer, the GAID, the App Set ID, Play Integrity, the SSAID, TCF, device
+ * info and two storage backends, each its own function, because a TypeScript
+ * core drove them one at a time. That core is retired and none of them had a
+ * caller left.
+ *
+ * They are deleted rather than left in place. One of them was actively harmful:
+ * an `OnCreate` block warmed a Play Integrity token provider for nobody, and
+ * the SDK's own `PlayIntegritySource` warms another — two `prepareIntegrityToken`
+ * calls per launch, against a quota, for one token. The rest were merely dead,
+ * which in an SDK means code someone later assumes is live.
+ *
+ * Everything they did, the vendored SDK now does through its own plugins.
+ */
 class AdvenueAndroidModule : Module() {
-  // Standard Integrity token provider, warmed once at module init. Null when
-  // Play Integrity is unavailable (side-loaded APK, emulator, no Play Services).
-  // Warming is best-effort — a failure leaves this null and getIntegrityToken
-  // will reject with a clear error.
-  private var integrityProvider: StandardIntegrityManager.StandardIntegrityTokenProvider? = null
-
   override fun definition() = ModuleDefinition {
     Name("AdvenueAndroid")
 
-    // Warm the Standard Integrity token provider when the module is created.
-    // The Google Cloud project number is read from the application's <meta-data>
-    // tag in AndroidManifest.xml:
-    //
-    //   <meta-data
-    //       android:name="io.advenue.INTEGRITY_CLOUD_PROJECT_NUMBER"
-    //       android:value="<your-GCP-project-number>" />
-    //
-    // This is the numeric project ID shown in the Google Cloud Console URL:
-    // https://console.cloud.google.com/home/dashboard?project=<project-id>
-    // The number itself lives in Settings → Project info → Project number.
-    OnCreate {
-      val ctx = appContext.reactContext?.applicationContext ?: return@OnCreate
-      try {
-        val ai: ApplicationInfo = ctx.packageManager.getApplicationInfo(
-          ctx.packageName,
-          android.content.pm.PackageManager.GET_META_DATA,
-        )
-        // GCP project numbers are large longs (12+ digits). Android meta-data
-        // stores them as String when declared as android:value="123..." (no type
-        // suffix). We try getLong() first (works when stored as an integer
-        // resource), then fall back to getString() + toLong() for string values.
-        val metaBundle = ai.metaData
-        val cloudProjectNumber: Long = metaBundle?.getLong(
-          "io.advenue.INTEGRITY_CLOUD_PROJECT_NUMBER", 0L
-        )?.takeIf { it != 0L }
-          ?: metaBundle?.getString("io.advenue.INTEGRITY_CLOUD_PROJECT_NUMBER")
-            ?.toLongOrNull()
-          ?: 0L
-        if (cloudProjectNumber == 0L) {
-          // Project number not configured — attestation will be unavailable.
-          // Callers can still call getIntegrityToken(); it will reject with ECONFIG.
-          return@OnCreate
-        }
-        val manager = IntegrityManagerFactory.createStandard(ctx)
-        manager.prepareIntegrityToken(
-          PrepareIntegrityTokenRequest.builder()
-            .setCloudProjectNumber(cloudProjectNumber)
-            .build()
-        )
-          .addOnSuccessListener { provider -> integrityProvider = provider }
-          .addOnFailureListener { /* provider stays null — getIntegrityToken will reject */ }
-      } catch (_: Exception) {
-        // Play Integrity unavailable (no Play Services, side-loaded build, etc.)
-      }
-    }
-
-    AsyncFunction("getInstallReferrer") { promise: Promise ->
-      val context = appContext.reactContext ?: run {
-        promise.reject("ECTX", "No React context", null)
-        return@AsyncFunction
-      }
-      val client = InstallReferrerClient.newBuilder(context).build()
-      // The Play Install Referrer callback can fire setup-finished, disconnect, or
-      // never respond (offline / unavailable). Settle the promise EXACTLY once and
-      // release the service binding on every exit path — otherwise a disconnect or
-      // a hung connection leaks the binding and hangs trackInstall forever.
-      val settled = java.util.concurrent.atomic.AtomicBoolean(false)
-      val handler = android.os.Handler(android.os.Looper.getMainLooper())
-      fun release() {
-        try { client.endConnection() } catch (_: Exception) {}
-      }
-      // Watchdog: if the service never calls back, resolve null (referrer is
-      // best-effort enrichment) so the JS promise always settles.
-      handler.postDelayed({
-        if (settled.compareAndSet(false, true)) {
-          release()
-          promise.resolve(null)
-        }
-      }, 5_000)
-
-      client.startConnection(object : InstallReferrerStateListener {
-        override fun onInstallReferrerSetupFinished(responseCode: Int) {
-          if (!settled.compareAndSet(false, true)) return
-          handler.removeCallbacksAndMessages(null)
-          try {
-            if (responseCode == InstallReferrerClient.InstallReferrerResponse.OK) {
-              val response = client.installReferrer
-              promise.resolve(mapOf(
-                "referrer" to response.installReferrer,
-                "clickTimestamp" to response.referrerClickTimestampSeconds,
-                "installTimestamp" to response.installBeginTimestampSeconds,
-                // Server-clock getters (G1): Play returns 0 when the install is
-                // unverified. The JS layer forwards these as server-trusted keys
-                // only when non-zero. Do NOT confuse with the device-clock
-                // *TimestampSeconds getters above.
-                "clickServerTimestamp" to response.referrerClickTimestampServerSeconds,
-                "installServerTimestamp" to response.installBeginTimestampServerSeconds,
-                "googlePlayInstant" to response.googlePlayInstantParam,
-              ))
-            } else {
-              promise.resolve(null)
-            }
-          } catch (e: Exception) {
-            promise.reject("EREFERRER", e.message, e)
-          } finally {
-            release()
-          }
-        }
-
-        override fun onInstallReferrerServiceDisconnected() {
-          // Service dropped before setup finished (e.g. low memory). Release the
-          // binding and settle as best-effort null instead of hanging forever.
-          if (settled.compareAndSet(false, true)) {
-            handler.removeCallbacksAndMessages(null)
-            release()
-            promise.resolve(null)
-          }
-        }
-      })
-    }
-
-    // Meta (Facebook/Instagram) install referrer via content provider. The
-    // payload is parsed in TS and the encrypted blob decrypted server-side
-    // (@advenue/install-referrer). Resolves null when no Meta app is installed.
-    AsyncFunction("getMetaInstallReferrer") { promise: Promise ->
-      val context = appContext.reactContext ?: run {
-        promise.reject("ECTX", "No React context", null)
-        return@AsyncFunction
-      }
-      val providers = listOf("com.facebook.katana", "com.instagram.android", "com.facebook.lite")
-      try {
-        for (pkg in providers) {
-          val uri = android.net.Uri.parse(
-            "content://$pkg.provider.InstallReferrerProvider/${context.packageName}"
-          )
-          val cursor = try {
-            context.contentResolver.query(
-              uri,
-              arrayOf("install_referrer", "is_ct", "actual_timestamp"),
-              null,
-              null,
-              null,
-            )
-          } catch (_: Exception) {
-            null
-          } ?: continue
-          cursor.use {
-            if (it.moveToFirst()) {
-              val referrerIdx = it.getColumnIndex("install_referrer")
-              val ctIdx = it.getColumnIndex("is_ct")
-              val tsIdx = it.getColumnIndex("actual_timestamp")
-              if (referrerIdx >= 0) {
-                promise.resolve(mapOf(
-                  "installReferrer" to it.getString(referrerIdx),
-                  "isClickThrough" to (ctIdx >= 0 && it.getInt(ctIdx) == 1),
-                  "actualTimestamp" to (if (tsIdx >= 0) it.getLong(tsIdx) else 0L),
-                  "provider" to pkg,
-                ))
-                return@AsyncFunction
-              }
-            }
-          }
-        }
-        promise.resolve(null)
-      } catch (e: Exception) {
-        promise.reject("EMETAREF", e.message, e)
-      }
+    // Diagnostics travel back to JavaScript. `onError` is a JS closure and
+    // cannot cross the channel, so what crosses is the event: a stable context
+    // identifier and a message, never PII. Without this the SDK's own swallowed
+    // failures reach nobody, which is what happened between the inversion and
+    // this commit.
+    Events("onAdvenueError")
+
+    Function("bridgeInitialize") { options: Map<String, Any?> ->
+      val application = appContext.reactContext?.applicationContext as? android.app.Application
+      val apiKey = options["apiKey"] as? String
+      if (application == null || apiKey == null) return@Function
+      Advenue.initialize(
+        application,
+        AdvenueConfig(
+          apiKey = apiKey,
+          endpoint = (options["endpoint"] as? String) ?: DEFAULT_ENDPOINT,
+          requireConsent = (options["requireConsent"] as? Boolean) ?: false,
+          batchSize = (options["batchSize"] as? Number)?.toInt() ?: 20,
+          flushIntervalMs = (options["flushIntervalMs"] as? Number)?.toLong() ?: 15_000L,
+          signingSecret = options["signingSecret"] as? String,
+          onError = { context, error ->
+            sendEvent("onAdvenueError", mapOf("context" to context, "message" to error.toString()))
+          },
+          // The wrapper's version, not this SDK's: a React Native release pins
+          // the native snapshot inside it, so its version identifies both.
+          sdkVersion = options["sdkVersion"] as? String,
+          // The JavaScript has sent this since before the inversion; nothing
+          // read it, so Meta install-referrer attribution never ran.
+          fbAppId = options["fbAppId"] as? String,
+        ),
+      )
     }
 
-    // Google Advertising ID (GAID) + limit-ad-tracking flag. The blocking
-    // Play Services call is run on a background thread.
-    AsyncFunction("getAdvertisingId") { promise: Promise ->
-      Thread {
-        try {
-          val ctx = appContext.reactContext?.applicationContext
-          if (ctx == null) { promise.resolve(null); return@Thread }
-          val info = AdvertisingIdClient.getAdvertisingIdInfo(ctx)
-          val id = info.id
-          val zeroGaid = "00000000-0000-0000-0000-000000000000"
-          if (id.isNullOrEmpty() || id == zeroGaid) promise.resolve(null)
-          else promise.resolve(mapOf("id" to id, "limitAdTracking" to info.isLimitAdTrackingEnabled))
-        } catch (e: Exception) {
-          promise.resolve(null)
-        }
-      }.start()
+    Function("bridgeTrack") { name: String, properties: Map<String, Any?>? ->
+      Advenue.track(name, properties)
     }
 
-    // App Set ID — non-advertising, developer-scoped id. First-party fraud/dedup
-    // use only; Google forbids using it for ads or measurement.
-    AsyncFunction("getAppSetId") { promise: Promise ->
-      val ctx = appContext.reactContext?.applicationContext
-      if (ctx == null) { promise.resolve(null); return@AsyncFunction }
-      AppSet.getClient(ctx).appSetIdInfo
-        .addOnSuccessListener { info -> promise.resolve(info.id) }
-        .addOnFailureListener { promise.resolve(null) }
+    Function("bridgeFlush") { Advenue.flush() }
+    Function("bridgeSetUserId") { id: String? -> Advenue.setUserId(id) }
+    Function("bridgeSetConsent") { granted: Boolean -> Advenue.setConsent(granted) }
+    Function("bridgeForgetMe") { Advenue.forgetMe() }
+    Function("bridgeShutdown") { Advenue.shutdown() }
+    Function("bridgeResolvedAppId") { Advenue.resolvedAppId() }
+    Function("bridgeDeviceId") { Advenue.deviceId() }
+
+    Function("bridgeSetConsentData") { data: Map<String, Any?> ->
+      val gdpr = data["isUserSubjectToGDPR"] as? Boolean ?: return@Function
+      Advenue.setConsentData(
+        gdpr,
+        data["hasConsentForDataUsage"] as? Boolean,
+        data["hasConsentForAdsPersonalization"] as? Boolean,
+        data["hasConsentForAdStorage"] as? Boolean,
+      )
     }
 
-    // Play Integrity Standard API — device attestation (G3.1n).
-    //
-    // `requestHash` MUST be sha256_hex("<deviceId>") — lowercase hex of SHA-256
-    // over the device id alone. The server's mapIntegrityVerdict re-derives the
-    // same string and compares it to the token's requestHash field; the strings
-    // must match byte-for-byte. No app id is hashed in: the token is decoded
-    // against this app's Play package name and must be PLAY_RECOGNIZED, which
-    // binds the app already.
-    //
-    // The provider is warmed in OnCreate (above). If it is null — because the
-    // manifest meta-data key is absent, Play Integrity is unsupported, or warming
-    // failed — this rejects with ECONFIG / EUNSUPPORTED. The JS layer treats any
-    // rejection as "no attestation" and omits the token from the install event.
-    AsyncFunction("getIntegrityToken") { requestHash: String, promise: Promise ->
-      val provider = integrityProvider
-      if (provider == null) {
-        // Distinguish "project number not set" from "Play Integrity not available".
-        val ctx = appContext.reactContext?.applicationContext
-        if (ctx != null) {
-          val ai = try {
-            ctx.packageManager.getApplicationInfo(
-              ctx.packageName,
-              android.content.pm.PackageManager.GET_META_DATA,
-            )
-          } catch (_: Exception) { null }
-          val mb = ai?.metaData
-          val cfgNum: Long = mb?.getLong("io.advenue.INTEGRITY_CLOUD_PROJECT_NUMBER", 0L)
-            ?.takeIf { it != 0L }
-            ?: mb?.getString("io.advenue.INTEGRITY_CLOUD_PROJECT_NUMBER")?.toLongOrNull()
-            ?: 0L
-          if (cfgNum == 0L) {
-            promise.reject(
-              "ECONFIG",
-              "Play Integrity not configured: add io.advenue.INTEGRITY_CLOUD_PROJECT_NUMBER to AndroidManifest.xml meta-data",
-              null,
-            )
-            return@AsyncFunction
+    // Read back, for the JavaScript consent cache. The cache is seeded from
+    // this at initialize: consent is persisted and survives restarts, so a
+    // facade defaulting to false on every cold start would silently discard a
+    // preference the user gave.
+    Function("bridgeGetConsent") { Advenue.trackingConsent() }
+
+    Function("bridgeGetConsentData") {
+      val consent = Advenue.consentData()
+      if (consent == null) {
+        null
+      } else {
+        // Written only when stated: "not asked" is not "denied", and a false
+        // invented here is a recorded refusal that never happened.
+        buildMap<String, Any> {
+          put("isUserSubjectToGDPR", consent.isUserSubjectToGDPR)
+          consent.hasConsentForDataUsage?.let { put("hasConsentForDataUsage", it) }
+          consent.hasConsentForAdsPersonalization?.let {
+            put("hasConsentForAdsPersonalization", it)
           }
+          consent.hasConsentForAdStorage?.let { put("hasConsentForAdStorage", it) }
         }
-        promise.reject(
-          "EUNSUPPORTED",
-          "Play Integrity token provider not ready (Play Services may be unavailable or warming failed)",
-          null,
-        )
-        return@AsyncFunction
       }
-
-      val request = StandardIntegrityTokenRequest.builder()
-        .setRequestHash(requestHash)
-        .build()
-
-      provider.request(request)
-        .addOnSuccessListener { response -> promise.resolve(response.token()) }
-        .addOnFailureListener { e ->
-          promise.reject("EINTEGRITY", e.message ?: "Play Integrity request failed", e)
-        }
     }
 
-    // Device metadata for Meta CAPI `extinfo` (Task 3n). Synchronous — every
-    // API used here is a cheap local read (no network, no blocking I/O beyond
-    // a local StatFs stat call). Best-effort per field: a field is simply
-    // omitted (not defaulted) when its source is unavailable, so the JS-side
-    // fail-safe (collectDeviceInfo) degrades gracefully rather than sending
-    // misleading zeros.
-    Function("getDeviceInfo") {
-      val map = mutableMapOf<String, Any?>()
-      map["model"] = android.os.Build.MODEL
-      map["locale"] = java.util.Locale.getDefault().toString()
-      map["timezone"] = java.util.TimeZone.getDefault().id
-      map["cpuCores"] = Runtime.getRuntime().availableProcessors()
-
-      val ctx = appContext.reactContext?.applicationContext
-      if (ctx != null) {
-        // Meta CAPI extinfo slots 1-3. versionName is the user-facing version
-        // (slot 2, surfaced as the event's appVersion); the version code is the
-        // build identifier (slot 3). Best-effort: a missing PackageInfo must
-        // not cost the caller the rest of the device metadata.
-        map["packageName"] = ctx.packageName
-        try {
-          val pi = ctx.packageManager.getPackageInfo(ctx.packageName, 0)
-          pi.versionName?.let { map["shortVersion"] = it }
-          @Suppress("DEPRECATION")
-          val code =
-            if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.P) {
-              pi.longVersionCode
-            } else {
-              pi.versionCode.toLong()
-            }
-          map["longVersion"] = code.toString()
-        } catch (_: Exception) {
-          // package info best-effort
-        }
-        try {
-          val dm = ctx.resources.displayMetrics
-          map["screenWidth"] = dm.widthPixels
-          map["screenHeight"] = dm.heightPixels
-          map["screenDensity"] = dm.density.toDouble()
-        } catch (_: Exception) {
-          // screen metrics best-effort
-        }
-        try {
-          val statFs = android.os.StatFs(ctx.filesDir.path)
-          val blockSize = statFs.blockSizeLong
-          val gb = 1024.0 * 1024.0 * 1024.0
-          map["totalStorageGb"] = (statFs.blockCountLong * blockSize).toDouble() / gb
-          map["freeStorageGb"] = (statFs.availableBlocksLong * blockSize).toDouble() / gb
-        } catch (_: Exception) {
-          // storage stat best-effort
-        }
-        try {
-          val tm = ctx.getSystemService(android.content.Context.TELEPHONY_SERVICE)
-            as? android.telephony.TelephonyManager
-          val carrier = tm?.networkOperatorName
-          if (!carrier.isNullOrEmpty()) map["carrier"] = carrier
-        } catch (_: Exception) {
-          // carrier best-effort
-        }
-      }
-      map
-    }
+    Function("bridgeSetAppInstanceId") { id: String? -> Advenue.setAppInstanceId(id) }
 
-    // Built-in SDK storage (Adjust-style: the app supplies nothing). A
-    // dedicated SharedPreferences file keeps SDK keys out of the app's prefs.
-    // Wiped on uninstall — Android has no reinstall-durable store, so a
-    // reinstall legitimately re-fires the install (backend window dedups).
-    Function("storageGetItem") { key: String ->
-      sdkPrefs()?.getString(key, null)
-    }
-    Function("storageSetItem") { key: String, value: String ->
-      sdkPrefs()?.edit()?.putString(key, value)?.apply()
-    }
-    Function("storageRemoveItem") { key: String ->
-      sdkPrefs()?.edit()?.remove(key)?.apply()
+    Function("bridgeSetPushToken") { token: String?, provider: String? ->
+      Advenue.setPushToken(token, provider)
     }
 
-    // IAB TCF v2 data a TCF-compliant CMP (e.g. Google UMP) writes to the
-    // *default* SharedPreferences ("<package>_preferences", per the TCF spec) —
-    // deliberately not our io.advenue.sdk file. Raw values pass through; the
-    // TS side (tcfToConsent) owns the policy mapping.
-    Function("getTcfData") { ->
-      val ctx = appContext.reactContext?.applicationContext ?: return@Function null
-      val prefs = ctx.getSharedPreferences(
-        "${ctx.packageName}_preferences", android.content.Context.MODE_PRIVATE
-      )
-      // prefs.all + map lookup: a missing key reads as null (no default value
-      // involved), so "missing" and "0" stay distinguishable. `as? Number`
-      // tolerates a CMP writing the value as Int OR Long (SharedPreferences
-      // has no fixed numeric type per the TCF spec's own contract) without
-      // degrading a Long writer to unknown. runCatching stays as the
-      // last-resort crash guard.
-      val gdprApplies = runCatching {
-        (prefs.all["IABTCF_gdprApplies"] as? Number)?.toInt()
-      }.getOrNull()
-      val purposeConsents = runCatching { prefs.getString("IABTCF_PurposeConsents", null) }.getOrNull()
-      if (gdprApplies == null && purposeConsents == null) return@Function null
-      mapOf("gdprApplies" to gdprApplies, "purposeConsents" to purposeConsents)
+    Function("bridgeProcessDeepLink") { url: String ->
+      val intent = android.content.Intent(android.content.Intent.ACTION_VIEW)
+      intent.data = android.net.Uri.parse(url)
+      Advenue.processDeepLink(intent)
     }
 
-    // SSAID (ANDROID_ID): signing-key-scoped, stable across reinstalls, reset
-    // only by factory reset. Read by the JS facade ONLY when no usable GAID
-    // exists, as a first-party fraud/dedup + reinstall-detection signal (Play
-    // policy: never linked to the advertising id, never used for ads).
-    Function("getAndroidId") { ->
-      try {
-        val ctx = appContext.reactContext?.applicationContext
-        if (ctx != null) {
-          android.provider.Settings.Secure.getString(
-            ctx.contentResolver,
-            android.provider.Settings.Secure.ANDROID_ID,
-          )
+    // Blocking by nature — it polls with backoff — so it is async across the
+    // bridge and runs on its own thread. Calling it on the JS thread would
+    // freeze the UI for up to eight seconds.
+    AsyncFunction("bridgeResolveDeferredDeepLink") { promise: Promise ->
+      Thread {
+        val link = Advenue.resolveDeferredDeepLink()
+        if (link == null) {
+          promise.resolve(null)
         } else {
-          null
+          promise.resolve(
+            mapOf(
+              "deepLinkValue" to link.deepLinkValue,
+              "campaign" to link.campaign,
+              "network" to link.network,
+              "influencerId" to link.influencerId,
+              "isDeferred" to link.isDeferred,
+              "isFirstLaunch" to link.isFirstLaunch,
+            ),
+          )
         }
-      } catch (_: Exception) {
-        null // best-effort: a missing SSAID never blocks anything
       }
+        .apply { isDaemon = true }
+        .start()
     }
   }
-
-  private fun sdkPrefs(): android.content.SharedPreferences? =
-    appContext.reactContext?.applicationContext
-      ?.getSharedPreferences("io.advenue.sdk", android.content.Context.MODE_PRIVATE)
 }