catalyst-core 0.0.3-canary.18 → 0.0.3-canary.19

package/changelog.md

@@ -1,9 +1,35 @@
 # Changelog
 
+## [0.0.3-canary.19] - 2025-12-09
+
+-   Offline fallback support: packages `public/offline.html` into Android/iOS bundles and shows it automatically when connectivity drops (with retry handling)
+-   Notification refactor: streamlined config toggle for local vs push, centralized permission/asset handling, and simpler routing into the web app
+-   Access control: combined access control config for ios
+
+## [0.0.3-canary.18] - 2025-11-19
+
+-   Configuration Files
+-   Android Native WebView - MainActivity.kt
+-   Android Native WebView - CustomWebview.kt
+
+## [0.0.3-canary.17] - 2025-11-19
+
+-   ✨ Added complete notification system (local & push)
+-   🔔 New useNotification() React hook
+-   📱 Firebase Cloud Messaging conditional build support
+-   🤖 Android notification handling in MainActivity
+-   🔧 5 new notification commands + 5 callbacks in NativeBridge
+-   📦 Auto-processing of notification icons & sounds
+-   ⚙️ Conditional dependencies based on notification config
+-   🧹 Updated .gitignore & .npmignore
+-   📋 Enhanced build process with automatic permission injection
+-   🔗 Deep link integration with notifications
+
 ## [0.0.3-canary.16] - 2025-11-19
-- FeaturesGallery Support for File Picker: Enhanced file picker to open native gallery for selecting images and videos
-- HTTPS Framework Server: Enabled HTTPS support for the framework server with self-signed SSL certificate
-- MIME Type Handling: Fixed and improved MIME type detection and handling in the file picker
+
+-   FeaturesGallery Support for File Picker: Enhanced file picker to open native gallery for selecting images and videos
+-   HTTPS Framework Server: Enabled HTTPS support for the framework server with self-signed SSL certificate
+-   MIME Type Handling: Fixed and improved MIME type detection and handling in the file picker
 
 ## [0.0.3-canary.15] - 2025-11-19
 

package/dist/native/androidProject/app/src/main/java/io/yourname/androidproject/CustomWebview.kt

@@ -19,6 +19,7 @@ import io.yourname.androidproject.isUrlAllowed
 import io.yourname.androidproject.isExternalDomain
 import io.yourname.androidproject.matchesCachePattern
 import io.yourname.androidproject.utils.CameraUtils
+import io.yourname.androidproject.utils.NetworkUtils
 import kotlinx.coroutines.*
 import java.io.FileNotFoundException
 import java.util.Properties
