react-native-cliqit 0.0.1

package/android/src/main/java/com/cliqit/sdk/CliqItDeviceInfo.kt

@@ -0,0 +1,196 @@
+package com.cliqit.sdk
+
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.content.pm.PackageManager
+import android.content.res.Configuration
+import android.net.ConnectivityManager
+import android.net.NetworkCapabilities
+import android.os.BatteryManager
+import android.os.Build
+import android.util.DisplayMetrics
+import android.view.WindowManager
+import java.security.MessageDigest
+import java.util.Currency
+import java.util.Locale
+import java.util.TimeZone
+
+internal object CliqItDeviceInfo {
+  fun osVersionMajor(): String =
+    Build.VERSION.RELEASE.substringBefore('.').ifEmpty { Build.VERSION.SDK_INT.toString() }
+
+  fun osVersionMajorMinor(): String {
+    val parts = Build.VERSION.RELEASE.split('.')
+    return when {
+      parts.size >= 2 -> "${parts[0]}.${parts[1]}"
+      parts.isNotEmpty() -> parts[0]
+      else -> Build.VERSION.SDK_INT.toString()
+    }
+  }
+
+  fun deviceName(): String = Build.MODEL ?: "unknown"
+
+  fun matchLocale(): String =
+    Locale.getDefault().toLanguageTag().ifEmpty { Locale.getDefault().toString().replace('_', '-') }
+
+  fun languagesOrdered(): String {
+    return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+      val list = android.os.LocaleList.getDefault()
+      (0 until list.size()).joinToString(",") { i -> list[i].toLanguageTag() }
+        .ifEmpty { Locale.getDefault().toLanguageTag() }
+    } else {
+      Locale.getDefault().toLanguageTag()
+    }
+  }
+
+  fun boldText(context: Context): Boolean {
+    return try {
+      android.provider.Settings.Secure.getInt(
+        context.contentResolver,
+        "accessibility_bold_text",
+        0,
+      ) == 1
+    } catch (_: Exception) {
+      false
+    }
+  }
+
+  fun reduceMotion(context: Context): Boolean {
+    return try {
+      val scale = android.provider.Settings.Global.getFloat(
+        context.contentResolver,
+        android.provider.Settings.Global.TRANSITION_ANIMATION_SCALE,
+        1f,
+      )
+      scale == 0f
+    } catch (_: Exception) {
+      false
+    }
+  }
+
+  fun increaseContrast(context: Context): Boolean {
+    return try {
+      android.provider.Settings.Secure.getInt(
+        context.contentResolver,
+        "high_text_contrast_enabled",
+        0,
+      ) == 1
+    } catch (_: Exception) {
+      false
+    }
+  }
+
+  fun timezone(): String = TimeZone.getDefault().id
+
+  fun screenBucket(context: Context): String {
+    val metrics = DisplayMetrics()
+    @Suppress("DEPRECATION")
+    (context.getSystemService(Context.WINDOW_SERVICE) as WindowManager).defaultDisplay.getMetrics(metrics)
+    val minSide = minOf(metrics.widthPixels, metrics.heightPixels).toFloat() / metrics.density
+    val maxSide = maxOf(metrics.widthPixels, metrics.heightPixels).toFloat() / metrics.density
+    return when {
+      minSide >= 600 -> "tablet"
+      maxSide >= 800 -> "large"
+      maxSide >= 700 -> "medium"
+      else -> "small"
+    }
+  }
+
+  fun colorScheme(context: Context): String {
+    val night = context.resources.configuration.uiMode and Configuration.UI_MODE_NIGHT_MASK
+    return if (night == Configuration.UI_MODE_NIGHT_YES) "dark" else "light"
+  }
+
+  fun hourCycle(): String {
+    val pattern = android.text.format.DateFormat.getBestDateTimePattern(Locale.getDefault(), "j")
+    return if (pattern.contains('a')) "h12" else "h24"
+  }
+
+  fun currencyCode(): String? = try {
+    Currency.getInstance(Locale.getDefault()).currencyCode
+  } catch (_: Exception) {
+    null
+  }
+
+  fun regionCode(): String? = Locale.getDefault().country.takeIf { it.isNotEmpty() }
+
+  /// Matches iOS / web: `"high"` (≥2×) or `"standard"`.
+  fun devicePixelRatioBucket(context: Context): String {
+    val density = context.resources.displayMetrics.density
+    return if (density >= 2.0f) "high" else "standard"
+  }
+
+  fun battery(context: Context): Pair<Double?, Boolean?> {
+    val intent = context.registerReceiver(null, IntentFilter(Intent.ACTION_BATTERY_CHANGED))
+      ?: return null to null
+    val level = intent.getIntExtra(BatteryManager.EXTRA_LEVEL, -1)
+    val scale = intent.getIntExtra(BatteryManager.EXTRA_SCALE, -1)
+    val status = intent.getIntExtra(BatteryManager.EXTRA_STATUS, -1)
+    val pct = if (level >= 0 && scale > 0) level.toDouble() / scale.toDouble() else null
+    val charging = status == BatteryManager.BATTERY_STATUS_CHARGING ||
+      status == BatteryManager.BATTERY_STATUS_FULL
+    return pct to charging
+  }
+
+  fun connectionType(context: Context): String? {
+    val cm = context.getSystemService(Context.CONNECTIVITY_SERVICE) as? ConnectivityManager ?: return null
+    val network = cm.activeNetwork ?: return null
+    val caps = cm.getNetworkCapabilities(network) ?: return null
+    return when {
+      caps.hasTransport(NetworkCapabilities.TRANSPORT_WIFI) -> "wifi"
+      caps.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR) -> "cellular"
+      caps.hasTransport(NetworkCapabilities.TRANSPORT_ETHERNET) -> "ethernet"
+      else -> "other"
+    }
+  }
+
+  fun hardwareConcurrency(): Int = Runtime.getRuntime().availableProcessors()
+
+  fun fontScale(context: Context): String {
+    val scale = context.resources.configuration.fontScale
+    return when {
+      scale <= 0.85f -> "S"
+      scale <= 1.0f -> "M"
+      scale <= 1.15f -> "L"
+      scale <= 1.3f -> "XL"
+      else -> "XXL"
+    }
+  }
+
+  fun packageName(context: Context): String = context.packageName
+
+  /** Signing cert SHA-256, colon-separated uppercase (same style as keytool / assetlinks). */
+  fun androidSha256(context: Context): String? {
+    return try {
+      val pm = context.packageManager
+      val packageName = context.packageName
+      val signatures: Array<android.content.pm.Signature> = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+        val info = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+          pm.getPackageInfo(
+            packageName,
+            PackageManager.PackageInfoFlags.of(PackageManager.GET_SIGNING_CERTIFICATES.toLong()),
+          )
+        } else {
+          @Suppress("DEPRECATION")
+          pm.getPackageInfo(packageName, PackageManager.GET_SIGNING_CERTIFICATES)
+        }
+        val signingInfo = info.signingInfo ?: return null
+        if (signingInfo.hasMultipleSigners()) {
+          signingInfo.apkContentsSigners
+        } else {
+          signingInfo.signingCertificateHistory
+        }
+      } else {
+        @Suppress("DEPRECATION")
+        pm.getPackageInfo(packageName, PackageManager.GET_SIGNATURES).signatures
+      } ?: return null
+
+      val cert = signatures.firstOrNull()?.toByteArray() ?: return null
+      val digest = MessageDigest.getInstance("SHA-256").digest(cert)
+      digest.joinToString(":") { b -> "%02X".format(b) }
+    } catch (e: Exception) {
+      null
+    }
+  }
+}

