@advenue/react-native 0.8.0 → 1.0.0

package/android/src/main/kotlin/io/advenue/plugin/PlayIntegritySource.kt

@@ -0,0 +1,86 @@
+package io.advenue.plugin
+
+import android.content.Context
+import android.content.pm.PackageManager
+import com.google.android.play.core.integrity.IntegrityManagerFactory
+import com.google.android.play.core.integrity.StandardIntegrityManager.PrepareIntegrityTokenRequest
+import com.google.android.play.core.integrity.StandardIntegrityManager.StandardIntegrityTokenProvider
+import com.google.android.play.core.integrity.StandardIntegrityManager.StandardIntegrityTokenRequest
+import com.google.android.gms.tasks.Tasks
+import java.util.concurrent.TimeUnit
+
+/**
+ * Play Integrity Standard API — device attestation.
+ *
+ * The token provider is warmed once, because preparing it is the slow half and
+ * doing it per request would put seconds on the install path.
+ *
+ * The Google Cloud project number comes from the app's manifest:
+ * ```xml
+ * <meta-data android:name="io.advenue.INTEGRITY_CLOUD_PROJECT_NUMBER"
+ *            android:value="123456789012" />
+ * ```
+ * Read as a long **and** as a string, because Android stores a large
+ * `android:value` as a String — reading only one of the two makes the feature
+ * silently unavailable for most projects.
+ */
+public class PlayIntegritySource : AttestationSource {
+  @Volatile private var provider: StandardIntegrityTokenProvider? = null
+  @Volatile private var warmed = false
+
+  override fun token(context: Context, requestHash: String): String? {
+    val app = context.applicationContext
+    warm(app)
+    val provider = this.provider ?: return null
+
+    return runCatching {
+      Tasks.await(
+          provider.request(
+            StandardIntegrityTokenRequest.builder().setRequestHash(requestHash).build(),
+          ),
+          10,
+          TimeUnit.SECONDS,
+        )
+        .token()
+    }
+      .getOrNull()
+  }
+
+  private fun warm(context: Context) {
+    if (warmed) return
+    warmed = true
+    val projectNumber = cloudProjectNumber(context)
+    // Zero means the app never configured it — a different situation from Play
+    // Integrity being unavailable, and the two need different answers from
+    // support. Neither is an error here: attestation is best-effort and the
+    // install proceeds without it.
+    if (projectNumber == 0L) return
+
+    runCatching {
+      val manager = IntegrityManagerFactory.createStandard(context)
+      provider =
+        Tasks.await(
+          manager.prepareIntegrityToken(
+            PrepareIntegrityTokenRequest.builder().setCloudProjectNumber(projectNumber).build(),
+          ),
+          15,
+          TimeUnit.SECONDS,
+        )
+    }
+  }
+
+  private fun cloudProjectNumber(context: Context): Long =
+    runCatching {
+      val info =
+        context.packageManager.getApplicationInfo(context.packageName, PackageManager.GET_META_DATA)
+      val meta = info.metaData ?: return 0L
+      meta.getLong(META_KEY, 0L).takeIf { it != 0L }
+        ?: meta.getString(META_KEY)?.toLongOrNull()
+        ?: 0L
+    }
+      .getOrDefault(0L)
+
+  private companion object {
+    private const val META_KEY = "io.advenue.INTEGRITY_CLOUD_PROJECT_NUMBER"
+  }
+}

package/android/src/main/kotlin/io/advenue/plugin/PluginRegistry.kt

@@ -0,0 +1,61 @@
+package io.advenue.plugin
+
+import java.util.concurrent.ConcurrentHashMap
+
+/**
+ * Resolves a plugin's entry class by fixed name, once, at initialisation.
+ *
+ * The consumer adds a Gradle line and writes nothing else, which is how Adjust's
+ * ten plugins work — `sdk-core/src/main/java/com/adjust/sdk/Reflection.java`
+ * resolves them the same way.
+ *
+ * **This is not the rejected "compileOnly plus reflection" shape.** There,
+ * reflection wrapped every vendor API call and every one of them was untyped.
+ * Here there is one lookup of *our own* class, at init, and the resolved class
+ * then talks to its dependency with ordinary compile-time typing.
+ *
+ * **ServiceLoader was considered and rejected.** It is the JVM standard and R8
+ * understands it, but its registration lives in a `META-INF/services` resource,
+ * which jar merging and aggressive shrinkers drop silently. A silently absent
+ * referrer plugin is an attribution outage that looks like organic traffic — the
+ * worst failure shape available. A missing class is detectable, and one
+ * `consumerProguardFiles` rule keeps it.
+ */
+public object PluginRegistry {
+  public const val PLAY_REFERRER: String = "io.advenue.plugin.PlayInstallReferrerSource"
+  public const val PLAY_IDENTITY: String = "io.advenue.plugin.PlayAdvertisingIdSource"
+  public const val PLAY_INTEGRITY: String = "io.advenue.plugin.PlayIntegritySource"
+  public const val FIREBASE: String = "io.advenue.plugin.FirebaseAppInstanceIdSource"
+
+  private val cache = ConcurrentHashMap<String, Any>()
+
+  /**
+   * The plugin at [className], or null when the artifact is not on the
+   * classpath — which is the ordinary case, not an error.
+   *
+   * A class that exists but does not implement the contract is a packaging
+   * mistake, and it degrades to "no plugin" rather than taking the host app
+   * down: an SDK that throws during `initialize` crashes an app that merely
+   * mis-declared a dependency.
+   */
+  @Suppress("UNCHECKED_CAST")
+  public inline fun <reified T : Any> load(className: String): T? = loadAs(className, T::class.java)
+
+  @PublishedApi
+  internal fun <T : Any> loadAs(className: String, type: Class<T>): T? {
+    cache[className]?.let { return if (type.isInstance(it)) type.cast(it) else null }
+    return try {
+      val loaded = Class.forName(className).getDeclaredConstructor().newInstance()
+      if (!type.isInstance(loaded)) return null
+      cache[className] = loaded
+      type.cast(loaded)
+    } catch (_: Throwable) {
+      null
+    }
+  }
+
+  /** Test surface: forget what was resolved, so a test can vary the classpath. */
+  internal fun reset() {
+    cache.clear()
+  }
+}