@thelacanians/vue-native-cli 0.4.3 → 0.4.4

package/native/android/VueNativeCore/src/main/kotlin/com/vuenative/core/Modules/NotificationsModule.kt

@@ -0,0 +1,181 @@
+package com.vuenative.core
+
+import android.Manifest
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.content.Context
+import android.content.pm.PackageManager
+import android.os.Build
+import android.os.Handler
+import android.os.Looper
+import androidx.core.app.ActivityCompat
+import androidx.core.app.NotificationCompat
+import androidx.core.app.NotificationManagerCompat
+
+/**
+ * Native module for local and remote (push) notifications.
+ *
+ * For push notifications, the host app must:
+ * 1. Add Firebase Messaging dependency to their app-level build.gradle
+ * 2. Create a FirebaseMessagingService subclass that calls
+ *    NotificationsModule.onNewToken() and onPushReceived()
+ *
+ * Methods:
+ *   - requestPermission() -> { status: "granted"|"denied" }
+ *   - scheduleLocal(opts) -> { id }
+ *   - cancel(id)
+ *   - cancelAll()
+ *   - registerForPush() -> true (no-op on Android; FCM auto-registers)
+ *   - getToken() -> String? (returns cached FCM token)
+ *
+ * Global events:
+ *   "notification:received" -- local notification tapped
+ *   "push:token"     { token }
+ *   "push:received"  { title, body, data, remote: true }
+ */
+class NotificationsModule : NativeModule {
+    override val moduleName = "Notifications"
+
+    private var context: Context? = null
+    private var bridge: NativeBridge? = null
+    private val handler = Handler(Looper.getMainLooper())
+    private var notifIdCounter = 1
+
+    companion object {
+        private const val CHANNEL_ID = "vue_native_default"
+
+        /** Singleton reference so FirebaseMessagingService can call into this module. */
+        @Volatile
+        var instance: NotificationsModule? = null
+            private set
+    }
+
+    override fun initialize(context: Context, bridge: NativeBridge) {
+        this.context = context
+        this.bridge = bridge
+        instance = this
+        createDefaultChannel(context)
+    }
+
+    private fun createDefaultChannel(ctx: Context) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            val channel = NotificationChannel(
+                CHANNEL_ID,
+                "Notifications",
+                NotificationManager.IMPORTANCE_DEFAULT
+            ).apply {
+                description = "Vue Native app notifications"
+            }
+            ctx.getSystemService(NotificationManager::class.java)
+                ?.createNotificationChannel(channel)
+        }
+    }
+
+    // -------------------------------------------------------------------------
+    // Push token handling (called from FirebaseMessagingService in host app)
+    // -------------------------------------------------------------------------
+
+    /** Cached FCM token. Volatile because onNewToken() is called from FCM background thread
+     *  while getToken() may be called from the module invocation thread. */
+    @Volatile
+    private var fcmToken: String? = null
+
+    /**
+     * Called by the host app's FirebaseMessagingService.onNewToken().
+     */
+    fun onNewToken(token: String) {
+        fcmToken = token
+        bridge?.dispatchGlobalEvent("push:token", mapOf("token" to token))
+    }
+
+    /**
+     * Called by the host app's FirebaseMessagingService.onMessageReceived().
+     */
+    fun onPushReceived(title: String, body: String, data: Map<String, String>) {
+        bridge?.dispatchGlobalEvent("push:received", mapOf(
+            "title" to title,
+            "body" to body,
+            "data" to data,
+            "remote" to true
+        ))
+    }
+
+    // -------------------------------------------------------------------------
+    // Module invocation
+    // -------------------------------------------------------------------------
+
+    override fun invoke(
+        method: String,
+        args: List<Any?>,
+        bridge: NativeBridge,
+        callback: (Any?, String?) -> Unit
+    ) {
+        when (method) {
+            "requestPermission" -> {
+                // Android <13: no runtime permission needed for notifications
+                // Android 13+: POST_NOTIFICATIONS must be granted via PermissionsModule
+                val granted = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+                    val ctx = context ?: run { callback(null, "Not initialized"); return }
+                    ActivityCompat.checkSelfPermission(ctx, Manifest.permission.POST_NOTIFICATIONS) ==
+                            PackageManager.PERMISSION_GRANTED
+                } else {
+                    true
+                }
+                callback(mapOf("status" to if (granted) "granted" else "denied"), null)
+            }
+            "scheduleLocal" -> {
+                val ctx = context ?: run { callback(null, "Not initialized"); return }
+                val opts = args.getOrNull(0) as? Map<*, *>
+                    ?: run { callback(null, "Invalid args — expected options object"); return }
+
+                val title = opts["title"]?.toString() ?: ""
+                val body = opts["body"]?.toString() ?: ""
+                val delaySeconds = (opts["delay"] as? Number)?.toLong() ?: 0L
+                val notifId = notifIdCounter++
+
+                val show = Runnable {
+                    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU ||
+                        ActivityCompat.checkSelfPermission(ctx, Manifest.permission.POST_NOTIFICATIONS)
+                        == PackageManager.PERMISSION_GRANTED
+                    ) {
+                        val notification = NotificationCompat.Builder(ctx, CHANNEL_ID)
+                            .setSmallIcon(android.R.drawable.ic_dialog_info)
+                            .setContentTitle(title)
+                            .setContentText(body)
+                            .setPriority(NotificationCompat.PRIORITY_DEFAULT)
+                            .setAutoCancel(true)
+                            .build()
+                        NotificationManagerCompat.from(ctx).notify(notifId, notification)
+                    }
+                }
+
+                if (delaySeconds > 0) {
+                    handler.postDelayed(show, delaySeconds * 1000L)
+                } else {
+                    show.run()
+                }
+                callback(mapOf("id" to notifId), null)
+            }
+            "cancel" -> {
+                val ctx = context ?: run { callback(null, "Not initialized"); return }
+                val id = (args.getOrNull(0) as? Number)?.toInt()
+                    ?: run { callback(null, "Invalid args — expected notification id"); return }
+                NotificationManagerCompat.from(ctx).cancel(id)
+                callback(null, null)
+            }
+            "cancelAll" -> {
+                val ctx = context ?: run { callback(null, "Not initialized"); return }
+                NotificationManagerCompat.from(ctx).cancelAll()
+                callback(null, null)
+            }
+            "registerForPush" -> {
+                // On Android, FCM auto-registers. This is a no-op for API parity with iOS.
+                callback(true, null)
+            }
+            "getToken" -> {
+                callback(fcmToken, null)
+            }
+            else -> callback(null, "Unknown method: $method")
+        }
+    }
+}

