fix js appmessage ack/nack events/callbacks

Author: crc-32

android/shared/src/androidMain/kotlin/io/rebble/cobble/shared/js/WebViewPrivatePKJSInterface.kt

@@ -9,15 +9,15 @@ import io.rebble.cobble.shared.data.js.fromDevice
 import io.rebble.cobble.shared.database.dao.LockerDao
 import io.rebble.cobble.shared.domain.state.ConnectionStateManager
 import io.rebble.cobble.shared.domain.state.watchOrNull
-import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.*
 import kotlinx.coroutines.flow.MutableSharedFlow
-import kotlinx.coroutines.launch
 import kotlinx.serialization.encodeToString
 import kotlinx.serialization.json.Json
 import org.koin.core.component.KoinComponent
 import org.koin.core.component.inject
+import kotlin.time.Duration.Companion.seconds
 
-class WebViewPrivatePKJSInterface(private val jsRunner: WebViewJsRunner, private val scope: CoroutineScope, private val outgoingAppMessages: MutableSharedFlow<String>): PrivatePKJSInterface, KoinComponent {
+class WebViewPrivatePKJSInterface(private val jsRunner: WebViewJsRunner, private val scope: CoroutineScope, private val outgoingAppMessages: MutableSharedFlow<Pair<CompletableDeferred<UByte>, String>>): PrivatePKJSInterface, KoinComponent {
     private val lockerDao: LockerDao by inject()
 
     @JavascriptInterface
@@ -118,10 +118,17 @@ class WebViewPrivatePKJSInterface(private val jsRunner: WebViewJsRunner, private
     }
 
     @JavascriptInterface
-    fun sendAppMessageString(jsonAppMessage: String) {
+    fun sendAppMessageString(jsonAppMessage: String): Int {
         Logging.v("sendAppMessageString")
-        if (!outgoingAppMessages.tryEmit(jsonAppMessage)) {
+        val completable = CompletableDeferred<UByte>()
+        if (!outgoingAppMessages.tryEmit(Pair(completable, jsonAppMessage))) {
             Logging.e("Failed to emit outgoing AppMessage")
+            error("Failed to emit outgoing AppMessage")
+        }
+        return runBlocking {
+            withTimeout(10.seconds) {
+                completable.await().toInt()
+            }
         }
     }
 

android/shared/src/commonMain/kotlin/io/rebble/cobble/shared/js/JsRunner.kt

@@ -2,6 +2,7 @@ package io.rebble.cobble.shared.js
 
 import io.rebble.cobble.shared.domain.common.PebbleDevice
 import io.rebble.libpebblecommon.metadata.pbw.appinfo.PbwAppInfo
+import kotlinx.coroutines.CompletableDeferred
 import kotlinx.coroutines.flow.MutableSharedFlow
 import kotlinx.coroutines.flow.asSharedFlow
 
@@ -13,6 +14,6 @@ abstract class JsRunner(val appInfo: PbwAppInfo, val jsPath: String, val device:
     abstract suspend fun signalAppMessageAck(data: String?): Boolean
     abstract suspend fun signalAppMessageNack(data: String?): Boolean
 
-    protected val _outgoingAppMessages = MutableSharedFlow<String>(extraBufferCapacity = 1)
+    protected val _outgoingAppMessages = MutableSharedFlow<Pair<CompletableDeferred<UByte>, String>>(extraBufferCapacity = 1)
     val outgoingAppMessages = _outgoingAppMessages.asSharedFlow()
 }

android/shared/src/commonMain/kotlin/io/rebble/cobble/shared/js/PKJSApp.kt

@@ -47,7 +47,7 @@ class PKJSApp(val uuid: Uuid): KoinComponent {
                 Logging.v("Ignoring app message for different app: ${it.uuid.get()} != $uuid")
                 return@onEach
             }
-            Logging.d("Received app message: $it")
+            Logging.d("Received app message: ${it::class.simpleName} ${it.transactionId}")
             withTimeout(1000) {
                 device.outgoingAppMessages.emit(OutgoingMessage.Ack(AppMessage.AppMessageACK(it.transactionId.get())))
             }
@@ -59,11 +59,12 @@ class PKJSApp(val uuid: Uuid): KoinComponent {
         }.catch {
             Logging.e("Error receiving app message", it)
         }.launchIn(scope)
-        jsRunner?.outgoingAppMessages?.onEach {
-            Logging.d("Sending app message: $it")
-            val appMessage = AppMessage.fromJSDataString(it, appInfo)
+        jsRunner?.outgoingAppMessages?.onEach { (tIDDeferred, data) ->
+            Logging.d("Sending app message: $data")
+            val appMessage = AppMessage.fromJSDataString(data, appInfo)
             val tID = device.appMessageTransactionSequence.next()
             appMessage.transactionId.set(tID)
+            tIDDeferred.complete(tID)
             device.appMessageService.send(appMessage)
         }?.catch {
             Logging.e("Error sending app message", it)