@runanywhere/core 0.16.0

package/android/src/main/java/com/margelo/nitro/runanywhere/HybridRunAnywhereDeviceInfo.kt

@@ -0,0 +1,229 @@
+/**
+ * HybridRunAnywhereDeviceInfo.kt
+ *
+ * Android implementation of device information for RunAnywhere SDK.
+ * Provides device capabilities, memory info, and battery status.
+ */
+
+package com.margelo.nitro.runanywhere
+
+import android.app.ActivityManager
+import android.content.Context
+import android.os.BatteryManager
+import android.os.Build
+import android.os.PowerManager
+import com.margelo.nitro.NitroModules
+import com.margelo.nitro.core.Promise
+import java.io.BufferedReader
+import java.io.File
+import java.io.FileReader
+
+/**
+ * Kotlin implementation of RunAnywhereDeviceInfo HybridObject.
+ * Provides device information and capabilities for the RunAnywhere SDK on Android.
+ */
+class HybridRunAnywhereDeviceInfo : HybridRunAnywhereDeviceInfoSpec() {
+
+    companion object {
+        private val logger = SDKLogger.core
+    }
+
+    private val context = NitroModules.applicationContext ?: error("Android context not found")
+
+    /**
+     * Get device model name
+     */
+    override fun getDeviceModel(): Promise<String> = Promise.async {
+        val manufacturer = Build.MANUFACTURER
+        val model = Build.MODEL
+        if (model.startsWith(manufacturer, ignoreCase = true)) {
+            model.capitalize()
+        } else {
+            "${manufacturer.capitalize()} $model"
+        }
+    }
+
+    /**
+     * Get OS version
+     */
+    override fun getOSVersion(): Promise<String> = Promise.async {
+        Build.VERSION.RELEASE
+    }
+
+    /**
+     * Get platform name
+     */
+    override fun getPlatform(): Promise<String> = Promise.async {
+        "android"
+    }
+
+    /**
+     * Get total RAM in bytes
+     */
+    override fun getTotalRAM(): Promise<Double> = Promise.async {
+        val activityManager = context.getSystemService(Context.ACTIVITY_SERVICE) as ActivityManager
+        val memInfo = ActivityManager.MemoryInfo()
+        activityManager.getMemoryInfo(memInfo)
+        memInfo.totalMem.toDouble()
+    }
+
+    /**
+     * Get available RAM in bytes
+     */
+    override fun getAvailableRAM(): Promise<Double> = Promise.async {
+        val activityManager = context.getSystemService(Context.ACTIVITY_SERVICE) as ActivityManager
+        val memInfo = ActivityManager.MemoryInfo()
+        activityManager.getMemoryInfo(memInfo)
+        memInfo.availMem.toDouble()
+    }
+
+    /**
+     * Get number of CPU cores
+     */
+    override fun getCPUCores(): Promise<Double> = Promise.async {
+        Runtime.getRuntime().availableProcessors().toDouble()
+    }
+
+    /**
+     * Check if device has GPU acceleration
+     */
+    override fun hasGPU(): Promise<Boolean> = Promise.async {
+        // Check for Vulkan support as indicator of modern GPU
+        val hasVulkan = try {
+            val pm = context.packageManager
+            pm.hasSystemFeature("android.hardware.vulkan.level")
+        } catch (e: Exception) {
+            false
+        }
+
+        // Most Android devices have some GPU
+        hasVulkan || Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP
+    }
+
+    /**
+     * Check if device has Neural Engine / NPU
+     */
+    override fun hasNPU(): Promise<Boolean> = Promise.async {
+        // Android Neural Networks API (NNAPI) is available on API 27+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O_MR1) {
+            val hardware = Build.HARDWARE.lowercase()
+            val soc = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+                Build.SOC_MODEL.lowercase()
+            } else {
+                ""
+            }
+
+            listOf(
+                "qcom",      // Qualcomm (Hexagon DSP)
+                "exynos",    // Samsung (NPU)
+                "tensor",    // Google (TPU)
+                "kirin",     // Huawei (NPU)
+                "dimensity", // MediaTek (APU)
+                "mtk"        // MediaTek
+            ).any { hardware.contains(it) || soc.contains(it) }
+        } else {
+            false
+        }
+    }
+
+    /**
+     * Get chip name if available
+     */
+    override fun getChipName(): Promise<String> = Promise.async {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+            val socModel = Build.SOC_MODEL
+            val socManufacturer = Build.SOC_MANUFACTURER
+            if (socModel.isNotEmpty() && socModel != "unknown") {
+                if (socManufacturer.isNotEmpty() && socManufacturer != "unknown") {
+                    "$socManufacturer $socModel"
+                } else {
+                    socModel
+                }
+            } else {
+                getCPUInfo()
+            }
+        } else {
+            getCPUInfo()
+        }
+    }
+
+    /**
+     * Get device thermal state (0 = nominal, 1 = fair, 2 = serious, 3 = critical)
+     */
+    override fun getThermalState(): Promise<Double> = Promise.async {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+            val powerManager = context.getSystemService(Context.POWER_SERVICE) as PowerManager
+            when (powerManager.currentThermalStatus) {
+                PowerManager.THERMAL_STATUS_NONE -> 0.0
+                PowerManager.THERMAL_STATUS_LIGHT -> 0.0
+                PowerManager.THERMAL_STATUS_MODERATE -> 1.0
+                PowerManager.THERMAL_STATUS_SEVERE -> 2.0
+                PowerManager.THERMAL_STATUS_CRITICAL -> 3.0
+                PowerManager.THERMAL_STATUS_EMERGENCY -> 3.0
+                PowerManager.THERMAL_STATUS_SHUTDOWN -> 3.0
+                else -> 0.0
+            }
+        } else {
+            0.0
+        }
+    }
+
+    /**
+     * Get battery level (0.0 to 1.0)
+     */
+    override fun getBatteryLevel(): Promise<Double> = Promise.async {
+        val batteryManager = context.getSystemService(Context.BATTERY_SERVICE) as BatteryManager
+        val level = batteryManager.getIntProperty(BatteryManager.BATTERY_PROPERTY_CAPACITY)
+        level.toDouble() / 100.0
+    }
+
+    /**
+     * Check if device is charging
+     */
+    override fun isCharging(): Promise<Boolean> = Promise.async {
+        val batteryManager = context.getSystemService(Context.BATTERY_SERVICE) as BatteryManager
+        batteryManager.isCharging
+    }
+
+    /**
+     * Check if low power mode is enabled
+     */
+    override fun isLowPowerMode(): Promise<Boolean> = Promise.async {
+        val powerManager = context.getSystemService(Context.POWER_SERVICE) as PowerManager
+        powerManager.isPowerSaveMode
+    }
+
+    /**
+     * Read CPU info from /proc/cpuinfo
+     */
+    private fun getCPUInfo(): String {
+        return try {
+            val cpuInfo = File("/proc/cpuinfo")
+            if (cpuInfo.exists()) {
+                BufferedReader(FileReader(cpuInfo)).use { reader ->
+                    var line: String?
+                    while (reader.readLine().also { line = it } != null) {
+                        if (line?.startsWith("Hardware") == true) {
+                            return line?.substringAfter(":")?.trim() ?: "Unknown"
+                        }
+                        if (line?.startsWith("model name") == true) {
+                            return line?.substringAfter(":")?.trim() ?: "Unknown"
+                        }
+                    }
+                }
+            }
+            Build.HARDWARE
+        } catch (e: Exception) {
+            logger.warning("Failed to read CPU info: ${e.message}")
+            Build.HARDWARE
+        }
+    }
+
+    private fun String.capitalize(): String {
+        return if (isNotEmpty()) {
+            this[0].uppercaseChar() + substring(1)
+        } else {
+            this
+        }
+    }
+}