package/native/android/VueNativeCore/src/main/kotlin/com/vuenative/core/Modules/OTAModule.kt

@@ -0,0 +1,255 @@
+package com.vuenative.core
+
+import android.content.Context
+import android.content.SharedPreferences
+import android.util.Log
+import okhttp3.*
+import java.io.File
+import java.io.FileOutputStream
+import java.io.IOException
+import java.security.MessageDigest
+
+/**
+ * Native module for Over-The-Air (OTA) JS bundle updates.
+ *
+ * Methods:
+ *   - checkForUpdate(serverUrl) — check for available updates
+ *   - downloadUpdate(url, hash) — download a new bundle and verify integrity
+ *   - applyUpdate() — swap to downloaded bundle on next launch
+ *   - rollback() — revert to the embedded bundle
+ *   - getCurrentVersion() — get current bundle version info
+ *
+ * Events:
+ *   - ota:downloadProgress — payload: { progress, bytesDownloaded, totalBytes }
+ */
+class OTAModule : NativeModule {
+    override val moduleName = "OTA"
+    private var appContext: Context? = null
+    private var bridgeRef: NativeBridge? = null
+    private var prefs: SharedPreferences? = null
+    private val client = OkHttpClient()
+
+    private val KEY_PREFIX = "vue_native_ota_"
+    private val KEY_CURRENT_VERSION = "${KEY_PREFIX}current_version"
+    private val KEY_BUNDLE_PATH = "${KEY_PREFIX}bundle_path"
+    private val KEY_PREVIOUS_BUNDLE_PATH = "${KEY_PREFIX}previous_bundle_path"
+    private val KEY_PREVIOUS_VERSION = "${KEY_PREFIX}previous_version"
+    private val KEY_PENDING_BUNDLE_PATH = "${KEY_PREFIX}pending_bundle_path"
+
+    override fun initialize(context: Context, bridge: NativeBridge) {
+        appContext = context.applicationContext
+        bridgeRef = bridge
+        prefs = context.getSharedPreferences("vue_native_ota", Context.MODE_PRIVATE)
+    }
+
+    override fun invoke(method: String, args: List<Any?>, bridge: NativeBridge, callback: (Any?, String?) -> Unit) {
+        val p = prefs ?: run { callback(null, "OTA not initialized"); return }
+
+        when (method) {
+            "checkForUpdate" -> {
+                val serverUrl = args.getOrNull(0)?.toString()
+                    ?: run { callback(null, "checkForUpdate: missing serverUrl"); return }
+                checkForUpdate(serverUrl, p, callback)
+            }
+            "downloadUpdate" -> {
+                val url = args.getOrNull(0)?.toString()
+                    ?: run { callback(null, "downloadUpdate: missing url"); return }
+                val expectedHash = args.getOrNull(1)?.toString()
+                downloadUpdate(url, expectedHash, p, callback)
+            }
+            "applyUpdate" -> applyUpdate(p, callback)
+            "rollback" -> rollback(p, callback)
+            "getCurrentVersion" -> getCurrentVersion(p, callback)
+            else -> callback(null, "OTAModule: Unknown method '$method'")
+        }
+    }
+
+    private fun checkForUpdate(serverUrl: String, prefs: SharedPreferences, callback: (Any?, String?) -> Unit) {
+        val currentVersion = prefs.getString(KEY_CURRENT_VERSION, "0") ?: "0"
+
+        val request = Request.Builder()
+            .url(serverUrl)
+            .header("X-Current-Version", currentVersion)
+            .header("X-Platform", "android")
+            .header("X-App-Id", appContext?.packageName ?: "unknown")
+            .get()
+            .build()
+
+        client.newCall(request).enqueue(object : Callback {
+            override fun onFailure(call: Call, e: IOException) {
+                callback(null, "Network error: ${e.message}")
+            }
+
+            override fun onResponse(call: Call, response: Response) {
+                try {
+                    val body = response.body?.string() ?: run {
+                        callback(null, "Empty response from update server")
+                        return
+                    }
+
+                    val json = org.json.JSONObject(body)
+                    val result = mapOf(
+                        "updateAvailable" to (json.optBoolean("updateAvailable", false)),
+                        "version" to json.optString("version", ""),
+                        "downloadUrl" to json.optString("downloadUrl", ""),
+                        "hash" to json.optString("hash", ""),
+                        "size" to json.optInt("size", 0),
+                        "releaseNotes" to json.optString("releaseNotes", ""),
+                    )
+                    callback(result, null)
+                } catch (e: Exception) {
+                    callback(null, "Failed to parse update response: ${e.message}")
+                }
+            }
+        })
+    }
+
+    private fun downloadUpdate(
+        url: String,
+        expectedHash: String?,
+        prefs: SharedPreferences,
+        callback: (Any?, String?) -> Unit
+    ) {
+        val request = Request.Builder().url(url).build()
+
+        client.newCall(request).enqueue(object : Callback {
+            override fun onFailure(call: Call, e: IOException) {
+                callback(null, "Download failed: ${e.message}")
+            }
+
+            override fun onResponse(call: Call, response: Response) {
+                try {
+                    val body = response.body ?: run {
+                        callback(null, "Download failed: empty response")
+                        return
+                    }
+
+                    val totalBytes = body.contentLength()
+                    val ctx = appContext ?: run {
+                        callback(null, "Context not available")
+                        return
+                    }
+
+                    val otaDir = File(ctx.filesDir, "VueNativeOTA")
+                    otaDir.mkdirs()
+                    val bundleFile = File(otaDir, "bundle.js")
+
+                    val source = body.source()
+                    val outputStream = FileOutputStream(bundleFile)
+                    val buffer = ByteArray(8192)
+                    var bytesDownloaded = 0L
+
+                    while (true) {
+                        val read = source.read(buffer)
+                        if (read == -1) break
+                        outputStream.write(buffer, 0, read)
+                        bytesDownloaded += read
+
+                        val progress = if (totalBytes > 0) bytesDownloaded.toDouble() / totalBytes else 0.0
+                        bridgeRef?.dispatchGlobalEvent("ota:downloadProgress", mapOf(
+                            "progress" to progress,
+                            "bytesDownloaded" to bytesDownloaded,
+                            "totalBytes" to totalBytes,
+                        ))
+                    }
+
+                    outputStream.close()
+                    source.close()
+
+                    // Verify hash if provided
+                    if (!expectedHash.isNullOrEmpty()) {
+                        val actualHash = sha256(bundleFile)
+                        if (!actualHash.equals(expectedHash, ignoreCase = true)) {
+                            bundleFile.delete()
+                            callback(null, "Bundle integrity check failed. Expected: $expectedHash, got: $actualHash")
+                            return
+                        }
+                    }
+
+                    prefs.edit().putString(KEY_PENDING_BUNDLE_PATH, bundleFile.absolutePath).apply()
+
+                    callback(mapOf(
+                        "path" to bundleFile.absolutePath,
+                        "size" to bytesDownloaded,
+                    ), null)
+                } catch (e: Exception) {
+                    callback(null, "Failed to save bundle: ${e.message}")
+                }
+            }
+        })
+    }
+
+    private fun applyUpdate(prefs: SharedPreferences, callback: (Any?, String?) -> Unit) {
+        val pendingPath = prefs.getString(KEY_PENDING_BUNDLE_PATH, null)
+        if (pendingPath == null || !File(pendingPath).exists()) {
+            callback(null, "No pending update to apply")
+            return
+        }
+
+        val editor = prefs.edit()
+
+        // Save current for rollback
+        val currentPath = prefs.getString(KEY_BUNDLE_PATH, null)
+        val currentVersion = prefs.getString(KEY_CURRENT_VERSION, null)
+        if (currentPath != null) editor.putString(KEY_PREVIOUS_BUNDLE_PATH, currentPath)
+        if (currentVersion != null) editor.putString(KEY_PREVIOUS_VERSION, currentVersion)
+
+        // Set new bundle as current
+        editor.putString(KEY_BUNDLE_PATH, pendingPath)
+        editor.remove(KEY_PENDING_BUNDLE_PATH)
+
+        // Increment version
+        val version = (prefs.getString(KEY_CURRENT_VERSION, "0")?.toIntOrNull() ?: 0) + 1
+        editor.putString(KEY_CURRENT_VERSION, version.toString())
+
+        editor.apply()
+
+        callback(mapOf("applied" to true), null)
+    }
+
+    private fun rollback(prefs: SharedPreferences, callback: (Any?, String?) -> Unit) {
+        val editor = prefs.edit()
+        val previousPath = prefs.getString(KEY_PREVIOUS_BUNDLE_PATH, null)
+
+        if (previousPath != null) {
+            editor.putString(KEY_BUNDLE_PATH, previousPath)
+            val prevVersion = prefs.getString(KEY_PREVIOUS_VERSION, null)
+            if (prevVersion != null) editor.putString(KEY_CURRENT_VERSION, prevVersion)
+            editor.remove(KEY_PREVIOUS_BUNDLE_PATH)
+            editor.remove(KEY_PREVIOUS_VERSION)
+            editor.apply()
+            callback(mapOf("rolledBack" to true, "toEmbedded" to false), null)
+        } else {
+            // Rollback to embedded
+            editor.remove(KEY_BUNDLE_PATH)
+            editor.remove(KEY_CURRENT_VERSION)
+            editor.apply()
+            callback(mapOf("rolledBack" to true, "toEmbedded" to true), null)
+        }
+    }
+
+    private fun getCurrentVersion(prefs: SharedPreferences, callback: (Any?, String?) -> Unit) {
+        val version = prefs.getString(KEY_CURRENT_VERSION, "embedded") ?: "embedded"
+        val bundlePath = prefs.getString(KEY_BUNDLE_PATH, null)
+        val isUsingOTA = bundlePath != null && File(bundlePath).exists()
+
+        callback(mapOf(
+            "version" to version,
+            "isUsingOTA" to isUsingOTA,
+            "bundlePath" to (bundlePath ?: ""),
+        ), null)
+    }
+
+    private fun sha256(file: File): String {
+        val digest = MessageDigest.getInstance("SHA-256")
+        file.inputStream().use { input ->
+            val buffer = ByteArray(8192)
+            while (true) {
+                val read = input.read(buffer)
+                if (read == -1) break
+                digest.update(buffer, 0, read)
+            }
+        }
+        return digest.digest().joinToString("") { "%02x".format(it) }
+    }
+}