package/android/src/main/java/com/cliqit/sdk/CliqItHttp.kt

@@ -0,0 +1,98 @@
+package com.cliqit.sdk
+
+import org.json.JSONObject
+import java.io.BufferedReader
+import java.io.InputStreamReader
+import java.io.OutputStreamWriter
+import java.net.HttpURLConnection
+import java.net.URL
+
+internal object CliqItHttp {
+  data class Response(val statusCode: Int, val body: String)
+
+  fun get(url: String, apiKey: String): Result<Response> =
+    request(url, "GET", apiKey, null)
+
+  fun postJson(url: String, apiKey: String, jsonBody: String): Result<Response> =
+    request(url, "POST", apiKey, jsonBody)
+
+  private fun request(
+    url: String,
+    method: String,
+    apiKey: String,
+    jsonBody: String?,
+  ): Result<Response> {
+    var lastError = "Request failed"
+    repeat(CliqItDefaults.MAX_RETRY) { attempt ->
+      if (attempt > 0) {
+        Thread.sleep(CliqItDefaults.RETRY_INITIAL_DELAY_MS * (1L shl (attempt - 1)))
+      }
+      try {
+        val conn = (URL(url).openConnection() as HttpURLConnection).apply {
+          requestMethod = method
+          connectTimeout = 15_000
+          readTimeout = 20_000
+          setRequestProperty(CliqItDefaults.API_KEY_HEADER, apiKey)
+          setRequestProperty("Accept", "application/json")
+          if (jsonBody != null) {
+            doOutput = true
+            setRequestProperty("Content-Type", "application/json")
+          }
+        }
+        if (jsonBody != null) {
+          OutputStreamWriter(conn.outputStream, Charsets.UTF_8).use { it.write(jsonBody) }
+        }
+        val code = conn.responseCode
+        val stream = if (code in 200..299) conn.inputStream else conn.errorStream
+        val body = stream?.let { BufferedReader(InputStreamReader(it, Charsets.UTF_8)).readText() }.orEmpty()
+        conn.disconnect()
+
+        if (code in 200..299) {
+          return Result.success(Response(code, body))
+        }
+        lastError = "Request failed ($code): ${body.ifEmpty { "empty" }}"
+        if (code == 408 || code == 429 || code in 500..599) {
+          // retry
+        } else {
+          return Result.failure(Exception(lastError))
+        }
+      } catch (e: Exception) {
+        lastError = e.message ?: "Request failed"
+      }
+    }
+    return Result.failure(Exception(lastError))
+  }
+
+  fun joinUrl(base: String, vararg parts: String): String {
+    val trimmedBase = base.trimEnd('/')
+    val path = parts.joinToString("/") { it.trim('/') }
+    return "$trimmedBase/$path"
+  }
+
+  /** Append platform identity query params (same fields as verify / match body). */
+  fun appendIdentityQuery(url: String, context: android.content.Context): String {
+    val sep = if (url.contains('?')) '&' else '?'
+    val platform = "platform=android"
+    val packageName = "packageName=${java.net.URLEncoder.encode(CliqItDeviceInfo.packageName(context), Charsets.UTF_8.name())}"
+    val sha = CliqItDeviceInfo.androidSha256(context)?.let {
+      "&androidSha256=${java.net.URLEncoder.encode(it, Charsets.UTF_8.name())}"
+    }.orEmpty()
+    return "$url$sep$platform&$packageName$sha"
+  }
+
+  fun optString(obj: JSONObject?, key: String): String? {
+    if (obj == null || !obj.has(key) || obj.isNull(key)) return null
+    val v = obj.optString(key, "")
+    return v.takeIf { it.isNotEmpty() && !it.equals("null", ignoreCase = true) }
+  }
+
+  fun optBool(obj: JSONObject?, key: String): Boolean? {
+    if (obj == null || !obj.has(key) || obj.isNull(key)) return null
+    return obj.optBoolean(key)
+  }
+
+  fun optDouble(obj: JSONObject?, key: String): Double? {
+    if (obj == null || !obj.has(key) || obj.isNull(key)) return null
+    return obj.optDouble(key).takeUnless { it.isNaN() }
+  }
+}

