@thelacanians/vue-native-cli 0.4.11 → 0.4.13

package/native/android/VueNativeCore/src/main/kotlin/com/vuenative/core/Components/Factories/VSegmentedControlFactory.kt

@@ -9,7 +9,7 @@ import org.json.JSONArray
 
 class VSegmentedControlFactory : NativeComponentFactory {
     private val changeHandlers = mutableMapOf<RadioGroup, (Any?) -> Unit>()
-    private val segmentValues  = mutableMapOf<RadioGroup, List<String>>()
+    private val segmentValues = mutableMapOf<RadioGroup, List<String>>()
 
     override fun createView(context: Context): View {
         return RadioGroup(context).apply {
@@ -27,8 +27,8 @@ class VSegmentedControlFactory : NativeComponentFactory {
             "values" -> {
                 val labels = when (value) {
                     is JSONArray -> (0 until value.length()).map { value.getString(it) }
-                    is List<*>   -> value.map { it?.toString() ?: "" }
-                    else         -> emptyList()
+                    is List<*> -> value.map { it?.toString() ?: "" }
+                    else -> emptyList()
                 }
                 segmentValues[rg] = labels
                 rg.removeAllViews()

package/native/android/VueNativeCore/src/main/kotlin/com/vuenative/core/Components/Factories/VStatusBarFactory.kt

@@ -1,10 +1,10 @@
 package com.vuenative.core
 
+import android.content.Context
 import android.os.Build
 import android.view.View
 import android.view.ViewGroup
 import android.view.WindowInsetsController
-import android.content.Context
 
 class VStatusBarFactory : NativeComponentFactory {
     override fun createView(context: Context): View = View(context).apply {
@@ -21,13 +21,13 @@ class VStatusBarFactory : NativeComponentFactory {
                     val controller = window.insetsController
                     when (value) {
                         "light-content" -> controller?.setSystemBarsAppearance(0, WindowInsetsController.APPEARANCE_LIGHT_STATUS_BARS)
-                        "dark-content"  -> controller?.setSystemBarsAppearance(WindowInsetsController.APPEARANCE_LIGHT_STATUS_BARS, WindowInsetsController.APPEARANCE_LIGHT_STATUS_BARS)
+                        "dark-content" -> controller?.setSystemBarsAppearance(WindowInsetsController.APPEARANCE_LIGHT_STATUS_BARS, WindowInsetsController.APPEARANCE_LIGHT_STATUS_BARS)
                     }
                 } else {
                     @Suppress("DEPRECATION")
                     val flags = window.decorView.systemUiVisibility
                     window.decorView.systemUiVisibility = when (value) {
-                        "dark-content"  -> flags or View.SYSTEM_UI_FLAG_LIGHT_STATUS_BAR
+                        "dark-content" -> flags or View.SYSTEM_UI_FLAG_LIGHT_STATUS_BAR
                         "light-content" -> flags and View.SYSTEM_UI_FLAG_LIGHT_STATUS_BAR.inv()
                         else -> flags
                     }

package/native/android/VueNativeCore/src/main/kotlin/com/vuenative/core/Components/Factories/VSwitchFactory.kt

@@ -3,7 +3,6 @@ package com.vuenative.core
 import android.content.Context
 import android.view.View
 import android.view.ViewGroup
-import android.widget.Switch
 import androidx.appcompat.widget.SwitchCompat
 
 class VSwitchFactory : NativeComponentFactory {

package/native/android/VueNativeCore/src/main/kotlin/com/vuenative/core/Components/Factories/VViewFactory.kt

@@ -24,7 +24,10 @@ class VViewFactory : NativeComponentFactory {
     override fun addEventListener(view: View, event: String, handler: (Any?) -> Unit) {
         when (event) {
             "press" -> view.setOnClickListener { handler(null) }
-            "longPress" -> view.setOnLongClickListener { handler(null); true }
+            "longPress" -> view.setOnLongClickListener {
+                handler(null)
+                true
+            }
         }
     }
 
@@ -38,8 +41,11 @@ class VViewFactory : NativeComponentFactory {
     override fun insertChild(parent: View, child: View, index: Int) {
         val flex = parent as? FlexboxLayout ?: return
         val lp = StyleEngine.buildFlexLayoutParams(child)
-        if (index >= flex.childCount) flex.addView(child, lp)
-        else flex.addView(child, index, lp)
+        if (index >= flex.childCount) {
+            flex.addView(child, lp)
+        } else {
+            flex.addView(child, index, lp)
+        }
     }
 
     override fun removeChild(parent: View, child: View) {

package/native/android/VueNativeCore/src/main/kotlin/com/vuenative/core/Components/Factories/VWebViewFactory.kt

@@ -12,8 +12,8 @@ import android.webkit.WebViewClient
 import org.json.JSONObject
 
 class VWebViewFactory : NativeComponentFactory {
-    private val loadHandlers    = mutableMapOf<WebView, (Any?) -> Unit>()
-    private val errorHandlers   = mutableMapOf<WebView, (Any?) -> Unit>()
+    private val loadHandlers = mutableMapOf<WebView, (Any?) -> Unit>()
+    private val errorHandlers = mutableMapOf<WebView, (Any?) -> Unit>()
     private val messageHandlers = mutableMapOf<WebView, (Any?) -> Unit>()
 
     override fun createView(context: Context): View {
@@ -77,14 +77,16 @@ class VWebViewFactory : NativeComponentFactory {
     override fun addEventListener(view: View, event: String, handler: (Any?) -> Unit) {
         val wv = view as? WebView ?: return
         when (event) {
-            "load"    -> loadHandlers[wv]    = handler
-            "error"   -> errorHandlers[wv]   = handler
+            "load" -> loadHandlers[wv] = handler
+            "error" -> errorHandlers[wv] = handler
             "message" -> messageHandlers[wv] = handler
         }
     }
 
     override fun removeEventListener(view: View, event: String) {
         val wv = view as? WebView ?: return
-        loadHandlers.remove(wv); errorHandlers.remove(wv); messageHandlers.remove(wv)
+        loadHandlers.remove(wv)
+        errorHandlers.remove(wv)
+        messageHandlers.remove(wv)
     }
 }

package/native/android/VueNativeCore/src/main/kotlin/com/vuenative/core/Components/NativeComponentFactory.kt

@@ -20,8 +20,11 @@ interface NativeComponentFactory {
                 ViewGroup.LayoutParams.WRAP_CONTENT,
                 ViewGroup.LayoutParams.WRAP_CONTENT
             )
-            if (index >= vg.childCount) vg.addView(child, lp)
-            else vg.addView(child, index, lp)
+            if (index >= vg.childCount) {
+                vg.addView(child, lp)
+            } else {
+                vg.addView(child, index, lp)
+            }
         }
     }
 

package/native/android/VueNativeCore/src/main/kotlin/com/vuenative/core/Helpers/GestureHelper.kt

@@ -11,6 +11,9 @@ object GestureHelper {
     }
 
     fun attachLongPress(view: View, handler: (Any?) -> Unit) {
-        view.setOnLongClickListener { handler(null); true }
+        view.setOnLongClickListener {
+            handler(null)
+            true
+        }
     }
 }

package/native/android/VueNativeCore/src/main/kotlin/com/vuenative/core/Modules/AnimationModule.kt

@@ -22,7 +22,8 @@ class AnimationModule : NativeModule {
     private val mainHandler = Handler(Looper.getMainLooper())
 
     override fun initialize(context: Context, bridge: NativeBridge) {
-        this.context = context; this.bridge = bridge
+        this.context = context
+        this.bridge = bridge
     }
 
     override fun invoke(method: String, args: List<Any?>, bridge: NativeBridge, callback: (Any?, String?) -> Unit) {
@@ -34,15 +35,22 @@ class AnimationModule : NativeModule {
             "parallel" -> handleParallel(args, bridge, callback)
             "fadeIn" -> {
                 val nodeId = StyleEngine.toInt(args.getOrNull(0), -1)
-                val view = bridge.nodeViews[nodeId] ?: run { callback(null, null); return }
+                val view = bridge.nodeViews[nodeId] ?: run {
+                    callback(null, null)
+                    return
+                }
                 mainHandler.post {
-                    view.alpha = 0f; view.visibility = View.VISIBLE
+                    view.alpha = 0f
+                    view.visibility = View.VISIBLE
                     view.animate().alpha(1f).setDuration(300).withEndAction { callback(null, null) }.start()
                 }
             }
             "fadeOut" -> {
                 val nodeId = StyleEngine.toInt(args.getOrNull(0), -1)
-                val view = bridge.nodeViews[nodeId] ?: run { callback(null, null); return }
+                val view = bridge.nodeViews[nodeId] ?: run {
+                    callback(null, null)
+                    return
+                }
                 mainHandler.post {
                     view.animate().alpha(0f).setDuration(300).withEndAction {
                         view.visibility = View.INVISIBLE
@@ -68,11 +76,17 @@ class AnimationModule : NativeModule {
         val delay = StyleEngine.toInt(options["delay"], 0).toLong()
         val easing = options["easing"]?.toString() ?: "easeInOut"
 
-        val view = bridge.nodeViews[nodeId] ?: run { callback(null, "timing: view $nodeId not found"); return }
+        val view = bridge.nodeViews[nodeId] ?: run {
+            callback(null, "timing: view $nodeId not found")
+            return
+        }
 
         mainHandler.post {
             val animators = buildPropertyAnimators(view, toStyles)
-            if (animators.isEmpty()) { callback(true, null); return@post }
+            if (animators.isEmpty()) {
+                callback(true, null)
+                return@post
+            }
 
             val interpolator = resolveInterpolator(easing)
             val set = AnimatorSet()
@@ -81,7 +95,9 @@ class AnimationModule : NativeModule {
             set.startDelay = delay
             set.interpolator = interpolator
             set.addListener(object : AnimatorListenerAdapter() {
-                override fun onAnimationEnd(a: Animator) { callback(true, null) }
+                override fun onAnimationEnd(a: Animator) {
+                    callback(true, null)
+                }
             })
             set.start()
         }
@@ -100,11 +116,17 @@ class AnimationModule : NativeModule {
         val duration = StyleEngine.toInt(options["duration"], 500).toLong()
         val delay = StyleEngine.toInt(options["delay"], 0).toLong()
 
-        val view = bridge.nodeViews[nodeId] ?: run { callback(null, "spring: view $nodeId not found"); return }
+        val view = bridge.nodeViews[nodeId] ?: run {
+            callback(null, "spring: view $nodeId not found")
+            return
+        }
 
         mainHandler.post {
             val animators = buildPropertyAnimators(view, toStyles)
-            if (animators.isEmpty()) { callback(true, null); return@post }
+            if (animators.isEmpty()) {
+                callback(true, null)
+                return@post
+            }
 
             // Android doesn't have built-in spring for ObjectAnimator pre-API 23 DynamicAnimation.
             // Use overshoot interpolator to approximate spring feel.
@@ -114,7 +136,9 @@ class AnimationModule : NativeModule {
             set.startDelay = delay
             set.interpolator = android.view.animation.OvershootInterpolator(1.5f)
             set.addListener(object : AnimatorListenerAdapter() {
-                override fun onAnimationEnd(a: Animator) { callback(true, null) }
+                override fun onAnimationEnd(a: Animator) {
+                    callback(true, null)
+                }
             })
             set.start()
         }
@@ -127,11 +151,17 @@ class AnimationModule : NativeModule {
 
     private fun handleKeyframe(args: List<Any?>, bridge: NativeBridge, callback: (Any?, String?) -> Unit) {
         val nodeId = StyleEngine.toInt(args.getOrNull(0), -1)
-        val stepsRaw = args.getOrNull(1) as? List<*> ?: run { callback(null, "keyframe: invalid keyframes"); return }
+        val stepsRaw = args.getOrNull(1) as? List<*> ?: run {
+            callback(null, "keyframe: invalid keyframes")
+            return
+        }
         val options = toStringKeyMap(args.getOrNull(2)) ?: emptyMap()
         val duration = StyleEngine.toInt(options["duration"], 300).toLong()
 
-        val view = bridge.nodeViews[nodeId] ?: run { callback(null, "keyframe: view $nodeId not found"); return }
+        val view = bridge.nodeViews[nodeId] ?: run {
+            callback(null, "keyframe: view $nodeId not found")
+            return
+        }
 
         // Parse keyframe steps into Map<String, List<Pair<Float, Float>>> (property -> [(offset, value)])
         val propertyKeyframes = mutableMapOf<String, MutableList<Pair<Float, Float>>>()
@@ -146,7 +176,10 @@ class AnimationModule : NativeModule {
             }
         }
 
-        if (propertyKeyframes.isEmpty()) { callback(null, null); return }
+        if (propertyKeyframes.isEmpty()) {
+            callback(null, null)
+            return
+        }
 
         mainHandler.post {
             val animators = mutableListOf<Animator>()
@@ -164,12 +197,17 @@ class AnimationModule : NativeModule {
                 }
             }
 
-            if (animators.isEmpty()) { callback(null, null); return@post }
+            if (animators.isEmpty()) {
+                callback(null, null)
+                return@post
+            }
 
             val set = AnimatorSet()
             set.playTogether(animators)
             set.addListener(object : AnimatorListenerAdapter() {
-                override fun onAnimationEnd(a: Animator) { callback(null, null) }
+                override fun onAnimationEnd(a: Animator) {
+                    callback(null, null)
+                }
             })
             set.start()
         }
@@ -179,9 +217,15 @@ class AnimationModule : NativeModule {
     // args[0]: List<Map> animations [{ type, viewId, toStyles, options }, ...]
 
     private fun handleSequence(args: List<Any?>, bridge: NativeBridge, callback: (Any?, String?) -> Unit) {
-        val animationsRaw = args.getOrNull(0) as? List<*> ?: run { callback(null, "sequence: invalid args"); return }
+        val animationsRaw = args.getOrNull(0) as? List<*> ?: run {
+            callback(null, "sequence: invalid args")
+            return
+        }
         val animations = animationsRaw.mapNotNull { toStringKeyMap(it) }
-        if (animations.isEmpty()) { callback(null, null); return }
+        if (animations.isEmpty()) {
+            callback(null, null)
+            return
+        }
 
         runSequenceStep(animations, 0, bridge, callback)
     }
@@ -192,7 +236,10 @@ class AnimationModule : NativeModule {
         bridge: NativeBridge,
         callback: (Any?, String?) -> Unit
     ) {
-        if (index >= animations.size) { callback(null, null); return }
+        if (index >= animations.size) {
+            callback(null, null)
+            return
+        }
 
         val animData = animations[index]
         val method = animData["type"]?.toString() ?: "timing"
@@ -202,7 +249,10 @@ class AnimationModule : NativeModule {
 
         val subArgs: List<Any?> = listOf(viewId, toStyles, options)
         invoke(method, subArgs, bridge) { _, error ->
-            if (error != null) { callback(null, error); return@invoke }
+            if (error != null) {
+                callback(null, error)
+                return@invoke
+            }
             runSequenceStep(animations, index + 1, bridge, callback)
         }
     }
@@ -211,9 +261,15 @@ class AnimationModule : NativeModule {
     // args[0]: List<Map> animations [{ type, viewId, toStyles, options }, ...]
 
     private fun handleParallel(args: List<Any?>, bridge: NativeBridge, callback: (Any?, String?) -> Unit) {
-        val animationsRaw = args.getOrNull(0) as? List<*> ?: run { callback(null, "parallel: invalid args"); return }
+        val animationsRaw = args.getOrNull(0) as? List<*> ?: run {
+            callback(null, "parallel: invalid args")
+            return
+        }
         val animations = animationsRaw.mapNotNull { toStringKeyMap(it) }
-        if (animations.isEmpty()) { callback(null, null); return }
+        if (animations.isEmpty()) {
+            callback(null, null)
+            return
+        }
 
         val total = animations.size
         var completed = 0

package/native/android/VueNativeCore/src/main/kotlin/com/vuenative/core/Modules/AsyncStorageModule.kt

@@ -12,20 +12,35 @@ class AsyncStorageModule : NativeModule {
     }
 
     override fun invoke(method: String, args: List<Any?>, bridge: NativeBridge, callback: (Any?, String?) -> Unit) {
-        val p = prefs ?: run { callback(null, "Storage not initialized"); return }
+        val p = prefs ?: run {
+            callback(null, "Storage not initialized")
+            return
+        }
         when (method) {
             "getItem" -> {
-                val key = args.getOrNull(0)?.toString() ?: run { callback(null, "Missing key"); return }
+                val key = args.getOrNull(0)?.toString() ?: run {
+                    callback(null, "Missing key")
+                    return
+                }
                 callback(p.getString(key, null), null)
             }
             "setItem" -> {
-                val key   = args.getOrNull(0)?.toString() ?: run { callback(null, "Missing key"); return }
-                val value = args.getOrNull(1)?.toString() ?: run { callback(null, "Missing value"); return }
+                val key = args.getOrNull(0)?.toString() ?: run {
+                    callback(null, "Missing key")
+                    return
+                }
+                val value = args.getOrNull(1)?.toString() ?: run {
+                    callback(null, "Missing value")
+                    return
+                }
                 p.edit().putString(key, value).apply()
                 callback(null, null)
             }
             "removeItem" -> {
-                val key = args.getOrNull(0)?.toString() ?: run { callback(null, "Missing key"); return }
+                val key = args.getOrNull(0)?.toString() ?: run {
+                    callback(null, "Missing key")
+                    return
+                }
                 p.edit().remove(key).apply()
                 callback(null, null)
             }

package/native/android/VueNativeCore/src/main/kotlin/com/vuenative/core/Modules/BackgroundTaskModule.kt

@@ -31,19 +31,28 @@ class BackgroundTaskModule : NativeModule {
     }
 
     override fun invoke(method: String, args: List<Any?>, bridge: NativeBridge, callback: (Any?, String?) -> Unit) {
-        val ctx = appContext ?: run { callback(null, "BackgroundTask not initialized"); return }
+        val ctx = appContext ?: run {
+            callback(null, "BackgroundTask not initialized")
+            return
+        }
 
         when (method) {
             "scheduleTask" -> {
                 val taskId = args.getOrNull(0)?.toString()
-                    ?: run { callback(null, "scheduleTask: missing taskId"); return }
+                    ?: run {
+                        callback(null, "scheduleTask: missing taskId")
+                        return
+                    }
                 val type = args.getOrNull(1)?.toString() ?: "refresh"
                 val options = args.getOrNull(2) as? Map<*, *> ?: emptyMap<String, Any>()
                 scheduleTask(ctx, taskId, type, options, callback)
             }
             "cancelTask" -> {
                 val taskId = args.getOrNull(0)?.toString()
-                    ?: run { callback(null, "cancelTask: missing taskId"); return }
+                    ?: run {
+                        callback(null, "cancelTask: missing taskId")
+                        return
+                    }
                 WorkManager.getInstance(ctx).cancelUniqueWork(taskId)
                 callback(null, null)
             }

package/native/android/VueNativeCore/src/main/kotlin/com/vuenative/core/Modules/BiometryModule.kt

@@ -27,12 +27,15 @@ class BiometryModule : NativeModule {
     ) {
         when (method) {
             "getSupportedBiometry" -> {
-                val ctx = context ?: run { callback("none", null); return }
+                val ctx = context ?: run {
+                    callback("none", null)
+                    return
+                }
                 val biometricManager = BiometricManager.from(ctx)
                 val result = when (biometricManager.canAuthenticate(
                     BiometricManager.Authenticators.BIOMETRIC_STRONG
                 )) {
-                    BiometricManager.BIOMETRIC_SUCCESS -> "faceID"   // Android doesn't distinguish
+                    BiometricManager.BIOMETRIC_SUCCESS -> "faceID" // Android doesn't distinguish
                     BiometricManager.BIOMETRIC_ERROR_NO_HARDWARE -> "none"
                     BiometricManager.BIOMETRIC_ERROR_HW_UNAVAILABLE -> "none"
                     BiometricManager.BIOMETRIC_ERROR_NONE_ENROLLED -> "biometric" // HW present, not enrolled

package/native/android/VueNativeCore/src/main/kotlin/com/vuenative/core/Modules/BluetoothModule.kt

@@ -52,39 +52,80 @@ class BluetoothModule : NativeModule {
             }
             "connect" -> {
                 val deviceId = args.getOrNull(0)?.toString() ?: run {
-                    callback(null, "Missing deviceId"); return
+                    callback(null, "Missing deviceId")
+                    return
                 }
                 connect(deviceId, callback)
             }
             "disconnect" -> {
                 val deviceId = args.getOrNull(0)?.toString() ?: run {
-                    callback(null, "Missing deviceId"); return
+                    callback(null, "Missing deviceId")
+                    return
                 }
                 disconnect(deviceId, callback)
             }
             "readCharacteristic" -> {
-                val deviceId = args.getOrNull(0)?.toString() ?: run { callback(null, "Missing deviceId"); return }
-                val serviceUUID = args.getOrNull(1)?.toString() ?: run { callback(null, "Missing serviceUUID"); return }
-                val charUUID = args.getOrNull(2)?.toString() ?: run { callback(null, "Missing charUUID"); return }
+                val deviceId = args.getOrNull(0)?.toString() ?: run {
+                    callback(null, "Missing deviceId")
+                    return
+                }
+                val serviceUUID = args.getOrNull(1)?.toString() ?: run {
+                    callback(null, "Missing serviceUUID")
+                    return
+                }
+                val charUUID = args.getOrNull(2)?.toString() ?: run {
+                    callback(null, "Missing charUUID")
+                    return
+                }
                 readCharacteristic(deviceId, serviceUUID, charUUID, callback)
             }
             "writeCharacteristic" -> {
-                val deviceId = args.getOrNull(0)?.toString() ?: run { callback(null, "Missing deviceId"); return }
-                val serviceUUID = args.getOrNull(1)?.toString() ?: run { callback(null, "Missing serviceUUID"); return }
-                val charUUID = args.getOrNull(2)?.toString() ?: run { callback(null, "Missing charUUID"); return }
-                val dataBase64 = args.getOrNull(3)?.toString() ?: run { callback(null, "Missing data"); return }
+                val deviceId = args.getOrNull(0)?.toString() ?: run {
+                    callback(null, "Missing deviceId")
+                    return
+                }
+                val serviceUUID = args.getOrNull(1)?.toString() ?: run {
+                    callback(null, "Missing serviceUUID")
+                    return
+                }
+                val charUUID = args.getOrNull(2)?.toString() ?: run {
+                    callback(null, "Missing charUUID")
+                    return
+                }
+                val dataBase64 = args.getOrNull(3)?.toString() ?: run {
+                    callback(null, "Missing data")
+                    return
+                }
                 writeCharacteristic(deviceId, serviceUUID, charUUID, dataBase64, callback)
             }
             "subscribeToCharacteristic" -> {
-                val deviceId = args.getOrNull(0)?.toString() ?: run { callback(null, "Missing deviceId"); return }
-                val serviceUUID = args.getOrNull(1)?.toString() ?: run { callback(null, "Missing serviceUUID"); return }
-                val charUUID = args.getOrNull(2)?.toString() ?: run { callback(null, "Missing charUUID"); return }
+                val deviceId = args.getOrNull(0)?.toString() ?: run {
+                    callback(null, "Missing deviceId")
+                    return
+                }
+                val serviceUUID = args.getOrNull(1)?.toString() ?: run {
+                    callback(null, "Missing serviceUUID")
+                    return
+                }
+                val charUUID = args.getOrNull(2)?.toString() ?: run {
+                    callback(null, "Missing charUUID")
+                    return
+                }
                 subscribeToCharacteristic(deviceId, serviceUUID, charUUID, callback)
             }
             "unsubscribeFromCharacteristic" -> {
-                val deviceId = args.getOrNull(0)?.toString() ?: run { callback(null, "Missing deviceId"); return }
-                val serviceUUID = args.getOrNull(1)?.toString() ?: run { callback(null, "Missing serviceUUID"); return }
-                val charUUID = args.getOrNull(2)?.toString() ?: run { callback(null, "Missing charUUID"); return }
+                val deviceId = args.getOrNull(0)?.toString() ?: run {
+                    callback(null, "Missing deviceId")
+                    return
+                }
+                val serviceUUID = args.getOrNull(1)?.toString() ?: run {
+                    callback(null, "Missing serviceUUID")
+                    return
+                }
+                val charUUID = args.getOrNull(2)?.toString() ?: run {
+                    callback(null, "Missing charUUID")
+                    return
+                }
                 unsubscribeFromCharacteristic(deviceId, serviceUUID, charUUID, callback)
             }
             "getState" -> {
@@ -151,8 +192,14 @@ class BluetoothModule : NativeModule {
 
     @Suppress("MissingPermission")
     private fun readCharacteristic(deviceId: String, serviceUUID: String, charUUID: String, callback: (Any?, String?) -> Unit) {
-        val gatt = gattConnections[deviceId] ?: run { callback(null, "Device not connected"); return }
-        val char = findCharacteristic(gatt, serviceUUID, charUUID) ?: run { callback(null, "Characteristic not found"); return }
+        val gatt = gattConnections[deviceId] ?: run {
+            callback(null, "Device not connected")
+            return
+        }
+        val char = findCharacteristic(gatt, serviceUUID, charUUID) ?: run {
+            callback(null, "Characteristic not found")
+            return
+        }
         val key = "$deviceId:$serviceUUID:$charUUID"
         readCallbacks[key] = callback
         gatt.readCharacteristic(char)
@@ -160,8 +207,14 @@ class BluetoothModule : NativeModule {
 
     @Suppress("MissingPermission")
     private fun writeCharacteristic(deviceId: String, serviceUUID: String, charUUID: String, dataBase64: String, callback: (Any?, String?) -> Unit) {
-        val gatt = gattConnections[deviceId] ?: run { callback(null, "Device not connected"); return }
-        val char = findCharacteristic(gatt, serviceUUID, charUUID) ?: run { callback(null, "Characteristic not found"); return }
+        val gatt = gattConnections[deviceId] ?: run {
+            callback(null, "Device not connected")
+            return
+        }
+        val char = findCharacteristic(gatt, serviceUUID, charUUID) ?: run {
+            callback(null, "Characteristic not found")
+            return
+        }
         val data = Base64.decode(dataBase64, Base64.DEFAULT)
         val key = "$deviceId:$serviceUUID:$charUUID"
         writeCallbacks[key] = callback
@@ -171,8 +224,14 @@ class BluetoothModule : NativeModule {
 
     @Suppress("MissingPermission")
     private fun subscribeToCharacteristic(deviceId: String, serviceUUID: String, charUUID: String, callback: (Any?, String?) -> Unit) {
-        val gatt = gattConnections[deviceId] ?: run { callback(null, "Device not connected"); return }
-        val char = findCharacteristic(gatt, serviceUUID, charUUID) ?: run { callback(null, "Characteristic not found"); return }
+        val gatt = gattConnections[deviceId] ?: run {
+            callback(null, "Device not connected")
+            return
+        }
+        val char = findCharacteristic(gatt, serviceUUID, charUUID) ?: run {
+            callback(null, "Characteristic not found")
+            return
+        }
         gatt.setCharacteristicNotification(char, true)
         val descriptor = char.getDescriptor(UUID.fromString("00002902-0000-1000-8000-00805f9b34fb"))
         descriptor?.let {
@@ -184,8 +243,14 @@ class BluetoothModule : NativeModule {
 
     @Suppress("MissingPermission")
     private fun unsubscribeFromCharacteristic(deviceId: String, serviceUUID: String, charUUID: String, callback: (Any?, String?) -> Unit) {
-        val gatt = gattConnections[deviceId] ?: run { callback(null, "Device not connected"); return }
-        val char = findCharacteristic(gatt, serviceUUID, charUUID) ?: run { callback(null, "Characteristic not found"); return }
+        val gatt = gattConnections[deviceId] ?: run {
+            callback(null, "Device not connected")
+            return
+        }
+        val char = findCharacteristic(gatt, serviceUUID, charUUID) ?: run {
+            callback(null, "Characteristic not found")
+            return
+        }
         gatt.setCharacteristicNotification(char, false)
         callback(null, null)
     }