package/native/android/VueNativeCore/src/main/kotlin/com/vuenative/core/Modules/PerformanceModule.kt

@@ -0,0 +1,147 @@
+package com.vuenative.core
+
+import android.content.Context
+import android.os.Handler
+import android.os.Looper
+import android.view.Choreographer
+
+/**
+ * Native module for performance profiling.
+ * Tracks FPS via Choreographer, memory usage via Runtime, and bridge operation counts.
+ * Dispatches `perf:metrics` global events every 1 second while profiling is active.
+ */
+class PerformanceModule : NativeModule {
+    override val moduleName = "Performance"
+
+    private var bridge: NativeBridge? = null
+    private val mainHandler = Handler(Looper.getMainLooper())
+    private var isProfiling = false
+
+    // FPS tracking
+    private var frameCount = 0
+    private var lastFrameTimeNanos = 0L
+    private var currentFPS = 0.0
+
+    // Bridge operation count
+    private var bridgeOpsCount = 0
+
+    // Metrics timer
+    private var metricsRunnable: Runnable? = null
+
+    // Choreographer callback
+    private var frameCallback: Choreographer.FrameCallback? = null
+
+    override fun initialize(context: Context, bridge: NativeBridge) {
+        this.bridge = bridge
+    }
+
+    override fun invoke(
+        method: String,
+        args: List<Any?>,
+        bridge: NativeBridge,
+        callback: (result: Any?, error: String?) -> Unit
+    ) {
+        when (method) {
+            "startProfiling" -> startProfiling(callback)
+            "stopProfiling" -> stopProfiling(callback)
+            "getMetrics" -> callback(collectMetrics(), null)
+            else -> callback(null, "PerformanceModule: unknown method '$method'")
+        }
+    }
+
+    // ── Start / Stop ──────────────────────────────────────────────────────
+
+    private fun startProfiling(callback: (Any?, String?) -> Unit) {
+        if (isProfiling) { callback(true, null); return }
+        isProfiling = true
+        frameCount = 0
+        lastFrameTimeNanos = 0
+        currentFPS = 0.0
+        bridgeOpsCount = 0
+
+        mainHandler.post {
+            // Choreographer for FPS measurement
+            frameCallback = object : Choreographer.FrameCallback {
+                override fun doFrame(frameTimeNanos: Long) {
+                    if (!isProfiling) return
+
+                    if (lastFrameTimeNanos == 0L) {
+                        lastFrameTimeNanos = frameTimeNanos
+                        frameCount = 0
+                    } else {
+                        frameCount++
+                        val elapsedNanos = frameTimeNanos - lastFrameTimeNanos
+                        val elapsedSeconds = elapsedNanos / 1_000_000_000.0
+
+                        // Calculate FPS every 0.5 seconds
+                        if (elapsedSeconds >= 0.5) {
+                            currentFPS = frameCount / elapsedSeconds
+                            frameCount = 0
+                            lastFrameTimeNanos = frameTimeNanos
+                        }
+                    }
+
+                    Choreographer.getInstance().postFrameCallback(this)
+                }
+            }
+            Choreographer.getInstance().postFrameCallback(frameCallback!!)
+
+            // Periodic metrics dispatch (every 1 second)
+            metricsRunnable = object : Runnable {
+                override fun run() {
+                    if (!isProfiling) return
+                    dispatchMetrics()
+                    mainHandler.postDelayed(this, 1000)
+                }
+            }
+            mainHandler.postDelayed(metricsRunnable!!, 1000)
+        }
+
+        callback(true, null)
+    }
+
+    private fun stopProfiling(callback: (Any?, String?) -> Unit) {
+        if (!isProfiling) { callback(true, null); return }
+        isProfiling = false
+
+        mainHandler.post {
+            frameCallback?.let { Choreographer.getInstance().removeFrameCallback(it) }
+            frameCallback = null
+            metricsRunnable?.let { mainHandler.removeCallbacks(it) }
+            metricsRunnable = null
+        }
+
+        callback(true, null)
+    }
+
+    // ── Metrics collection ────────────────────────────────────────────────
+
+    private fun collectMetrics(): Map<String, Any> {
+        val runtime = Runtime.getRuntime()
+        val usedMemory = (runtime.totalMemory() - runtime.freeMemory()).toDouble() / (1024 * 1024)
+
+        return mapOf(
+            "fps" to Math.round(currentFPS * 10.0) / 10.0,
+            "memoryMB" to Math.round(usedMemory * 100.0) / 100.0,
+            "bridgeOps" to bridgeOpsCount,
+            "timestamp" to System.currentTimeMillis()
+        )
+    }
+
+    private fun dispatchMetrics() {
+        if (!isProfiling) return
+        bridgeOpsCount++
+        val metrics = collectMetrics()
+        bridge?.dispatchGlobalEvent("perf:metrics", metrics)
+    }
+
+    override fun destroy() {
+        isProfiling = false
+        mainHandler.post {
+            frameCallback?.let { Choreographer.getInstance().removeFrameCallback(it) }
+            frameCallback = null
+            metricsRunnable?.let { mainHandler.removeCallbacks(it) }
+            metricsRunnable = null
+        }
+    }
+}