one 2.0.0-beta.115.1 → 2.0.0-beta.120.1

package/android/src/main/java/com/margelo/nitro/one/HybridOneFetch.kt

@@ -1,6 +1,7 @@
 package com.margelo.nitro.one
 
 import android.net.Uri
+import android.util.Base64
 import android.webkit.MimeTypeMap
 import com.facebook.react.modules.blob.BlobModule
 import com.facebook.react.modules.network.CookieJarContainer
@@ -8,8 +9,14 @@ import com.facebook.react.modules.network.ForwardingCookieHandler
 import com.facebook.react.modules.network.OkHttpClientProvider
 import com.margelo.nitro.NitroModules
 import com.margelo.nitro.core.ArrayBuffer
+import java.io.ByteArrayInputStream
+import java.io.File
+import java.io.FileInputStream
+import java.io.FileOutputStream
 import java.io.IOException
 import java.io.InputStream
+import java.net.URL
+import java.nio.channels.Channels
 import java.util.concurrent.ConcurrentHashMap
 import java.util.concurrent.Executors
 import okhttp3.Call
@@ -27,6 +34,7 @@ import okhttp3.RequestBody.Companion.toRequestBody
 import okhttp3.Response
 import okhttp3.internal.http.HttpMethod
 import okio.BufferedSink
+import okio.source
 
 // the global fetch on native, over an OkHttp client built the way react
 // native's NetworkingModule builds its own: from OkHttpClientProvider, so an
@@ -67,6 +75,26 @@ class HybridOneFetch : HybridOneFetchSpec() {
             readLocal(id, request.url, onResponse, onChunk, onComplete, onError)
             return
         }