@@ -46,6 +47,10 @@ class CustomWebView(
     private lateinit var assetLoader: WebViewAssetLoader
     private var allowedUrls: List<String> = emptyList()
     private var accessControlEnabled: Boolean = false
+    private val offlineAssetPath = "offline/offline.html"
+    private val offlineAssetUrl = "file:///android_asset/$offlineAssetPath"
+    private var offlinePageVisible = false
+    private var lastTargetUrl: String? = null
 
     // Counters for asset loading statistics
     private var assetLoadAttempts = 0
@@ -123,9 +128,34 @@ class CustomWebView(
     }
 
     fun loadUrl(url: String) {
+        lastTargetUrl = url
+        offlinePageVisible = false
         webView.loadUrl(url)
     }
 
+    fun updateLastTargetUrl(url: String) {
+        lastTargetUrl = url
+    }
+
+    fun showOfflinePage() {
+        if (offlinePageVisible) {
+            return
+        }
+
+        // Verify offline asset exists to avoid crash
+        try {
+            context.assets.open(offlineAssetPath).close()
+            offlinePageVisible = true
+            webView.loadUrl(offlineAssetUrl)
+            if (BuildConfig.DEBUG) {
+                Log.d(TAG, "📴 Showing offline page from assets: $offlineAssetPath")
+            }
+        } catch (e: Exception) {
+            Log.e(TAG, "❌ offline.html not found in assets, cannot show offline page", e)
+        }
+    }
+
+
     fun saveState(outState: Bundle) {
         webView.saveState(outState)
     }
@@ -264,6 +294,27 @@ class CustomWebView(
         val uri = Uri.parse(url)
         val scheme = uri.scheme?.lowercase() ?: return false
 
+        // Handle offline retry scheme
+        if (scheme == "catalyst" && (uri.host?.lowercase() == "retry" || uri.schemeSpecificPart?.lowercase() == "retry")) {
+            val status = NetworkUtils.getCurrentStatus(context)
+            if (status.isOnline) {
+                val target = lastTargetUrl
+                if (target != null) {
+                    if (BuildConfig.DEBUG) {
+                        Log.d(TAG, "🔄 Retry requested, online. Reloading: $target")
+                    }
+                    offlinePageVisible = false
+                    lastTargetUrl = target
+                    webView.loadUrl(target)
+                } else if (BuildConfig.DEBUG) {
+                    Log.w(TAG, "🔄 Retry requested but no target URL is known")
+                }
+            } else if (BuildConfig.DEBUG) {
+                Log.d(TAG, "🔄 Retry requested but still offline; staying on offline page")
+            }
+            return true
+        }
+
         // Only handle tel, mailto, sms
         if (scheme !in listOf("tel", "mailto", "sms")) {
             return false
@@ -573,6 +624,7 @@ class CustomWebView(
 
                     // Let WebView handle loading non-API HTTP/HTTPS URLs
                     if (url.scheme in listOf("http", "https")) {
+                        lastTargetUrl = urlString
                         return false
                     }
                 }
@@ -807,6 +859,9 @@ class CustomWebView(
 
             override fun onPageStarted(view: WebView?, url: String?, favicon: Bitmap?) {
                 super.onPageStarted(view, url, favicon)
+                if (url != null && url != offlineAssetUrl) {
+                    offlinePageVisible = false
+                }
                 progressBar.visibility = View.VISIBLE
                 val startTime = System.currentTimeMillis()
                 view?.tag = startTime // Store start time for performance tracking

package/dist/native/androidProject/app/src/main/java/io/yourname/androidproject/MainActivity.kt

@@ -7,10 +7,13 @@ import android.view.WindowManager
 import androidx.activity.OnBackPressedCallback
 import androidx.appcompat.app.AppCompatActivity
 
+import org.json.JSONObject
 import java.util.Properties
 import io.yourname.androidproject.databinding.ActivityMainBinding
 import io.yourname.androidproject.NativeBridge
+import io.yourname.androidproject.utils.BridgeUtils
 import io.yourname.androidproject.utils.KeyboardUtil
+import io.yourname.androidproject.utils.NetworkUtils
 import io.yourname.androidproject.utils.NotificationConstants
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.MainScope
@@ -139,14 +142,25 @@ class MainActivity : AppCompatActivity(), CoroutineScope by MainScope() {
                 val useHttps = properties.getProperty("useHttps", "false").toBoolean()
                 val protocol = if (useHttps) "https" else "http"
                 currentUrl = "$protocol://$local_ip:$port/$initial_url"
+                customWebView.updateLastTargetUrl(currentUrl)
             
 
             // Check for notification and handle via /notification endpoint
             if (intent.getBooleanExtra(NotificationConstants.EXTRA_IS_NOTIFICATION, false)) {
                 handleNotificationClick(currentUrl, intent)
             } else {
-                Log.d(TAG, "🔗 Loading base URL: $currentUrl")
-                customWebView.loadUrl(currentUrl)
+                val isOnline = NetworkUtils.getCurrentStatus(this).isOnline
+                if (isOnline) {
+                    if (BuildConfig.DEBUG) {
+                        Log.d(TAG, "🔗 Loading base URL: $currentUrl")
+                    }
+                    customWebView.loadUrl(currentUrl)
+                } else {
+                    if (BuildConfig.DEBUG) {
+                        Log.w(TAG, "📴 Device offline on launch, showing offline page")
+                    }
+                    customWebView.showOfflinePage()
+                }
             }
 
             metricsMonitor.markAppStartComplete()
@@ -230,18 +244,52 @@ class MainActivity : AppCompatActivity(), CoroutineScope by MainScope() {
         try {
             val action = intent.getStringExtra(NotificationConstants.EXTRA_ACTION)
             val notificationData = intent.getStringExtra(NotificationConstants.EXTRA_NOTIFICATION_DATA)
+            val notificationId = intent.getStringExtra(NotificationConstants.EXTRA_NOTIFICATION_ID)
 
             Log.d(TAG, "🔔 Handling notification click - Action: ${action ?: "none"}")
 
             // Dismiss the notification
             val notificationManager = getSystemService(android.content.Context.NOTIFICATION_SERVICE) as android.app.NotificationManager
-            notificationManager.cancelAll() // This dismisses all notifications from this app
+            if (!notificationId.isNullOrBlank()) {
+                notificationManager.cancel(notificationId.hashCode())
+            } else {
+                notificationManager.cancelAll() // Fallback if we didn't get an ID
+            }
 
             // Build simple /notification URL
             val url = buildNotificationUrl(baseUrl, action, notificationData)
             Log.d(TAG, "🔔 Navigating to: $url")
 
-            customWebView.loadUrl(url)
+            // Notify web layer about the action/tap
+            try {
+                val payload = org.json.JSONObject().apply {
+                    put("action", action ?: "tap")
+                    put("deepLinkURL", url)
+                    if (!notificationData.isNullOrBlank()) {
+                        put("data", org.json.JSONObject(notificationData))
+                    }
+                    if (!notificationId.isNullOrBlank()) {
+                        put("notificationId", notificationId)
+                    }
+                }
+                val webView = customWebView.getWebView()
+                if (action.isNullOrBlank()) {
+                    BridgeUtils.notifyWeb(webView, BridgeUtils.WebEvents.NOTIFICATION_TAPPED, payload.toString())
+                } else {
+                    BridgeUtils.notifyWeb(webView, BridgeUtils.WebEvents.NOTIFICATION_ACTION_PERFORMED, payload.toString())
+                }
+            } catch (e: Exception) {
+                Log.e(TAG, "Failed to notify web of notification action", e)
+            }
+
+            customWebView.updateLastTargetUrl(url)
+            val isOnline = NetworkUtils.getCurrentStatus(this).isOnline
+            if (isOnline) {
+                customWebView.loadUrl(url)
+            } else {
+                Log.w(TAG, "📴 Offline during notification click, showing offline page")
+                customWebView.showOfflinePage()
+            }
 
         } catch (e: Exception) {
             Log.e(TAG, "🔔 Error handling notification click: ${e.message}", e)
@@ -278,4 +326,4 @@ class MainActivity : AppCompatActivity(), CoroutineScope by MainScope() {
             "$baseUrl/notification"
         }
     }
-}
+}

package/dist/native/androidProject/app/src/main/java/io/yourname/androidproject/NativeBridge.kt

@@ -104,6 +104,7 @@ class NativeBridge(
     private lateinit var permissionLauncher: ActivityResultLauncher<String>
     private lateinit var filePickerLauncher: ActivityResultLauncher<Intent>
     private var currentFilePickerOptions: FilePickerOptions = FilePickerOptions()
+    private var networkMonitor: NetworkMonitor? = null
 
     // Unified notification manager
     private val notificationManager = AppNotificationManager(mainActivity, mainActivity.properties)
@@ -272,6 +273,37 @@ class NativeBridge(
         }
     }
 
+    @JavascriptInterface
+    fun getNetworkStatus(param: String? = null) {
+        BridgeUtils.safeExecute(webView, BridgeUtils.WebEvents.NETWORK_STATUS_CHANGED, "get network status") {
+            // Lazily start monitor on first request
+            if (networkMonitor == null) {
+                networkMonitor = NetworkMonitor(mainActivity) { status ->
+                    mainActivity.runOnUiThread {
+                        try {
+                            val payload = JSONObject().apply {
+                                put("online", status.isOnline)
+                                status.transport?.let { put("type", it) }
+                            }
+                            BridgeUtils.notifyWebJson(webView, BridgeUtils.WebEvents.NETWORK_STATUS_CHANGED, payload)
+                        } catch (e: Exception) {
+                            BridgeUtils.logError(TAG, "Failed to send network status to web: ${e.message}")
+                        }
+                    }
+                }.also { it.start() }
+            } else {
+                val status = NetworkUtils.getCurrentStatus(mainActivity)
+                val payload = JSONObject().apply {
+                    put("online", status.isOnline)
+                    status.transport?.let { put("type", it) }
+                }
+                mainActivity.runOnUiThread {
+                    BridgeUtils.notifyWebJson(webView, BridgeUtils.WebEvents.NETWORK_STATUS_CHANGED, payload)
+                }
+            }
+        }
+    }
+
     @JavascriptInterface
     fun getDeviceInfo(options: String?) {
         BridgeUtils.safeExecute(webView, BridgeUtils.WebEvents.ON_DEVICE_INFO_ERROR, "get device info") {
@@ -287,11 +319,11 @@ class NativeBridge(
     fun scheduleLocalNotification(config: String?) {
         BridgeUtils.safeExecute(webView, BridgeUtils.WebEvents.LOCAL_NOTIFICATION_SCHEDULED, "schedule local notification") {
             mainActivity.runOnUiThread {
-                // Parse config with full NotificationConfig support
-                val notificationConfig = if (config.isNullOrBlank()) {
-                    NotificationConfig(title = NotificationConstants.DEFAULT_NOTIFICATION_TITLE, body = NotificationConstants.DEFAULT_NOTIFICATION_BODY)
-                } else {
-                    try {
+                try {
+                    // Parse config with full NotificationConfig support
+                    val notificationConfig = if (config.isNullOrBlank()) {
+                        NotificationConfig(title = NotificationConstants.DEFAULT_NOTIFICATION_TITLE, body = NotificationConstants.DEFAULT_NOTIFICATION_BODY)
+                    } else {
                         val json = org.json.JSONObject(config)
 
                         // Parse actions array with title and actionId
@@ -343,26 +375,43 @@ class NativeBridge(
                             ongoing = json.optBoolean("ongoing", false),
                             data = data
                         )
-                    } catch (e: Exception) {
-                        BridgeUtils.logError(TAG, "Error parsing notification config", e)
-                        NotificationConfig(title = NotificationConstants.DEFAULT_NOTIFICATION_TITLE, body = NotificationConstants.DEFAULT_NOTIFICATION_BODY)
                     }
+
+                    val notificationId = notificationManager.scheduleLocal(notificationConfig)
+                    BridgeUtils.notifyWeb(webView, BridgeUtils.WebEvents.LOCAL_NOTIFICATION_SCHEDULED,
+                        """{"notificationId": "$notificationId", "scheduled": true, "success": true}""")
+
+                    // Emit received event
+                    val payload = org.json.JSONObject().apply {
+                        put("title", notificationConfig.title)
+                        put("body", notificationConfig.body)
+                        notificationConfig.data?.let { dataMap ->
+                            put("data", org.json.JSONObject(dataMap))
+                        }
+                        put("foreground", false)
+                        put("notificationId", notificationId)
+                    }
+                    BridgeUtils.notifyWeb(webView, BridgeUtils.WebEvents.NOTIFICATION_RECEIVED, payload.toString())
+                } catch (e: Exception) {
+                    BridgeUtils.notifyWeb(webView, BridgeUtils.WebEvents.LOCAL_NOTIFICATION_SCHEDULED,
+                        """{"notificationId": "", "scheduled": false, "success": false, "error": "Failed to schedule notification: ${e.message}"}""")
                 }
-                
-                val notificationId = notificationManager.scheduleLocal(notificationConfig)
-                BridgeUtils.notifyWeb(webView, BridgeUtils.WebEvents.LOCAL_NOTIFICATION_SCHEDULED,
-                    """{"notificationId": "$notificationId", "scheduled": true}""")
             }
         }
     }
 
     @JavascriptInterface
     fun cancelLocalNotification(notificationId: String?) {
-        BridgeUtils.safeExecute(webView, BridgeUtils.WebEvents.LOCAL_NOTIFICATION_SCHEDULED, "cancel local notification") {
+        BridgeUtils.safeExecute(webView, BridgeUtils.WebEvents.LOCAL_NOTIFICATION_CANCELLED, "cancel local notification") {
             mainActivity.runOnUiThread {
-                val success = notificationManager.cancelLocal(notificationId)
-                BridgeUtils.notifyWeb(webView, BridgeUtils.WebEvents.LOCAL_NOTIFICATION_SCHEDULED,
-                    """{"notificationId": "$notificationId", "cancelled": $success}""")
+                try {
+                    val success = notificationManager.cancelLocal(notificationId)
+                    BridgeUtils.notifyWeb(webView, BridgeUtils.WebEvents.LOCAL_NOTIFICATION_CANCELLED,
+                        """{"notificationId": "${notificationId ?: ""}", "success": $success}""")
+                } catch (e: Exception) {
+                    BridgeUtils.notifyWeb(webView, BridgeUtils.WebEvents.LOCAL_NOTIFICATION_CANCELLED,
+                        """{"notificationId": "${notificationId ?: ""}", "success": false, "error": "Failed to cancel notification: ${e.message}"}""")
+                }
             }
         }
     }
@@ -386,11 +435,16 @@ class NativeBridge(
                 launch {
                     try {
                         val token = notificationManager.initializePush()
-                        BridgeUtils.notifyWeb(webView, BridgeUtils.WebEvents.PUSH_NOTIFICATION_TOKEN,
-                            """{"token": "$token", "registered": true}""")
+                        if (token.isBlank()) {
+                            BridgeUtils.notifyWeb(webView, BridgeUtils.WebEvents.PUSH_NOTIFICATION_TOKEN,
+                                """{"success": false, "error": "Push registration returned empty token"}""")
+                        } else {
+                            BridgeUtils.notifyWeb(webView, BridgeUtils.WebEvents.PUSH_NOTIFICATION_TOKEN,
+                                """{"token": "$token", "success": true}""")
+                        }
                     } catch (e: Exception) {
-                        BridgeUtils.notifyWebError(webView, BridgeUtils.WebEvents.PUSH_NOTIFICATION_TOKEN,
-                            "Push registration failed: ${e.message}")
+                        BridgeUtils.notifyWeb(webView, BridgeUtils.WebEvents.PUSH_NOTIFICATION_TOKEN,
+                            """{"success": false, "error": "Push registration failed: ${e.message}"}""")
                     }
                 }
             }
@@ -400,7 +454,7 @@ class NativeBridge(
 
     @JavascriptInterface
     fun subscribeToTopic(config: String?) {
-        BridgeUtils.safeExecute(webView, BridgeUtils.WebEvents.NOTIFICATION_RECEIVED, "subscribe to topic") {
+        BridgeUtils.safeExecute(webView, BridgeUtils.WebEvents.TOPIC_SUBSCRIPTION_RESULT, "subscribe to topic") {
             mainActivity.runOnUiThread {
                 launch {
                     try {
@@ -408,18 +462,18 @@ class NativeBridge(
                         val topic = json.optString("topic", "")
 
                         if (topic.isBlank()) {
-                            BridgeUtils.notifyWebError(webView, BridgeUtils.WebEvents.NOTIFICATION_RECEIVED,
-                                "Topic name cannot be empty")
+                            BridgeUtils.notifyWeb(webView, BridgeUtils.WebEvents.TOPIC_SUBSCRIPTION_RESULT,
+                                """{"topic": "$topic", "success": false, "error": "Topic name cannot be empty", "action": "subscribe"}""")
                             return@launch
                         }
 
                         val success = notificationManager.subscribeToTopic(topic)
-                        BridgeUtils.notifyWeb(webView, BridgeUtils.WebEvents.NOTIFICATION_RECEIVED,
-                            """{"topic": "$topic", "subscribed": $success}""")
+                        BridgeUtils.notifyWeb(webView, BridgeUtils.WebEvents.TOPIC_SUBSCRIPTION_RESULT,
+                            """{"topic": "$topic", "success": $success, "action": "subscribe"}""")
 
                     } catch (e: Exception) {
-                        BridgeUtils.notifyWebError(webView, BridgeUtils.WebEvents.NOTIFICATION_RECEIVED,
-                            "Topic subscription failed: ${e.message}")
+                        BridgeUtils.notifyWeb(webView, BridgeUtils.WebEvents.TOPIC_SUBSCRIPTION_RESULT,
+                            """{"topic": "", "success": false, "error": "Topic subscription failed: ${e.message}", "action": "subscribe"}""")
                     }
                 }
             }
@@ -428,7 +482,7 @@ class NativeBridge(
 
     @JavascriptInterface
     fun unsubscribeFromTopic(config: String?) {
-        BridgeUtils.safeExecute(webView, BridgeUtils.WebEvents.NOTIFICATION_RECEIVED, "unsubscribe from topic") {
+        BridgeUtils.safeExecute(webView, BridgeUtils.WebEvents.TOPIC_SUBSCRIPTION_RESULT, "unsubscribe from topic") {
             mainActivity.runOnUiThread {
                 launch {
                     try {
@@ -436,18 +490,18 @@ class NativeBridge(
                         val topic = json.optString("topic", "")
 
                         if (topic.isBlank()) {
-                            BridgeUtils.notifyWebError(webView, BridgeUtils.WebEvents.NOTIFICATION_RECEIVED,
-                                "Topic name cannot be empty")
+                            BridgeUtils.notifyWeb(webView, BridgeUtils.WebEvents.TOPIC_SUBSCRIPTION_RESULT,
+                                """{"topic": "$topic", "success": false, "error": "Topic name cannot be empty", "action": "unsubscribe"}""")
                             return@launch
                         }
 
                         val success = notificationManager.unsubscribeFromTopic(topic)
-                        BridgeUtils.notifyWeb(webView, BridgeUtils.WebEvents.NOTIFICATION_RECEIVED,
-                            """{"topic": "$topic", "unsubscribed": $success}""")
+                        BridgeUtils.notifyWeb(webView, BridgeUtils.WebEvents.TOPIC_SUBSCRIPTION_RESULT,
+                            """{"topic": "$topic", "success": $success, "action": "unsubscribe"}""")
 
                     } catch (e: Exception) {
-                        BridgeUtils.notifyWebError(webView, BridgeUtils.WebEvents.NOTIFICATION_RECEIVED,
-                            "Topic unsubscription failed: ${e.message}")
+                        BridgeUtils.notifyWeb(webView, BridgeUtils.WebEvents.TOPIC_SUBSCRIPTION_RESULT,
+                            """{"topic": "", "success": false, "error": "Topic unsubscription failed: ${e.message}", "action": "unsubscribe"}""")
                     }
                 }
             }
@@ -456,17 +510,17 @@ class NativeBridge(
 
     @JavascriptInterface
     fun getSubscribedTopics(config: String?) {
-        BridgeUtils.safeExecute(webView, BridgeUtils.WebEvents.NOTIFICATION_RECEIVED, "get subscribed topics") {
+        BridgeUtils.safeExecute(webView, BridgeUtils.WebEvents.SUBSCRIBED_TOPICS_RESULT, "get subscribed topics") {
             mainActivity.runOnUiThread {
                 try {
                     val topics = notificationManager.getSubscribedTopics()
                     val topicsArray = org.json.JSONArray(topics.toList())
-                    BridgeUtils.notifyWeb(webView, BridgeUtils.WebEvents.NOTIFICATION_RECEIVED,
-                        """{"topics": $topicsArray}""")
+                    BridgeUtils.notifyWeb(webView, BridgeUtils.WebEvents.SUBSCRIBED_TOPICS_RESULT,
+                        """{"topics": $topicsArray, "success": true}""")
 
                 } catch (e: Exception) {
-                    BridgeUtils.notifyWebError(webView, BridgeUtils.WebEvents.NOTIFICATION_RECEIVED,
-                        "Failed to get subscribed topics: ${e.message}")
+                    BridgeUtils.notifyWeb(webView, BridgeUtils.WebEvents.SUBSCRIBED_TOPICS_RESULT,
+                        """{"topics": [], "success": false, "error": "Failed to get subscribed topics: ${e.message}"}""")
                 }
             }
         }
@@ -773,6 +827,10 @@ class NativeBridge(
             // Cleanup NotificationManager
             notificationManager.cleanup()
 
+            // Stop network monitoring
+            networkMonitor?.stop()
+            networkMonitor = null
+
             // Stop FrameworkServer
             FrameworkServerUtils.stopServer()
 

package/dist/native/androidProject/app/src/main/java/io/yourname/androidproject/utils/BridgeUtils.kt

@@ -57,9 +57,16 @@ object BridgeUtils {
         // Notification events
         NOTIFICATION_PERMISSION_STATUS("NOTIFICATION_PERMISSION_STATUS"),
         LOCAL_NOTIFICATION_SCHEDULED("LOCAL_NOTIFICATION_SCHEDULED"),
+        LOCAL_NOTIFICATION_CANCELLED("LOCAL_NOTIFICATION_CANCELLED"),
         PUSH_NOTIFICATION_TOKEN("PUSH_NOTIFICATION_TOKEN"),
         NOTIFICATION_RECEIVED("NOTIFICATION_RECEIVED"),
         NOTIFICATION_ACTION_PERFORMED("NOTIFICATION_ACTION_PERFORMED"),
+        NOTIFICATION_TAPPED("NOTIFICATION_TAPPED"),
+        TOPIC_SUBSCRIPTION_RESULT("TOPIC_SUBSCRIPTION_RESULT"),
+        SUBSCRIBED_TOPICS_RESULT("SUBSCRIBED_TOPICS_RESULT"),
+
+        // Network events
+        NETWORK_STATUS_CHANGED("NETWORK_STATUS_CHANGED"),
     }
     
     /**
@@ -226,4 +233,4 @@ object BridgeUtils {
     fun logWarning(tag: String, message: String) {
         Log.w(tag, message)
     }
-}
+}

package/dist/native/androidProject/app/src/main/java/io/yourname/androidproject/utils/NetworkUtils.kt

@@ -0,0 +1,105 @@
+package io.yourname.androidproject.utils
+
+import android.content.Context
+import android.net.ConnectivityManager
+import android.net.Network
+import android.net.NetworkCapabilities
+import android.net.NetworkRequest
+import android.os.Build
+
+data class NetworkStatus(
+    val isOnline: Boolean,
+    val transport: String? = null
+)
+
+object NetworkUtils {
+    private val transportLabels = mapOf(
+        NetworkCapabilities.TRANSPORT_WIFI to "wifi",
+        NetworkCapabilities.TRANSPORT_CELLULAR to "cellular",
+        NetworkCapabilities.TRANSPORT_ETHERNET to "ethernet",
+        NetworkCapabilities.TRANSPORT_BLUETOOTH to "bluetooth"
+    )
+
+    private fun resolveTransport(capabilities: NetworkCapabilities?): String? {
+        if (capabilities == null) return null
+        val transport = transportLabels.keys.firstOrNull { capabilities.hasTransport(it) }
+        return transport?.let { transportLabels[it] } ?: "unknown"
+    }
+
+    fun getCurrentStatus(context: Context): NetworkStatus {
+        val connectivityManager =
+            context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
+
+        val activeNetwork = connectivityManager.activeNetwork
+        val capabilities = connectivityManager.getNetworkCapabilities(activeNetwork)
+
+        val isValidated = capabilities?.hasCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED) == true
+        val isConnected = capabilities?.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET) == true
+        val transport = resolveTransport(capabilities)
+
+        // Fallback for older APIs or missing capabilities
+        val legacyConnected = connectivityManager.activeNetworkInfo?.isConnectedOrConnecting == true
+
+        val online = isValidated || isConnected || legacyConnected
+        return NetworkStatus(isOnline = online, transport = transport)
+    }
+}
+
+class NetworkMonitor(
+    context: Context,
+    private val onStatusChanged: (NetworkStatus) -> Unit
+) {
+    private val appContext = context.applicationContext
+    private val connectivityManager =
+        appContext.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
+    private var callback: ConnectivityManager.NetworkCallback? = null
+
+    fun start() {
+        if (callback != null) return
+
+        // Emit current state immediately
+        onStatusChanged(NetworkUtils.getCurrentStatus(appContext))
+
+        val request = NetworkRequest.Builder()
+            .addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
+            .build()
+
+        val networkCallback = object : ConnectivityManager.NetworkCallback() {
+            override fun onAvailable(network: Network) {
+                onStatusChanged(NetworkUtils.getCurrentStatus(appContext))
+            }
+
+            override fun onLost(network: Network) {
+                onStatusChanged(NetworkUtils.getCurrentStatus(appContext))
+            }
+
+            override fun onUnavailable() {
+                onStatusChanged(NetworkUtils.getCurrentStatus(appContext))
+            }
+        }
+
+        callback = networkCallback
+
+        try {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+                connectivityManager.registerDefaultNetworkCallback(networkCallback)
+            } else {
+                connectivityManager.registerNetworkCallback(request, networkCallback)
+            }
+        } catch (_: Exception) {
+            // Swallow registration errors to avoid crashes; hook users will fall back to navigator.onLine
+            callback = null
+        }
+    }
+
+    fun stop() {
+        callback?.let {
+            try {
+                connectivityManager.unregisterNetworkCallback(it)
+            } catch (_: Exception) {
+                // Ignore unregister errors
+            }
+        }
+        callback = null
+    }
+}

package/dist/native/androidProject/app/src/main/java/io/yourname/androidproject/utils/NotificationConstants.kt

@@ -24,4 +24,5 @@ object NotificationConstants {
     const val EXTRA_IS_NOTIFICATION = "is_notification"
     const val EXTRA_ACTION = "action"
     const val EXTRA_NOTIFICATION_DATA = "notification_data"
-}
+    const val EXTRA_NOTIFICATION_ID = "notification_id"
+}