Move to keychain

Author: TaeHagen

.dart_tool/build/fcd1995bc647fb959e82ea360c6c2c9a/asset_graph.json

@@ -35,41 +35,85 @@ import kotlin.concurrent.schedule
 import kotlin.coroutines.resume
 import kotlin.coroutines.suspendCoroutine
 import kotlinx.coroutines.guava.future
+import java.util.TimerTask
+import java.util.concurrent.atomic.AtomicInteger
 
 class DartWorker(context: Context, workerParams: WorkerParameters): ListenableWorker(context, workerParams) {
 
     companion object {
         var workerEngine: FlutterEngine? = null
         var engineReady = Mutex()
-    }
 
-    override fun startWork(): ListenableFuture<Result> {
-        val method = inputData.getString("method")!!
-        var data = inputData.getString("data")!!
-        val gson = GsonBuilder()
-                .setObjectToNumberStrategy(ToNumberPolicy.LONG_OR_DOUBLE)
-                .create()
-        if (method == "SMSMsg") {
-            val json: HashMap<String, Any> = gson.fromJson(data, TypeToken.getParameterized(HashMap::class.java, String::class.java, Any::class.java).type)
-            val pointer: Int = (json["id"] as Long).toInt()
-            if (MethodCallHandler.queuedMessages.contains(pointer)) {
-                data = MethodCallHandler.queuedMessages.remove(pointer)!!
-            } else {
-                // bail
-                return Futures.immediateFuture(Result.success())
+
+
+        /// Code idea taken from https://github.com/flutter/flutter/wiki/Experimental:-Reuse-FlutterEngine-across-screens
+        private suspend fun initNewEngine(applicationContext: Context) {
+            Log.d(Constants.logTag, "Ensuring Flutter is initialized before creating engine")
+            // We use the deprecated class here anyways, the new one doesn't work correctly using the same code
+            FlutterMain.startInitialization(applicationContext)
+            FlutterMain.ensureInitializationComplete(applicationContext, null)
+
+            Log.d(Constants.logTag, "Loading callback info")
+            val info = ApplicationInfoLoader.load(applicationContext)
+            workerEngine = FlutterEngine(applicationContext)
+
+            currentJobs.set(0)
+
+            workerEngine!!.addEngineLifecycleListener ( object : FlutterEngine.EngineLifecycleListener {
+                override fun onPreEngineRestart() {
+                    Log.d(Constants.logTag, "Engine is restarting")
+                }
+
+                override fun onEngineWillDestroy() {
+                    Log.d(Constants.logTag, "Engine is being destroyed")
+                }
+            })
+            suspendCoroutine { cont ->
+                // set up the method channel to receive events from Dart
+                MethodChannel(workerEngine!!.dartExecutor.binaryMessenger, Constants.methodChannel).setMethodCallHandler {
+                        call, result -> run {
+                    if (call.method == "ready") {
+                        Log.d(Constants.logTag, "Dart engine is ready!")
+                        cont.resume(Unit)
+                    } else {
+                        MethodCallHandler().methodCallHandler(call, result, applicationContext)
+                    }
+                }
+                }
+                val callbackInfo = FlutterCallbackInformation.lookupCallbackInformation(applicationContext.getSharedPreferences("FlutterSharedPreferences", 0).getLong("flutter.backgroundCallbackHandle", -1))
+                val callback = DartExecutor.DartCallback(applicationContext.assets, info.flutterAssetsDir, callbackInfo)
+
+                Log.d(Constants.logTag, "Executing Dart callback")
+                workerEngine!!.dartExecutor.executeDartCallback(callback)
             }
         }
 
-        if (engine != null) {
-            Log.d(Constants.logTag, "Using MainActivity engine to send to Dart")
-        } else {
-            Log.d(Constants.logTag, "Using DartWorker engine to send to Dart")
+        var currentCancelTask: TimerTask? = null
+        private fun closeEngineIfNeeded(applicationContext: Context) {
+            currentJobs.getAndDecrement()
+            // Delay 30 seconds so Dart has a chance to complete everything and in case new work comes in shortly after
+            currentCancelTask?.cancel()
+            currentCancelTask = Timer().schedule(30000) {
+                currentCancelTask = null
+                Log.d(Constants.logTag, "$currentJobs worker(s) still queued")
+                if (currentJobs.get() == 0 && workerEngine != null) {
+                    Log.d(Constants.logTag, "Closing ${Constants.dartWorkerTag} engine")
+                    // This must be run on main thread
+                    CoroutineScope(Dispatchers.Main).launch {
+                        workerEngine?.destroy()
+                        workerEngine = null
+                    }
+                }
+            }
         }
-        return CoroutineScope(Dispatchers.Main).future {
+
+        var currentJobs = AtomicInteger(0)
+
+        suspend fun callMethod(applicationContext: Context, method: String, arguments: Map<String, Any>) {
             engineReady.withLock {
                 if (engine == null && workerEngine == null) {
                     Log.d(Constants.logTag, "Initializing engine for worker with method $method")
-                    initNewEngine()
+                    initNewEngine(applicationContext)
                 }
             }
             Log.d(Constants.logTag, "Sending event, '$method' to Dart")
@@ -78,95 +122,73 @@ class DartWorker(context: Context, workerParams: WorkerParameters): ListenableWo
                 var engineToUse: FlutterEngine? = engine ?: workerEngine
                 if (engineToUse == null) {
                     Log.d(Constants.logTag, "Engine is null, cannot send method $method to Dart")
-                    return@future Result.failure()
+                    throw Exception("No engine")
                 }
 
                 Log.d(Constants.logTag, "Registering engine lifecycle listener")
 
-                engineToUse!!.addEngineLifecycleListener ( object : FlutterEngine.EngineLifecycleListener {
-                    override fun onPreEngineRestart() {
-                        Log.d(Constants.logTag, "Engine is restarting")
-                    }
-
-                    override fun onEngineWillDestroy() {
-                        Log.d(Constants.logTag, "Engine is being destroyed")
-                    }
-                })
-
                 Log.d(Constants.logTag, "Invoking method channel...")
                 suspendCoroutine { cont ->
-                    MethodChannel(engineToUse!!.dartExecutor.binaryMessenger, Constants.methodChannel).invokeMethod(method, gson.fromJson(data, TypeToken.getParameterized(HashMap::class.java, String::class.java, Any::class.java).type), object : MethodChannel.Result {
+                    currentJobs.getAndIncrement()
+                    MethodChannel(engineToUse!!.dartExecutor.binaryMessenger, Constants.methodChannel).invokeMethod(method, arguments, object : MethodChannel.Result {
                         override fun success(result: Any?) {
                             Log.d(Constants.logTag, "Worker with method $method completed successfully")
                             cont.resume(Result.success())
-                            closeEngineIfNeeded()
+                            closeEngineIfNeeded(applicationContext)
                         }
-    
+
                         override fun error(errorCode: String, errorMessage: String?, errorDetails: Any?) {
                             Log.e(Constants.logTag, "Worker with method $method failed!")
                             cont.resume(Result.failure())
-                            closeEngineIfNeeded()
+                            closeEngineIfNeeded(applicationContext)
                         }
-    
+
                         override fun notImplemented() {
                             Log.e(Constants.logTag, "Worker with method $method not implemented on Dart side")
                             cont.resume(Result.failure())
-                            closeEngineIfNeeded()
+                            closeEngineIfNeeded(applicationContext)
                         }
                     })
                 }
 
                 Log.d(Constants.logTag, "Worker with method $method completed successfully")
-                return@future Result.success()
             } catch (e: Exception) {
                 Log.d(Constants.logTag, "Error sending method $method to Dart: ${e.message}")
-                return@future Result.failure()
+                throw e
             }
         }
     }
 
-    /// Code idea taken from https://github.com/flutter/flutter/wiki/Experimental:-Reuse-FlutterEngine-across-screens
-    private suspend fun initNewEngine() {
-        Log.d(Constants.logTag, "Ensuring Flutter is initialized before creating engine")
-        // We use the deprecated class here anyways, the new one doesn't work correctly using the same code
-        FlutterMain.startInitialization(applicationContext)
-        FlutterMain.ensureInitializationComplete(applicationContext, null)
-
-        Log.d(Constants.logTag, "Loading callback info")
-        val info = ApplicationInfoLoader.load(applicationContext)
-        workerEngine = FlutterEngine(applicationContext)
-        suspendCoroutine { cont ->
-            // set up the method channel to receive events from Dart
-            MethodChannel(workerEngine!!.dartExecutor.binaryMessenger, Constants.methodChannel).setMethodCallHandler {
-                call, result -> run {
-                    if (call.method == "ready") {
-                        Log.d(Constants.logTag, "Dart engine is ready!")
-                        cont.resume(Unit)
-                    } else {
-                        MethodCallHandler().methodCallHandler(call, result, applicationContext)
-                    }
-                }
+    override fun startWork(): ListenableFuture<Result> {
+        val method = inputData.getString("method")!!
+        var data = inputData.getString("data")!!
+        val gson = GsonBuilder()
+                .setObjectToNumberStrategy(ToNumberPolicy.LONG_OR_DOUBLE)
+                .create()
+        if (method == "SMSMsg") {
+            val json: HashMap<String, Any> = gson.fromJson(data, TypeToken.getParameterized(HashMap::class.java, String::class.java, Any::class.java).type)
+            val pointer: Int = (json["id"] as Long).toInt()
+            if (MethodCallHandler.queuedMessages.contains(pointer)) {
+                data = MethodCallHandler.queuedMessages.remove(pointer)!!
+            } else {
+                // bail
+                return Futures.immediateFuture(Result.success())
             }
-            val callbackInfo = FlutterCallbackInformation.lookupCallbackInformation(applicationContext.getSharedPreferences("FlutterSharedPreferences", 0).getLong("flutter.backgroundCallbackHandle", -1))
-            val callback = DartExecutor.DartCallback(applicationContext.assets, info.flutterAssetsDir, callbackInfo)
-
-            Log.d(Constants.logTag, "Executing Dart callback")
-            workerEngine!!.dartExecutor.executeDartCallback(callback)
         }
-    }
 
-    private fun closeEngineIfNeeded() {
-        // Delay 5 seconds so Dart has a chance to complete everything and in case new work comes in shortly after
-        Timer().schedule(5000) {
-            val currentWork = WorkManager.getInstance(applicationContext).getWorkInfosByTag(Constants.dartWorkerTag).get().filter { element -> !element.state.isFinished }
-            Log.d(Constants.logTag, "${currentWork.size} worker(s) still queued")
-            if (currentWork.isEmpty() && workerEngine != null) {
-                Log.d(Constants.logTag, "Closing ${Constants.dartWorkerTag} engine")
-                // This must be run on main thread
-                CoroutineScope(Dispatchers.Main).launch {
-                    workerEngine?.destroy()
-                    workerEngine = null
-                }
+        if (engine != null) {
+            Log.d(Constants.logTag, "Using MainActivity engine to send to Dart")
+        } else {
+            Log.d(Constants.logTag, "Using DartWorker engine to send to Dart")
+        }
+        return CoroutineScope(Dispatchers.Main).future {
+            val arguments: HashMap<String, Any> = gson.fromJson(data, TypeToken.getParameterized(HashMap::class.java, String::class.java, Any::class.java).type)
+            try {
+                callMethod(applicationContext, method, arguments)
+                Result.success()
+            } catch (e: Exception) {
+                Log.d(Constants.logTag, "Error sending method $method to Dart: ${e.message}")
+                Result.failure()
             }
         }
     }

android/app/src/main/kotlin/com/bluebubbles/messaging/services/backend_ui_interop/DartWorker.kt

@@ -41,6 +41,7 @@ import com.bluebubbles.messaging.services.notifications.CreateMissedFaceTimeNoti
 import com.bluebubbles.messaging.services.rustpush.AppleAccountLoginHandler
 import com.bluebubbles.messaging.services.rustpush.EAPAKAGateway
 import com.bluebubbles.messaging.services.rustpush.GetNativeHandleHandler
+import com.bluebubbles.messaging.services.rustpush.KeystoreUnlockHandler
 import com.bluebubbles.messaging.services.rustpush.ProvisionNative
 import com.bluebubbles.messaging.services.rustpush.SMSLessAuthGateway
 import com.bluebubbles.messaging.services.system.EnableBTHandler
@@ -139,6 +140,7 @@ class MethodCallHandler {
             ShizukuGrantPermissionHandler.tag -> ShizukuGrantPermissionHandler().handleMethodCall(call, result, context)
             ProvisionNative.tag -> ProvisionNative().handleMethodCall(call, result, context)
             EAPAKAGateway.tag -> EAPAKAGateway().handleMethodCall(call, result, context)
+            KeystoreUnlockHandler.tag -> KeystoreUnlockHandler().handleMethodCall(call, result, context)
             "ready" -> { MainActivity.engine_ready = true }
             else -> {
                 val error = "Could not find method call handler for ${call.method}!"

android/app/src/main/kotlin/com/bluebubbles/messaging/services/backend_ui_interop/MethodCallHandler.kt

@@ -22,6 +22,7 @@ import androidx.core.content.ContextCompat
 import com.bluebubbles.messaging.MainActivity
 import com.bluebubbles.messaging.R
 import com.bluebubbles.messaging.services.backend_ui_interop.DartWorkManager
+import com.bluebubbles.messaging.services.backend_ui_interop.DartWorker
 import com.bluebubbles.messaging.services.backend_ui_interop.MethodCallHandler
 import com.bluebubbles.messaging.services.system.GetZenMode
 import com.bluebubbles.messaging.services.system.ZenModeUUIDHandler
@@ -31,9 +32,11 @@ import com.google.gson.ToNumberPolicy
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.launch
 import uniffi.rust_lib_bluebubbles.NativePushState
 import uniffi.rust_lib_bluebubbles.initNative
 import uniffi.rust_lib_bluebubbles.MsgReceiver
+import uniffi.rust_lib_bluebubbles.setupKeystore
 import uniffi.rust_lib_bluebubbles.start
 
 class APNService : Service(), MsgReceiver {
@@ -71,7 +74,9 @@ class APNService : Service(), MsgReceiver {
                 return@post
             }
             Log.i("ugh running", "backend $ptr $retry")
-            DartWorkManager.createWorker(this@APNService, "APNMsg", hashMapOf("pointer" to ptr.toString(), "retry" to retry.toString())) {}
+            CoroutineScope(Dispatchers.Main).launch {
+                DartWorker.callMethod(this@APNService, "APNMsg", mapOf("pointer" to ptr.toString(), "retry" to retry.toString()))
+            }
         }
     }
 
@@ -114,6 +119,7 @@ class APNService : Service(), MsgReceiver {
         pushState?.publishStatus(uuid)
     }
 
+    val keystore = AndroidNativeKeystore(this)
 
     fun launchAgent() {
         Log.i("launching agent", "herer")
@@ -123,12 +129,9 @@ class APNService : Service(), MsgReceiver {
                 MethodCallHandler.invokeMethod("SMSMsg", map)
                 return@init
             }
-            MethodCallHandler.queueId += 1
-            val gson = GsonBuilder()
-                .setObjectToNumberStrategy(ToNumberPolicy.LONG_OR_DOUBLE)
-                .create()
-            MethodCallHandler.queuedMessages[MethodCallHandler.queueId] = gson.toJson(map).toString()
-            DartWorkManager.createWorker(context, "SMSMsg", hashMapOf("id" to MethodCallHandler.queueId)) {}
+            CoroutineScope(Dispatchers.Main).launch {
+                DartWorker.callMethod(this@APNService, "SMSMsg", map)
+            }
         }
 
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
@@ -151,8 +154,14 @@ class APNService : Service(), MsgReceiver {
             )
         }
 
+        Log.i("here", "hjeal")
+
         start(applicationContext.filesDir.path, AndroidFilePackager(this))
+        setupKeystore(applicationContext.filesDir.path, keystore)
+        keystore.checkMaster()
+        Log.i("here", "hjealme")
 
+        Log.i("here", "hwallow")
         initNative(applicationContext.filesDir.path, null, this)
     }