+        if (request.form?.any { it.uri != null } == true) {
+            // react native opens every { uri } part before it sends, downloading
+            // an http one, so that runs off the js thread; a cancel meanwhile
+            // leaves no entry for send to replace
+            active[id] = {}
+            local.execute { send(id, request, true, onResponse, onChunk, onComplete, onError) }
+            return
+        }
+        send(id, request, false, onResponse, onChunk, onComplete, onError)
+    }
+
+    private fun send(
+        id: Double,
+        request: FetchNativeRequest,
+        pending: Boolean,
+        onResponse: (response: FetchNativeResponse) -> Unit,
+        onChunk: (chunk: ArrayBuffer) -> Unit,
+        onComplete: () -> Unit,
+        onError: (message: String) -> Unit
+    ) {
         val built = try {
             val builder = Request.Builder().url(request.url)
             for (header in request.headers) builder.addHeader(header.name, header.value)
@@ -75,12 +103,17 @@ class HybridOneFetch : HybridOneFetchSpec() {
                 ?.value?.toMediaTypeOrNull()
             builder.method(request.method, body(request, type))
             builder.build()
-        } catch (error: IllegalArgumentException) {
-            onError(error.message ?: "invalid request")
+        } catch (error: Exception) {
+            if (!pending || active.remove(id) != null) onError(error.message ?: "invalid request")
             return
         }
         val call = (if (request.omitCredentials) clientWithoutCookies else client).newCall(built)
-        active[id] = { call.cancel() }
+        val cancel = { call.cancel() }
+        if (pending) {
+            if (active.replace(id, cancel) == null) return
+        } else {
+            active[id] = cancel
+        }
         call.enqueue(object : Callback {
             override fun onFailure(call: Call, e: IOException) {
                 if (active.remove(id) != null) onError(e.message ?: e.javaClass.simpleName)
@@ -115,10 +148,11 @@ class HybridOneFetch : HybridOneFetchSpec() {
         context.getNativeModule(BlobModule::class.java)
             ?: throw IllegalStateException("fetch: react native's BlobModule is not loaded")
 
-    // the request body. js-owned bytes are copied now, during the call;
-    // blobs, files and multipart parts are read on the network thread. every
-    // length is known up front where react native's was, so uploads carry a
-    // content-length rather than going out chunked.
+    // the request body. js-owned bytes are copied now, during the call; blobs
+    // are read on the network thread, and { uri } parts open before sending,
+    // as react native opens them. every length is known up front where react
+    // native's was, so uploads carry a content-length rather than going out
+    // chunked.
     private fun body(request: FetchNativeRequest, type: MediaType?): RequestBody? {
         request.body?.let { return it.toByteArray().toRequestBody(type) }
         request.blob?.let { return blobBody(it, type) }
@@ -137,13 +171,43 @@ class HybridOneFetch : HybridOneFetchSpec() {
         }
     }
 
-    private fun uriBody(uri: String, type: MediaType?) = object : RequestBody() {
+    // react native's RequestBodyUtil.getFileInputStream, which is internal to
+    // react native: an http(s) uri downloads to a cache file first, a data: uri
+    // decodes its base64, anything else opens through the content resolver
+    private fun partStream(uri: String): InputStream {
+        val parsed = Uri.parse(uri)
+        if (parsed.scheme?.startsWith("http") == true) {
+            val file = File.createTempFile("RequestBodyUtil", "temp", context.applicationContext.cacheDir)
+            file.deleteOnExit()
+            FileOutputStream(file).use { output ->
+                URL(uri).openStream().use { input ->
+                    Channels.newChannel(input).use { channel ->
+                        output.channel.transferFrom(channel, 0, Long.MAX_VALUE)
+                    }
+                }
+            }
+            return FileInputStream(file)
+        }
+        if (uri.startsWith("data:")) {
+            return ByteArrayInputStream(Base64.decode(uri.split(",")[1], Base64.DEFAULT))
+        }
+        return context.contentResolver.openInputStream(parsed)
+            ?: throw IOException("Could not retrieve file for uri $uri")
+    }
+
+    // react native's RequestBodyUtil.create: the stream's available bytes are
+    // the part's length
+    private fun streamBody(type: MediaType, input: InputStream) = object : RequestBody() {
         override fun contentType() = type
         override fun contentLength() =
-            context.contentResolver.openAssetFileDescriptor(Uri.parse(uri), "r")?.use { it.length }
-                ?: -1L
+            try {
+                input.available().toLong()
+            } catch (e: IOException) {
+                0L
+            }
+        override fun isOneShot() = true
         override fun writeTo(sink: BufferedSink) {
-            open(uri).use { input -> input.copyTo(sink.outputStream()) }
+            input.use { sink.writeAll(it.source()) }
         }
     }
 
@@ -167,14 +231,21 @@ class HybridOneFetch : HybridOneFetchSpec() {
                 builder.addPart(Headers.headersOf("Content-Disposition", disposition), value.toRequestBody())
                 continue
             }
-            val filename = part.filename ?: part.uri?.let { Uri.parse(it).lastPathSegment }
+            val filename = part.filename
             if (filename != null) disposition += "; filename=\"${escape(filename)}\""
-            val type = (part.type ?: "application/octet-stream").toMediaTypeOrNull()
             val uri = part.uri
             val blob = part.blob
             val body = when {
-                uri != null -> uriBody(uri, type)
-                blob != null -> blobBody(blob, type)
+                uri != null -> streamBody(
+                    part.type?.toMediaTypeOrNull()
+                        ?: throw IOException("Binary FormData part needs a content-type header."),
+                    try {
+                        partStream(uri)
+                    } catch (error: Exception) {
+                        throw IOException("Could not retrieve file for uri $uri", error)
+                    }
+                )
+                blob != null -> blobBody(blob, (part.type ?: "application/octet-stream").toMediaTypeOrNull())
                 else -> throw IOException("fetch: FormData part ${part.name} has no value")
             }
             builder.addPart(Headers.headersOf("Content-Disposition", disposition), body)

package/android/src/main/java/com/margelo/nitro/one/HybridOneNativeModules.kt

@@ -0,0 +1,40 @@
+package com.margelo.nitro.one
+
+import com.margelo.nitro.core.Promise
+import dev.onejs.one.OneNativeSourceDispatch
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.launch
+
+class HybridOneNativeModules : HybridOneNativeModulesSpec() {
+    private val main = CoroutineScope(SupervisorJob() + Dispatchers.Main.immediate)
+    private val instances = mutableMapOf<String, OneNativeSourceDispatch>()
+
+    override fun call(module: String, methodName: String, argsJson: String, contractHash: String): Promise<String> {
+        val promise = Promise<String>()
+        main.launch {
+            try {
+                val packageName = module.substringBefore('.', "")
+                if (packageName.isEmpty() || !module.contains('.')) {
+                    throw OneNativeError("E_NATIVE_SOURCE", "invalid module $module")
+                }
+                val dispatcher = instances.getOrPut(packageName) {
+                    val name = "OneNativeSource_$packageName"
+                    val type = Class.forName(name)
+                    type.getDeclaredConstructor().newInstance() as OneNativeSourceDispatch
+                }
+                if (dispatcher.contractHash != contractHash) {
+                    throw OneNativeError("E_NATIVE_SOURCE_REBUILD", "native module $module changed; rebuild the app")
+                }
+                promise.resolve(dispatcher.call(module, methodName, argsJson))
+            } catch (error: Exception) {
+                promise.reject(
+                    if (error is OneNativeError) error
+                    else OneNativeError("E_NATIVE_SOURCE", "$module.$methodName: ${error.message}")
+                )
+            }
+        }
+        return promise
+    }
+}

package/android/src/main/java/com/margelo/nitro/one/HybridOneSecureStore.kt

@@ -120,35 +120,48 @@ class HybridOneSecureStore : HybridOneSecureStoreSpec() {
         }
     }
 
-    // any platform failure rejects with the stable code for its verb.
-    private fun <T> guarded(code: String, verb: String, body: () -> T): Promise<T> =
-        Promise.async {
-            try {
-                body()
-            } catch (e: Exception) {
-                throw OneNativeError(code, "SecureStore.$verb: ${e.message}")
-            }
+    // any platform failure throws or rejects with the stable code for its verb.
+    private fun <T> guarded(code: String, verb: String, body: () -> T): T =
+        try {
+            body()
+        } catch (e: Exception) {
+            throw OneNativeError(code, "SecureStore.$verb: ${e.message}")
         }
 
-    override fun getItem(key: String): Promise<String?> =
-        guarded("E_SECURE_STORE_GET", "getItem") {
-            val blob = prefs().getString(key, null) ?: return@guarded null
-            decrypt(blob)
+    private fun read(key: String): String? {
+        val blob = prefs().getString(key, null) ?: return null
+        return decrypt(blob)
+    }
+
+    private fun write(key: String, value: String) {
+        if (!prefs().edit().putString(key, encrypt(value)).commit()) {
+            throw SecureStoreException("the write could not be committed to disk")
         }
+    }
 
-    override fun setItem(key: String, value: String): Promise<Unit> =
-        guarded("E_SECURE_STORE_SET", "setItem") {
-            if (!prefs().edit().putString(key, encrypt(value)).commit()) {
-                throw SecureStoreException("the write could not be committed to disk")
-            }
+    private fun remove(key: String) {
+        if (!prefs().edit().remove(key).commit()) {
+            throw SecureStoreException("the delete could not be committed to disk")
         }
+    }
+
+    override fun getItem(key: String): Promise<String?> =
+        Promise.async { guarded("E_SECURE_STORE_GET", "getItem") { read(key) } }
+
+    override fun setItem(key: String, value: String): Promise<Unit> =
+        Promise.async { guarded("E_SECURE_STORE_SET", "setItem") { write(key, value) } }
 
     override fun deleteItem(key: String): Promise<Unit> =
-        guarded("E_SECURE_STORE_DELETE", "deleteItem") {
-            if (!prefs().edit().remove(key).commit()) {
-                throw SecureStoreException("the delete could not be committed to disk")
-            }
-        }
+        Promise.async { guarded("E_SECURE_STORE_DELETE", "deleteItem") { remove(key) } }
+
+    override fun getItemSync(key: String): String? =
+        guarded("E_SECURE_STORE_GET", "getItemSync") { read(key) }
+
+    override fun setItemSync(key: String, value: String) =
+        guarded("E_SECURE_STORE_SET", "setItemSync") { write(key, value) }
+
+    override fun deleteItemSync(key: String) =
+        guarded("E_SECURE_STORE_DELETE", "deleteItemSync") { remove(key) }
 
     private class SecureStoreException(message: String) : Exception(message)
 

package/android/src/main/java/com/margelo/nitro/one/OneLaunchScreen.kt

@@ -0,0 +1,41 @@
+package com.margelo.nitro.one
+
+import android.app.Activity
+import android.view.View
+import android.view.ViewTreeObserver
+import com.facebook.react.bridge.ReactMarker
+import com.facebook.react.bridge.ReactMarkerConstants
+
+// the prebuilt MainActivity calls this right after super.onCreate. the
+// activity's content skips drawing until react native's root view logs its
+// first content, which is android's documented way to keep the splash on
+// screen: the android 12+ system splash, or the launch theme's window
+// background below that, never gives way to an empty root.
+object OneLaunchScreen {
+    @JvmStatic
+    fun hold(activity: Activity) {
+        val content = activity.findViewById<View>(android.R.id.content)
+        var appeared = false
+        lateinit var marker: ReactMarker.MarkerListener
+        marker = ReactMarker.MarkerListener { name, _, _ ->
+            if (name != ReactMarkerConstants.CONTENT_APPEARED) return@MarkerListener
+            // markers can log off the main thread; the flag and the redraw
+            // both land on it.
+            content.post {
+                ReactMarker.removeListener(marker)
+                appeared = true
+                content.invalidate()
+            }
+        }
+        ReactMarker.addListener(marker)
+        content.viewTreeObserver.addOnPreDrawListener(
+            object : ViewTreeObserver.OnPreDrawListener {
+                override fun onPreDraw(): Boolean {
+                    if (!appeared) return false
+                    content.viewTreeObserver.removeOnPreDrawListener(this)
+                    return true
+                }
+            }
+        )
+    }
+}

package/android/src/main/java/dev/onejs/one/OneNativeSourceDispatch.kt

@@ -0,0 +1,6 @@
+package dev.onejs.one
+
+interface OneNativeSourceDispatch {
+    val contractHash: String
+    suspend fun call(module: String, method: String, argsJson: String): String
+}

package/android/src/main/java/dev/onejs/one/source/OneModule.kt

@@ -0,0 +1,3 @@
+package dev.onejs.one.source
+
+interface OneModule

package/android/src/main/java/dev/onejs/onenative/OneNativeComposeNodeEvents.kt

@@ -121,14 +121,14 @@ internal class OneNativeComposeNodeDialogDismissEvent(
         }
 }
 
-internal class OneNativeComposeNodeSwitchValueChangeEvent(
+internal class OneNativeComposeNodeBooleanValueChangeEvent(
     surfaceId: Int,
     viewTag: Int,
     private val value: Boolean,
     private val eventCount: Int,
     private val revision: Int,
-) : Event<OneNativeComposeNodeSwitchValueChangeEvent>(surfaceId, viewTag) {
-    override fun getEventName(): String = "topNativeComposeNodeSwitchValueChange"
+) : Event<OneNativeComposeNodeBooleanValueChangeEvent>(surfaceId, viewTag) {
+    override fun getEventName(): String = "topNativeComposeNodeBooleanValueChange"
 
     override fun canCoalesce(): Boolean = false
 

package/android/src/main/java/dev/onejs/onenative/OneNativeComposeNodeManager.kt

@@ -81,8 +81,8 @@ class OneNativeComposeNodeManager :
             super.getExportedCustomDirectEventTypeConstants()?.toMutableMap() ?: mutableMapOf()
         events["topNativeComposeNodeButtonPress"] =
             mapOf("registrationName" to "onNativeComposeNodeButtonPress")
-        events["topNativeComposeNodeSwitchValueChange"] =
-            mapOf("registrationName" to "onNativeComposeNodeSwitchValueChange")
+        events["topNativeComposeNodeBooleanValueChange"] =
+            mapOf("registrationName" to "onNativeComposeNodeBooleanValueChange")
         events["topNativeComposeNodeTextValueChange"] =
             mapOf("registrationName" to "onNativeComposeNodeTextValueChange")
         events["topNativeComposeNodeTextFieldFocusChange"] =
@@ -154,6 +154,70 @@ class OneNativeComposeNodeManager :
         view.stageValue(value)
     }
 
+    override fun setNativeClickable(view: OneNativeComposeNodeView, value: Boolean) {
+        view.stageNativeClickable(value)
+    }
+
+    override fun setCheckboxColors(view: OneNativeComposeNodeView, value: ReadableMap?) {
+        view.stageCheckboxColors(value)
+    }
+
+    override fun setSelected(view: OneNativeComposeNodeView, value: Boolean) {
+        view.stageSelected(value)
+    }
+
+    override fun setRadioColors(view: OneNativeComposeNodeView, value: ReadableMap?) {
+        view.stageRadioColors(value)
+    }
+
+    override fun setCardColors(view: OneNativeComposeNodeView, value: ReadableMap?) {
+        view.stageCardColors(value)
+    }
+
+    override fun setBadgeColors(view: OneNativeComposeNodeView, value: ReadableMap?) {
+        view.stageBadgeColors(value)
+    }
+
+    override fun setListItemColors(view: OneNativeComposeNodeView, value: ReadableMap?) {
+        view.stageListItemColors(value)
+    }
+
+    override fun setTonalElevation(view: OneNativeComposeNodeView, value: Double) {
+        view.stageTonalElevation(value)
+    }
+
+    override fun setShadowElevation(view: OneNativeComposeNodeView, value: Double) {
+        view.stageShadowElevation(value)
+    }
+
+    override fun setCardElevation(view: OneNativeComposeNodeView, value: Double) {
+        view.stageCardElevation(value)
+    }
+
+    override fun setCardBorder(view: OneNativeComposeNodeView, value: ReadableMap?) {
+        view.stageCardBorder(value)
+    }
+
+    override fun setDividerStyle(view: OneNativeComposeNodeView, value: ReadableMap?) {
+        view.stageDividerStyle(value)
+    }
+
+    override fun setSlotName(view: OneNativeComposeNodeView, value: String?) {
+        view.stageSlotName(value)
+    }
+
+    override fun setChipColors(view: OneNativeComposeNodeView, value: ReadableMap?) {
+        view.stageChipColors(value)
+    }
+
+    override fun setChipElevation(view: OneNativeComposeNodeView, value: Double) {
+        view.stageChipElevation(value)
+    }
+
+    override fun setChipBorder(view: OneNativeComposeNodeView, value: ReadableMap?) {
+        view.stageChipBorder(value)
+    }
+
     override fun setAcknowledgedEvent(view: OneNativeComposeNodeView, value: Int) {
         view.stageAcknowledgedEvent(value)
     }