package/android/src/main/java/com/margelo/nitro/runanywhere/PlatformAdapterBridge.kt

@@ -0,0 +1,392 @@
+/**
+ * PlatformAdapterBridge.kt
+ *
+ * JNI bridge for platform-specific operations (secure storage).
+ * Called from C++ via JNI.
+ *
+ * Reference: sdk/runanywhere-kotlin/src/androidMain/kotlin/com/runanywhere/sdk/security/SecureStorage.kt
+ */
+
+package com.margelo.nitro.runanywhere
+
+import android.util.Log
+
+/**
+ * JNI bridge that C++ code calls for platform operations.
+ * All methods are static and called via JNI from InitBridge.cpp
+ */
+object PlatformAdapterBridge {
+    private const val TAG = "PlatformAdapterBridge"
+
+    /**
+     * Called from C++ to set a secure value
+     */
+    @JvmStatic
+    fun secureSet(key: String, value: String): Boolean {
+        Log.d(TAG, "secureSet key=$key")
+        return SecureStorageManager.set(key, value)
+    }
+
+    /**
+     * Called from C++ to get a secure value
+     */
+    @JvmStatic
+    fun secureGet(key: String): String? {
+        Log.d(TAG, "secureGet key=$key")
+        return SecureStorageManager.get(key)
+    }
+
+    /**
+     * Called from C++ to delete a secure value
+     */
+    @JvmStatic
+    fun secureDelete(key: String): Boolean {
+        Log.d(TAG, "secureDelete key=$key")
+        return SecureStorageManager.delete(key)
+    }
+
+    /**
+     * Called from C++ to check if key exists
+     */
+    @JvmStatic
+    fun secureExists(key: String): Boolean {
+        return SecureStorageManager.exists(key)
+    }
+
+    /**
+     * Called from C++ to get persistent device UUID
+     */
+    @JvmStatic
+    fun getPersistentDeviceUUID(): String {
+        Log.d(TAG, "getPersistentDeviceUUID")
+        return SecureStorageManager.getPersistentDeviceUUID()
+    }
+
+    // ========================================================================
+    // HTTP POST for Device Registration (Synchronous)
+    // Matches Kotlin SDK's CppBridgeDevice.httpPost
+    // ========================================================================
+
+    /**
+     * HTTP response data class
+     */
+    data class HttpResponse(
+        val success: Boolean,
+        val statusCode: Int,
+        val responseBody: String?,
+        val errorMessage: String?
+    )
+
+    /**
+     * Synchronous HTTP POST for device registration
+     * Called from C++ device manager callbacks via JNI
+     *
+     * @param url Full URL to POST to
+     * @param jsonBody JSON body string
+     * @param supabaseKey Supabase API key (for dev mode, can be null)
+     * @return HttpResponse with result
+     */
+    @JvmStatic
+    fun httpPostSync(url: String, jsonBody: String, supabaseKey: String?): HttpResponse {
+        Log.d(TAG, "httpPostSync to: $url")
+        // Log first 300 chars of JSON body for debugging
+        Log.d(TAG, "httpPostSync body (first 300 chars): ${jsonBody.take(300)}")
+
+        // For Supabase device registration, add ?on_conflict=device_id for UPSERT
+        // This matches Swift's HTTPService.swift logic
+        var finalUrl = url
+        if (url.contains("/rest/v1/sdk_devices") && !url.contains("on_conflict=")) {
+            val separator = if (url.contains("?")) "&" else "?"
+            finalUrl = "$url${separator}on_conflict=device_id"
+            Log.d(TAG, "Added on_conflict for UPSERT: $finalUrl")
+        }
+
+        return try {
+            val urlConnection = java.net.URL(finalUrl).openConnection() as java.net.HttpURLConnection
+            urlConnection.requestMethod = "POST"
+            urlConnection.connectTimeout = 30000
+            urlConnection.readTimeout = 30000
+            urlConnection.doOutput = true
+
+            // Headers
+            urlConnection.setRequestProperty("Content-Type", "application/json")
+            urlConnection.setRequestProperty("Accept", "application/json")
+
+            // Supabase headers (for device registration UPSERT)
+            if (!supabaseKey.isNullOrEmpty()) {
+                urlConnection.setRequestProperty("apikey", supabaseKey)
+                urlConnection.setRequestProperty("Authorization", "Bearer $supabaseKey")
+                urlConnection.setRequestProperty("Prefer", "resolution=merge-duplicates")
+            }
+
+            // Write body
+            urlConnection.outputStream.use { os ->
+                os.write(jsonBody.toByteArray(Charsets.UTF_8))
+            }
+
+            val statusCode = urlConnection.responseCode
+            val responseBody = try {
+                urlConnection.inputStream.bufferedReader().use { it.readText() }
+            } catch (e: Exception) {
+                urlConnection.errorStream?.bufferedReader()?.use { it.readText() }
+            }
+
+            // 2xx or 409 (conflict/already exists) = success for device registration
+            val isSuccess = statusCode in 200..299 || statusCode == 409
+
+            Log.d(TAG, "httpPostSync completed: status=$statusCode success=$isSuccess")
+            if (!isSuccess) {
+                Log.e(TAG, "httpPostSync error response: $responseBody")
+            }
+
+            HttpResponse(
+                success = isSuccess,
+                statusCode = statusCode,
+                responseBody = responseBody,
+                errorMessage = if (!isSuccess) "HTTP $statusCode" else null
+            )
+        } catch (e: Exception) {
+            Log.e(TAG, "httpPostSync error", e)
+            HttpResponse(
+                success = false,
+                statusCode = 0,
+                responseBody = null,
+                errorMessage = e.message ?: "Unknown error"
+            )
+        }
+    }
+
+    // ========================================================================
+    // Device Info (Synchronous)
+    // For device registration callback which must be synchronous
+    // ========================================================================
+
+    /**
+     * Get device model name (e.g., "Pixel 8 Pro")
+     */
+    @JvmStatic
+    fun getDeviceModel(): String {
+        return android.os.Build.MODEL
+    }
+
+    /**
+     * Get OS version (e.g., "14")
+     */
+    @JvmStatic
+    fun getOSVersion(): String {
+        return android.os.Build.VERSION.RELEASE
+    }
+
+    /**
+     * Get chip name (e.g., "Tensor G3")
+     */
+    @JvmStatic
+    fun getChipName(): String {
+        return android.os.Build.HARDWARE
+    }
+
+    /**
+     * Get total memory in bytes
+     */
+    @JvmStatic
+    fun getTotalMemory(): Long {
+        // Try ActivityManager first (needs Context)
+        val context = SecureStorageManager.getContext()
+        if (context != null) {
+            try {
+                val activityManager = context.getSystemService(android.content.Context.ACTIVITY_SERVICE) as? android.app.ActivityManager
+                val memInfo = android.app.ActivityManager.MemoryInfo()
+                activityManager?.getMemoryInfo(memInfo)
+                if (memInfo.totalMem > 0) {
+                    return memInfo.totalMem
+                }
+            } catch (e: Exception) {
+                Log.w(TAG, "getTotalMemory via ActivityManager failed: ${e.message}")
+            }
+        }
+        
+        // Fallback: Read from /proc/meminfo (works without Context)
+        try {
+            val memInfoFile = java.io.File("/proc/meminfo")
+            if (memInfoFile.exists()) {
+                memInfoFile.bufferedReader().use { reader ->
+                    val line = reader.readLine() // First line: MemTotal: ...
+                    if (line != null && line.startsWith("MemTotal:")) {
+                        val parts = line.split("\\s+".toRegex())
+                        if (parts.size >= 2) {
+                            val kB = parts[1].toLongOrNull() ?: 0L
+                            return kB * 1024 // Convert KB to bytes
+                        }
+                    }
+                }
+            }
+        } catch (e: Exception) {
+            Log.w(TAG, "getTotalMemory via /proc/meminfo failed: ${e.message}")
+        }
+        
+        // Last resort: Return a reasonable default for modern phones (4GB)
+        return 4L * 1024 * 1024 * 1024
+    }
+
+    /**
+     * Get available memory in bytes
+     */
+    @JvmStatic
+    fun getAvailableMemory(): Long {
+        // Try ActivityManager first (needs Context)
+        val context = SecureStorageManager.getContext()
+        if (context != null) {
+            try {
+                val activityManager = context.getSystemService(android.content.Context.ACTIVITY_SERVICE) as? android.app.ActivityManager
+                val memInfo = android.app.ActivityManager.MemoryInfo()
+                activityManager?.getMemoryInfo(memInfo)
+                if (memInfo.availMem > 0) {
+                    return memInfo.availMem
+                }
+            } catch (e: Exception) {
+                Log.w(TAG, "getAvailableMemory via ActivityManager failed: ${e.message}")
+            }
+        }
+        
+        // Fallback: Read from /proc/meminfo (works without Context)
+        try {
+            val memInfoFile = java.io.File("/proc/meminfo")
+            if (memInfoFile.exists()) {
+                memInfoFile.bufferedReader().use { reader ->
+                    var line = reader.readLine()
+                    while (line != null) {
+                        if (line.startsWith("MemAvailable:")) {
+                            val parts = line.split("\\s+".toRegex())
+                            if (parts.size >= 2) {
+                                val kB = parts[1].toLongOrNull() ?: 0L
+                                return kB * 1024 // Convert KB to bytes
+                            }
+                        }
+                        line = reader.readLine()
+                    }
+                }
+            }
+        } catch (e: Exception) {
+            Log.w(TAG, "getAvailableMemory via /proc/meminfo failed: ${e.message}")
+        }
+        
+        // Last resort: Return half of total as estimate
+        return getTotalMemory() / 2
+    }
+
+    /**
+     * Get CPU core count
+     */
+    @JvmStatic
+    fun getCoreCount(): Int {
+        return Runtime.getRuntime().availableProcessors()
+    }
+
+    /**
+     * Get architecture (e.g., "arm64-v8a")
+     */
+    @JvmStatic
+    fun getArchitecture(): String {
+        return android.os.Build.SUPPORTED_ABIS.firstOrNull() ?: "unknown"
+    }
+
+    /**
+     * Get GPU family based on chip name
+     * Infers GPU vendor from known chip manufacturers:
+     * - Google Tensor/Pixel → Mali
+     * - Samsung Exynos → Mali
+     * - Qualcomm Snapdragon → Adreno
+     * - MediaTek → Mali (mostly)
+     * - HiSilicon Kirin → Mali
+     *
+     * Aligned with Kotlin SDK's CppBridgeDevice.getDefaultGPUFamily()
+     */
+    @JvmStatic
+    fun getGPUFamily(): String {
+        val chipName = getChipName().lowercase()
+        val manufacturer = android.os.Build.MANUFACTURER.lowercase()
+        
+        return when {
+            // Google Pixel codenames (all use Mali GPUs from Samsung/Google Tensor)
+            chipName == "bluejay" -> "mali"      // Pixel 6a (Tensor)
+            chipName == "oriole" -> "mali"       // Pixel 6 (Tensor)
+            chipName == "raven" -> "mali"        // Pixel 6 Pro (Tensor)
+            chipName == "cheetah" -> "mali"      // Pixel 7 (Tensor G2)
+            chipName == "panther" -> "mali"      // Pixel 7 Pro (Tensor G2)
+            chipName == "lynx" -> "mali"         // Pixel 7a (Tensor G2)
+            chipName == "tangorpro" -> "mali"    // Pixel Tablet (Tensor G2)
+            chipName == "shiba" -> "mali"        // Pixel 8 (Tensor G3)
+            chipName == "husky" -> "mali"        // Pixel 8 Pro (Tensor G3)
+            chipName == "akita" -> "mali"        // Pixel 8a (Tensor G3)
+            chipName == "caiman" -> "mali"       // Pixel 9 (Tensor G4)
+            chipName == "komodo" -> "mali"       // Pixel 9 Pro (Tensor G4)
+            chipName == "comet" -> "mali"        // Pixel 9 Pro XL (Tensor G4)
+            chipName == "tokay" -> "mali"        // Pixel 9 Pro Fold (Tensor G4)
+            
+            // Google Tensor generic patterns
+            chipName.contains("tensor") -> "mali"
+            chipName.contains("gs1") -> "mali"   // GS101 (Tensor)
+            chipName.contains("gs2") -> "mali"   // GS201 (Tensor G2)
+            chipName.contains("zuma") -> "mali"  // Zuma (Tensor G3)
+            manufacturer == "google" -> "mali"   // Default for Google devices
+            
+            // Samsung Exynos uses Mali GPUs
+            chipName.contains("exynos") -> "mali"
+            chipName.startsWith("s5e") -> "mali" // Samsung internal naming (e.g., s5e8535)
+            chipName.contains("samsung") -> "mali"
+            
+            // Qualcomm Snapdragon uses Adreno GPUs
+            chipName.contains("snapdragon") -> "adreno"
+            chipName.contains("qualcomm") -> "adreno"
+            chipName.contains("sdm") -> "adreno" // SDM845, SDM855, etc.
+            chipName.contains("sm8") -> "adreno" // SM8150, SM8250, etc.
+            chipName.contains("sm7") -> "adreno" // SM7150, etc.
+            chipName.contains("sm6") -> "adreno" // SM6150, etc.
+            chipName.contains("msm") -> "adreno" // Older MSM chips
+            chipName.contains("kona") -> "adreno" // Snapdragon 865
+            chipName.contains("lahaina") -> "adreno" // Snapdragon 888
+            chipName.contains("taro") -> "adreno" // Snapdragon 8 Gen 1
+            chipName.contains("kalama") -> "adreno" // Snapdragon 8 Gen 2
+            chipName.contains("pineapple") -> "adreno" // Snapdragon 8 Gen 3
+            manufacturer == "qualcomm" -> "adreno"
+            
+            // MediaTek uses Mali GPUs (mostly)
+            chipName.contains("mediatek") -> "mali"
+            chipName.contains("mt6") -> "mali"   // MT6xxx series
+            chipName.contains("mt8") -> "mali"   // MT8xxx series
+            chipName.contains("dimensity") -> "mali"
+            chipName.contains("helio") -> "mali"
+            
+            // HiSilicon Kirin uses Mali GPUs
+            chipName.contains("kirin") -> "mali"
+            chipName.contains("hisilicon") -> "mali"
+            
+            // Intel/x86 GPUs
+            chipName.contains("intel") -> "intel"
+            
+            // NVIDIA (rare on mobile)
+            chipName.contains("nvidia") -> "nvidia"
+            chipName.contains("tegra") -> "nvidia"
+            
+            else -> "unknown"
+        }
+    }
+
+    /**
+     * Check if device is a tablet
+     * Uses screen size configuration to determine form factor
+     * Matches Swift SDK: device.userInterfaceIdiom == .pad
+     */
+    @JvmStatic
+    fun isTablet(): Boolean {
+        val context = SecureStorageManager.getContext()
+        if (context != null) {
+            val screenLayout = context.resources.configuration.screenLayout and 
+                android.content.res.Configuration.SCREENLAYOUT_SIZE_MASK
+            return screenLayout >= android.content.res.Configuration.SCREENLAYOUT_SIZE_LARGE
+        }
+        // Fallback: Check display metrics if context unavailable
+        return false
+    }
+}
+

package/android/src/main/java/com/margelo/nitro/runanywhere/RunAnywhereCorePackage.kt

@@ -0,0 +1,28 @@
+package com.margelo.nitro.runanywhere
+
+import android.util.Log
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfoProvider
+
+class RunAnywhereCorePackage : BaseReactPackage() {
+    override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+        // Initialize secure storage with application context
+        SecureStorageManager.initialize(reactContext.applicationContext)
+        return null
+    }
+
+    override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
+        return ReactModuleInfoProvider { HashMap() }
+    }
+
+    companion object {
+        private const val TAG = "RunAnywhereCorePackage"
+        
+        init {
+            System.loadLibrary("runanywherecore")
+            Log.i(TAG, "Loaded native library: runanywherecore")
+        }
+    }
+}