package/android/src/main/java/com/cliqit/sdk/CliqItModels.kt

@@ -0,0 +1,130 @@
+package com.cliqit.sdk
+
+/** Mirrors iOS `CliqItLinkField`. */
+object LinkField {
+  const val destination = "destination"
+  const val iosDestination = "iosDestination"
+  const val androidDestination = "androidDestination"
+  const val ogTitle = "ogTitle"
+  const val ogDescription = "ogDescription"
+  const val ogImage = "ogImage"
+  const val ogUrl = "ogUrl"
+  const val slug = "slug"
+  const val webFallback = "webFallback"
+  const val showInterstitial = "showInterstitial"
+  const val isDeepLink = "isDeepLink"
+  const val appleTeamId = "appleTeamId"
+  const val iosBundleId = "iosBundleId"
+  const val androidPackageName = "androidPackageName"
+  const val resolvedPath = "resolvedPath"
+}
+
+data class CliqItPayload(
+  val url: String,
+  val path: String,
+  val pathComponents: List<String>,
+  val query: Map<String, String>,
+  val source: String,
+  val isDeferred: Boolean,
+)
+
+data class DeferredMatchInfo(
+  val matched: Boolean,
+  val tier: String?,
+  val confidence: String?,
+  val score: Double?,
+  val destinationPath: String?,
+  val slug: String?,
+)
+
+sealed class DeferredMatchOutcome {
+  data class Matched(val info: DeferredMatchInfo) : DeferredMatchOutcome()
+  data class NotMatched(val info: DeferredMatchInfo) : DeferredMatchOutcome()
+  data class Failed(val error: String) : DeferredMatchOutcome()
+}
+
+data class LinkDetails(
+  val destination: String?,
+  val iosDestination: String?,
+  val androidDestination: String?,
+  val ogTitle: String?,
+  val ogDescription: String?,
+  val ogImage: String?,
+  val ogUrl: String?,
+  val slug: String?,
+  val webFallback: String?,
+  val showInterstitial: Boolean?,
+  val isDeepLink: Boolean?,
+  val appleTeamId: String?,
+  val iosBundleId: String?,
+  val androidPackageName: String?,
+) {
+  /** Android: `androidDestination` ?? `destination`. */
+  val resolvedPath: String?
+    get() = normalizePath(androidDestination) ?: normalizePath(destination)
+
+  fun field(key: String): String? = when (key) {
+    LinkField.destination -> destination
+    LinkField.iosDestination -> iosDestination
+    LinkField.androidDestination -> androidDestination
+    LinkField.ogTitle -> ogTitle
+    LinkField.ogDescription -> ogDescription
+    LinkField.ogImage -> ogImage
+    LinkField.ogUrl -> ogUrl
+    LinkField.slug -> slug
+    LinkField.webFallback -> webFallback
+    LinkField.showInterstitial -> showInterstitial?.toString()
+    LinkField.isDeepLink -> isDeepLink?.toString()
+    LinkField.appleTeamId -> appleTeamId
+    LinkField.iosBundleId -> iosBundleId
+    LinkField.androidPackageName -> androidPackageName
+    LinkField.resolvedPath -> resolvedPath
+    else -> null
+  }
+
+  companion object {
+    fun normalizePath(raw: String?): String? {
+      var value = raw?.trim().orEmpty()
+      if (value.isEmpty() || value.equals("null", ignoreCase = true)) return null
+      if (!value.startsWith("/")) value = "/$value"
+      return value
+    }
+  }
+}
+
+sealed class VerifyOutcome {
+  data class Passed(val result: VerifyResult) : VerifyOutcome()
+  data class Mismatched(val result: VerifyResult) : VerifyOutcome()
+  data class Error(val message: String) : VerifyOutcome()
+}
+
+data class VerifyCheck(
+  val actual: String?,
+  val expected: String?,
+  val match: Boolean,
+)
+
+data class VerifyResult(
+  val ok: Boolean,
+  val appId: String?,
+  val appName: String?,
+  val checks: Map<String, VerifyCheck>,
+  val rawJSON: String,
+) {
+  val failedChecks: List<Pair<String, VerifyCheck>>
+    get() = checks.filter { !it.value.match }.toList().sortedBy { it.first }
+
+  val mismatchMessage: String
+    get() {
+      if (ok) return "Verify OK"
+      if (failedChecks.isEmpty()) return "Verify failed (ok=false)"
+      return failedChecks.joinToString("; ") { (field, check) ->
+        "$field: actual=${check.actual ?: "-"} expected=${check.expected ?: "-"}"
+      }
+    }
+}
+
+sealed class LinkLookupResult {
+  data class Resolved(val details: LinkDetails) : LinkLookupResult()
+  data class Failed(val error: String) : LinkLookupResult()
+}