@craft-native/android 0.0.91 → 0.0.94

package/templates/CraftNative.kt.template

@@ -1,6 +1,7 @@
 package com.craft.runtime
 
 import android.app.Activity
+import android.content.IntentSender
 import com.google.android.gms.location.Priority
 import com.google.android.gms.location.LocationServices
 import com.google.android.gms.location.LocationResult
@@ -110,10 +111,24 @@ object CraftNative {
      */
     val isAvailable: Boolean = try {
         System.loadLibrary("craft")
+        // Said out loud, because the two outcomes below are otherwise
+        // indistinguishable from outside: a library that never shipped and a
+        // library that loaded and then failed to bind both end with the shim
+        // answering every call. Zig logs its own registration under the same
+        // tag, so the pair reads as a sequence.
+        android.util.Log.i("CraftNative", "craft: libcraft.so loaded")
         true
     } catch (e: UnsatisfiedLinkError) {
+        // The reason, not just the fact. This used to be a bare `false`, and
+        // the first time the runtime was genuinely shipped and genuinely
+        // failed to load, the only evidence anywhere was that nothing
+        // happened — no linker line, no exception, nothing in logcat at all.
+        // The message carries the dynamic linker's own complaint, which is the
+        // one thing that says *why*.
+        android.util.Log.w("CraftNative", "craft: libcraft.so did not load: ${e.message}")
         false
     } catch (e: SecurityException) {
+        android.util.Log.w("CraftNative", "craft: libcraft.so was refused: ${e.message}")
         false
     }
 
@@ -197,14 +212,20 @@ object CraftNative {
     /**
      * Run `script` in the page. Called from Zig, on any thread.
      *
-     * Silent when no deliverer is installed — which is every moment before the
-     * WebView exists, and after it is torn down. A throw here would cross back
-     * into Zig as a pending exception on a thread that has nowhere to report
-     * it, and the caller already counts what it could not deliver.
+     * Returns whether a deliverer took it. False is every moment before the
+     * WebView exists and after it is torn down, and it used to be
+     * indistinguishable from a delivery: the script was dropped, Zig's caller
+     * reported success, and the page waited on a promise nothing would settle
+     * (#231). Zig counts a false, and says so once.
+     *
+     * Still no throw. A throw here would cross back into Zig as a pending
+     * exception on a thread with nowhere to report it; false says the same
+     * thing and the caller can act on it.
      */
     @JvmStatic
-    fun deliver(script: String) {
-        runCatching { deliverer?.invoke(script) }
+    fun deliver(script: String): Boolean {
+        val target = deliverer ?: return false
+        return runCatching { target(script); true }.getOrDefault(false)
     }
 
     private external fun nativeGetDeviceInfo(activity: Activity): String?
@@ -213,7 +234,7 @@ object CraftNative {
     private external fun nativeClipboardRead(activity: Activity): String?
     private external fun nativeClipboardWrite(activity: Activity, text: String): Boolean
     private external fun nativeOpenUrl(activity: Activity, url: String): Boolean
-    private external fun nativeShare(activity: Activity, text: String, title: String): Boolean
+    private external fun nativeShare(activity: Activity, text: String, title: String, chosen: IntentSender, requestCode: Int): Boolean
     private external fun nativeOpenCamera(activity: Activity): Boolean
     private external fun nativePickImage(activity: Activity): Boolean
     private external fun nativePickFile(activity: Activity): Boolean
@@ -235,7 +256,7 @@ object CraftNative {
     private external fun nativeResetDeepLinks(): Boolean
     private external fun nativeSetInitialURL(url: String?): Boolean
     private external fun nativeGetInitialURL(): Boolean
-    private external fun nativeDispatchDeepLink(url: String): Boolean
+    private external fun nativeDispatchDeepLink(url: String, initial: Boolean): Boolean
     private external fun nativeScreenshotReady(bytes: ByteArray)
     private external fun nativeScreenshotError(message: String)
     private external fun nativeTakeScreenshot(activity: Activity, webView: WebView): Boolean
@@ -411,11 +432,15 @@ object CraftNative {
         }
     }
 
-    /** Returns whether Zig launched the share sheet; false falls through. */
-    fun share(activity: Activity, text: String, title: String): Boolean {
+    /**
+     * Returns whether Zig launched the share menu for a result; false falls
+     * through. `chosen` fires on a pick and `requestCode` routes the result
+     * back to CraftBridge, which settles the page's promise from the two.
+     */
+    fun share(activity: Activity, text: String, title: String, chosen: IntentSender, requestCode: Int): Boolean {
         if (!isAvailable) return false
         return try {
-            nativeShare(activity, text, title)
+            nativeShare(activity, text, title, chosen, requestCode)
         } catch (e: UnsatisfiedLinkError) {
             false
         }
@@ -697,9 +722,9 @@ object CraftNative {
         return try { nativeGetInitialURL() } catch (e: UnsatisfiedLinkError) { false }
     }
 
-    fun dispatchDeepLink(url: String): Boolean {
+    fun dispatchDeepLink(url: String, initial: Boolean): Boolean {
         if (!isAvailable) return false
-        return try { nativeDispatchDeepLink(url) } catch (e: UnsatisfiedLinkError) { false }
+        return try { nativeDispatchDeepLink(url, initial) } catch (e: UnsatisfiedLinkError) { false }
     }
 
     @JvmStatic

package/templates/MainActivity.kt.template

@@ -1,10 +1,14 @@
 package {{PACKAGE_NAME}}
 
 import android.annotation.SuppressLint
+import android.content.Context
 import android.os.Bundle
 import android.content.Intent
 import android.graphics.Bitmap
+import android.net.ConnectivityManager
+import android.net.Network
 import android.net.Uri
+import android.util.Log
 import android.webkit.WebResourceRequest
 import android.webkit.WebResourceError
 import android.webkit.WebResourceResponse
@@ -19,6 +23,20 @@ import org.json.JSONObject
 import java.io.FileNotFoundException
 import java.net.URLConnection
 
+/** Main-frame failures for which the bundled app is an honest fallback (#254). */
+object CraftLoadFailure {
+    fun isUnreachable(errorCode: Int): Boolean = when (errorCode) {
+        WebViewClient.ERROR_HOST_LOOKUP,
+        WebViewClient.ERROR_CONNECT,
+        WebViewClient.ERROR_TIMEOUT,
+        // Android uses ERROR_IO for connection interruptions as well as local
+        // I/O failures. Keep it here deliberately: it is the closest Android
+        // equivalent to iOS's NSURLErrorNetworkConnectionLost.
+        WebViewClient.ERROR_IO -> true
+        else -> false
+    }
+}
+
 class MainActivity : AppCompatActivity() {
     private lateinit var webView: WebView
     private lateinit var craftBridge: CraftBridge
@@ -32,6 +50,28 @@ class MainActivity : AppCompatActivity() {
             .build()
     }
     private var loadedBundledFallback = false
+    private lateinit var connectivityManager: ConnectivityManager
+    @Volatile
+    private var isConnected = false
+    private var networkMonitoringRegistered = false
+    private val networkCallback = object : ConnectivityManager.NetworkCallback() {
+        override fun onAvailable(network: Network) {
+            val wasConnected = isConnected
+            isConnected = true
+            if (!wasConnected && isConnected) {
+                runOnUiThread {
+                    returnFromBundledFallback("the network came back")
+                }
+            }
+        }
+
+        override fun onLost(network: Network) {
+            // A second transport can already be the default by the time the
+            // old one reports its loss, so read current state instead of
+            // blindly turning the latch off.
+            isConnected = connectivityManager.activeNetwork != null
+        }
+    }
 
     @SuppressLint("SetJavaScriptEnabled")
     override fun onCreate(savedInstanceState: Bundle?) {
@@ -44,11 +84,31 @@ class MainActivity : AppCompatActivity() {
 
         webView = findViewById(R.id.webview)
         craftBridge = CraftBridge(this, webView, CraftHealthConnect(this, webView))
-        handleIncomingDeepLink(intent, dispatch = false)
-        if (savedInstanceState == null) handleIncomingShortcut(intent)
+        // The link that launched the app (#215). Queued until the page's bridge
+        // is injected, then dispatched once with `initial: true`, so a page that
+        // subscribes rather than calling getInitialURL still hears it.
+        //
+        // A relaunch from Recents carries the intent the app was first opened
+        // with. The person picked the task out of a list, not the link or the
+        // shortcut inside it, and neither is news the second time — so both
+        // are skipped, not just the link (#229).
+        //
+        // A recreated activity restores what the bridge saved rather than
+        // reading its intent, which onNewIntent may have replaced with a
+        // later warm link.
+        val launchedFromHistory = intent.flags and Intent.FLAG_ACTIVITY_LAUNCHED_FROM_HISTORY != 0
+        if (savedInstanceState == null) {
+            if (!launchedFromHistory) {
+                intent.data?.toString()?.let(craftBridge::receiveDeepLink)
+                handleIncomingShortcut(intent)
+            }
+        } else {
+            craftBridge.restoreDeepLinks(savedInstanceState)
+        }
 
         setupWebView()
         loadContent()
+        setupNetworkMonitoring()
     }
 
     @SuppressLint("SetJavaScriptEnabled")
@@ -94,7 +154,13 @@ class MainActivity : AppCompatActivity() {
 
             override fun onReceivedError(view: WebView?, request: WebResourceRequest?, error: WebResourceError?) {
                 super.onReceivedError(view, request, error)
-                if (request?.isForMainFrame == true && hasBundledFallback && !loadedBundledFallback) {
+                if (
+                    request?.isForMainFrame == true &&
+                    error != null &&
+                    CraftLoadFailure.isUnreachable(error.errorCode) &&
+                    hasBundledFallback &&
+                    !loadedBundledFallback
+                ) {
                     loadedBundledFallback = true
                     webView.loadUrl(BUNDLED_APP_URL)
                 }
@@ -107,6 +173,23 @@ class MainActivity : AppCompatActivity() {
         webView.addJavascriptInterface(craftBridge, "CraftAndroid")
     }
 
+    private fun setupNetworkMonitoring() {
+        if (!hasBundledFallback || devServerUrl == null) return
+        connectivityManager = getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
+        isConnected = connectivityManager.activeNetwork != null
+        connectivityManager.registerDefaultNetworkCallback(networkCallback)
+        networkMonitoringRegistered = true
+    }
+
+    /** Leave the bundled copy for the configured remote origin again. */
+    private fun returnFromBundledFallback(reason: String) {
+        val remoteUrl = devServerUrl ?: return
+        if (!loadedBundledFallback) return
+        loadedBundledFallback = false
+        Log.i(TAG, "$reason; loading $remoteUrl again instead of the bundled copy")
+        webView.loadUrl(remoteUrl)
+    }
+
     private fun loadContent() {
         // Check for dev server URL in config
         val remoteUrl = devServerUrl
@@ -150,12 +233,6 @@ class MainActivity : AppCompatActivity() {
         }
     }
 
-    private fun handleIncomingDeepLink(source: Intent?, dispatch: Boolean) {
-        val url = source?.data?.toString() ?: return
-        craftBridge.setInitialURL(url)
-        if (dispatch) craftBridge.dispatchDeepLink(url)
-    }
-
     private fun handleIncomingShortcut(source: Intent?) {
         source?.getStringExtra(SHORTCUT_TYPE_EXTRA)?.let(craftBridge::dispatchShortcut)
     }
@@ -198,10 +275,15 @@ class MainActivity : AppCompatActivity() {
         return (uri.scheme == "https" || localDevelopment) && origin in trustedOrigins
     }
 
+    override fun onSaveInstanceState(outState: Bundle) {
+        super.onSaveInstanceState(outState)
+        craftBridge.saveDeepLinks(outState)
+    }
+
     override fun onNewIntent(intent: Intent) {
         super.onNewIntent(intent)
         setIntent(intent)
-        handleIncomingDeepLink(intent, dispatch = true)
+        intent.data?.toString()?.let(craftBridge::receiveDeepLink)
         handleIncomingShortcut(intent)
     }
 
@@ -216,6 +298,7 @@ class MainActivity : AppCompatActivity() {
     override fun onResume() {
         super.onResume()
         webView.onResume()
+        returnFromBundledFallback("the app returned to the foreground")
     }
 
     override fun onPause() {
@@ -224,6 +307,10 @@ class MainActivity : AppCompatActivity() {
     }
 
     override fun onDestroy() {
+        if (networkMonitoringRegistered) {
+            connectivityManager.unregisterNetworkCallback(networkCallback)
+            networkMonitoringRegistered = false
+        }
         craftBridge.close()
         webView.destroy()
         super.onDestroy()
@@ -245,6 +332,7 @@ class MainActivity : AppCompatActivity() {
     }
 
     companion object {
+        private const val TAG = "CraftMainActivity"
         private const val BUNDLED_APP_HOST = "appassets.androidplatform.net"
         private const val BUNDLED_APP_ORIGIN = "https://appassets.androidplatform.net"
         private const val BUNDLED_APP_URL = "$BUNDLED_APP_ORIGIN/"

package/LICENSE.md

@@ -1,21 +0,0 @@
-# MIT License
-
-Copyright (c) 2025 Stacks.js
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.