@advenue/react-native 0.3.1 → 0.5.0

package/README.md

@@ -8,11 +8,11 @@ engine.
 ## Install
 
 ```sh
-npx expo install @advenue/react-native @advenue/sdk-android @advenue/sdk-ios \
+npx expo install @advenue/react-native \
   react-native-mmkv expo-secure-store
 ```
 
-`@advenue/sdk-android` and `@advenue/sdk-ios` are Expo native modules built by
+The iOS and Android Expo native modules ship inside this package (`ios/`, `android/`) and are built by
 your app's own Gradle/Xcode build — no manual linking.
 
 ## Quick start

package/android/build.gradle

@@ -0,0 +1,22 @@
+apply plugin: 'com.android.library'
+apply plugin: 'org.jetbrains.kotlin.android'
+
+group = 'expo.modules.advenue'
+version = '0.0.0'
+
+android {
+  namespace = 'expo.modules.advenue'
+  compileSdk = 35
+  defaultConfig {
+    minSdk = 24
+  }
+}
+
+dependencies {
+  implementation 'com.android.installreferrer:installreferrer:2.2'
+  implementation("com.google.android.gms:play-services-ads-identifier:18.0.1")
+  // App Set ID — non-advertising, developer-scoped id for first-party fraud/dedup (not ads).
+  implementation("com.google.android.gms:play-services-appset:16.0.2")
+  // Play Integrity Standard API — device attestation (G3.1n).
+  implementation("com.google.android.play:integrity:1.4.0")
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,8 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+  <!-- Android 11+ package visibility for the Meta Install Referrer providers. -->
+  <queries>
+    <package android:name="com.facebook.katana" />
+    <package android:name="com.instagram.android" />
+    <package android:name="com.facebook.lite" />
+  </queries>
+</manifest>

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

@@ -0,0 +1,354 @@
+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.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).
+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)
+      }
+    }
+
+    // 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()
+    }
+
+    // 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) }
+    }
+
+    // Play Integrity Standard API — device attestation (G3.1n).
+    //
+    // `requestHash` MUST be sha256_hex("<appId>:<deviceId>") — lowercase hex of
+    // SHA-256 over the literal string "<appId>:<deviceId>". The server's
+    // mapIntegrityVerdict (Task 3) re-derives the same string and compares it to
+    // the token's requestHash field; the strings must match byte-for-byte.
+    //
+    // 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
+          }
+        }
+        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) {
+        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
+    }
+
+    // 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()
+    }
+
+    // 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,
+          )
+        } else {
+          null
+        }
+      } catch (_: Exception) {
+        null // best-effort: a missing SSAID never blocks anything
+      }
+    }
+  }
+
+  private fun sdkPrefs(): android.content.SharedPreferences? =
+    appContext.reactContext?.applicationContext
+      ?.getSharedPreferences("io.advenue.sdk", android.content.Context.MODE_PRIVATE)
+}