craft-native 0.0.55 → 0.0.72

package/dist/android/templates/CraftBridge.kt.template

@@ -49,6 +49,7 @@ import com.google.android.gms.location.LocationResult
 import com.google.android.gms.location.LocationServices
 import com.google.android.gms.location.Priority
 import com.google.android.play.core.review.ReviewManagerFactory
+{{FIREBASE_IMPORT}}
 import android.content.ContentResolver
 import android.content.ContentUris
 import android.content.ContentValues
@@ -95,10 +96,12 @@ import android.graphics.BitmapFactory
 import java.io.ByteArrayOutputStream
 import java.io.File
 import java.util.concurrent.TimeUnit
+import java.util.UUID
 
 class CraftBridge(
     private val activity: Activity,
-    private val webView: WebView
+    private val webView: WebView,
+    private val healthConnect: CraftHealthConnect
 ) {
     private var speechRecognizer: SpeechRecognizer? = null
     private var isListening = false
@@ -167,42 +170,43 @@ class CraftBridge(
             window.craft = {
                 platform: 'android',
                 capabilities: {
-                    haptics: true,
-                    speechRecognition: ${SpeechRecognizer.isRecognitionAvailable(activity)},
-                    share: true,
-                    camera: true,
-                    biometric: ${isBiometricAvailable()},
-                    pushNotifications: true,
-                    secureStorage: true,
-                    geolocation: true,
-                    clipboard: true,
+                    haptics: {{ENABLE_HAPTICS}},
+                    speechRecognition: {{ENABLE_SPEECH}} && ${SpeechRecognizer.isRecognitionAvailable(activity)},
+                    share: {{ENABLE_SHARE}},
+                    camera: {{ENABLE_CAMERA}},
+                    biometric: {{ENABLE_BIOMETRIC}} && ${isBiometricAvailable()},
+                    pushNotifications: {{ENABLE_PUSH}},
+                    secureStorage: {{ENABLE_SECURE_STORAGE}},
+                    geolocation: {{ENABLE_GEOLOCATION}},
+                    backgroundLocation: {{ENABLE_BACKGROUND_LOCATION}},
+                    clipboard: false,
                     deviceInfo: true,
-                    appBadge: true,
+                    appBadge: {{ENABLE_PUSH}},
                     networkStatus: true,
                     appReview: true,
-                    flashlight: ${hasFlashlight()},
+                    flashlight: {{ENABLE_CAMERA}} && ${hasFlashlight()},
                     openURL: true,
                     vibrationPattern: true,
                     appState: true,
-                    contacts: true,
-                    calendar: true,
-                    localNotifications: true,
-                    inAppPurchase: true,
-                    keepAwake: true,
-                    orientationLock: true,
-                    deepLinks: true,
-                    qrScanner: true,
-                    filePicker: true,
-                    fileDownload: true,
-                    googleSignIn: true,
-                    audioRecording: true,
-                    videoRecording: true,
-                    motionSensors: true,
-                    localDatabase: true,
-                    bluetooth: true,
-                    nfc: ${NfcAdapter.getDefaultAdapter(activity) != null},
-                    fitness: true,
-                    screenCapture: true
+                    contacts: false,
+                    calendar: false,
+                    localNotifications: {{ENABLE_PUSH}},
+                    inAppPurchase: false,
+                    keepAwake: {{ENABLE_KEEP_AWAKE}},
+                    orientationLock: false,
+                    deepLinks: {{ENABLE_DEEP_LINKS}},
+                    qrScanner: false,
+                    filePicker: false,
+                    fileDownload: false,
+                    googleSignIn: false,
+                    audioRecording: false,
+                    videoRecording: false,
+                    motionSensors: false,
+                    localDatabase: false,
+                    bluetooth: false,
+                    nfc: false,
+                    health: {{ENABLE_HEALTH_CONNECT}},
+                    screenCapture: false
                 },
 
                 // Haptic feedback
@@ -595,7 +599,7 @@ class CraftBridge(
                 },
 
                 // Fitness / Health
-                fitness: {
+                health: {
                     requestAuthorization: function(types) {
                         return new Promise(function(resolve, reject) {
                             window._craftFitnessAuthResolve = resolve;
@@ -603,11 +607,19 @@ class CraftBridge(
                             CraftAndroid.requestFitnessAuthorization(JSON.stringify(types || []));
                         });
                     },
-                    getData: function(type, startDate, endDate) {
+                    getData: function(type, options) {
+                        options = options || {};
                         return new Promise(function(resolve, reject) {
                             window._craftFitnessDataResolve = resolve;
                             window._craftFitnessDataReject = reject;
-                            CraftAndroid.getFitnessData(type, startDate || 0, endDate || 0);
+                            CraftAndroid.getFitnessData(type, options.startDate || 0, options.endDate || 0);
+                        });
+                    },
+                    saveWorkout: function(workout) {
+                        return new Promise(function(resolve, reject) {
+                            window._craftFitnessSaveResolve = resolve;
+                            window._craftFitnessSaveReject = reject;
+                            CraftAndroid.saveHealthWorkout(JSON.stringify(workout || {}));
                         });
                     }
                 },
@@ -1202,6 +1214,73 @@ class CraftBridge(
                 }
             };
 
+            (function installCraftMobileContract(craft) {
+                var legacyShare = craft.share.bind(craft);
+                var legacyOpenCamera = craft.openCamera.bind(craft);
+                var legacyPickImage = craft.pickImage.bind(craft);
+                var legacyAuthenticate = craft.authenticate.bind(craft);
+                var legacySecureStore = craft.secureStore;
+                craft.contractVersion = '1.0.0';
+                craft.device = {
+                    getInfo: function() { return Promise.resolve(craft.getDeviceInfo()); },
+                    getCapabilities: function() { return Promise.resolve(Object.assign({}, craft.capabilities)); }
+                };
+                craft.haptics = {
+                    impact: function(style) { craft.haptic(style || 'medium'); return Promise.resolve(); },
+                    notification: function(type) { craft.haptic(type === 'error' ? 'heavy' : 'light'); return Promise.resolve(); },
+                    selection: function() { craft.haptic('selection'); return Promise.resolve(); },
+                    vibrate: function(pattern) { craft.vibrate(pattern || []); return Promise.resolve(); }
+                };
+                craft.camera = {
+                    takePicture: function() { return legacyOpenCamera().then(normalizePhoto); },
+                    pickImage: function() { return legacyPickImage().then(normalizePhoto); },
+                    pickMultiple: function() { return legacyPickImage().then(function(photo) { return [normalizePhoto(photo)]; }); },
+                    isAvailable: function() { return Promise.resolve(!!craft.capabilities.camera); }
+                };
+                craft.biometrics = {
+                    isAvailable: function() { return Promise.resolve(!!craft.capabilities.biometric); },
+                    getBiometricType: function() { return Promise.resolve(craft.capabilities.biometric ? 'fingerprint' : null); },
+                    authenticate: function(reason) { return legacyAuthenticate(reason); }
+                };
+                craft.secureStorage = {
+                    set: function(key, value) { return Promise.resolve(legacySecureStore.set(key, value)).then(function() {}); },
+                    get: function(key) { return Promise.resolve(legacySecureStore.get(key)); },
+                    delete: function(key) { return Promise.resolve(legacySecureStore.remove(key)).then(function() {}); },
+                    clear: function() { return Promise.resolve(CraftAndroid.secureClear()).then(function() {}); }
+                };
+                craft.location = {
+                    getCurrentPosition: craft.getCurrentPosition,
+                    watchPosition: craft.watchPosition,
+                    clearWatch: craft.clearWatch,
+                    startRecording: function(options) { return Promise.resolve(JSON.parse(CraftAndroid.startLocationRecording(JSON.stringify(options || {})))); },
+                    pauseRecording: function() { return Promise.resolve(JSON.parse(CraftAndroid.pauseLocationRecording())); },
+                    resumeRecording: function() { return Promise.resolve(JSON.parse(CraftAndroid.resumeLocationRecording())); },
+                    stopRecording: function() { return Promise.resolve(JSON.parse(CraftAndroid.stopLocationRecording())); },
+                    getRecordingState: function() { return Promise.resolve(JSON.parse(CraftAndroid.getLocationRecordingState())); },
+                    readRecording: function() { return Promise.resolve(JSON.parse(CraftAndroid.readLocationRecording())); }
+                };
+                var shareApi = function(text, title) { return legacyShare(text, title); };
+                shareApi.share = function(options) {
+                    options = options || {};
+                    return Promise.resolve(legacyShare([options.text, options.url].filter(Boolean).join(' '), options.title || ''));
+                };
+                craft.share = shareApi;
+                craft.lifecycle = {
+                    getState: function() { return document.visibilityState === 'visible' ? 'active' : 'background'; },
+                    onStateChange: function(callback) {
+                        var handler = function() { callback(document.visibilityState === 'visible' ? 'active' : 'background'); };
+                        document.addEventListener('visibilitychange', handler);
+                        return function() { document.removeEventListener('visibilitychange', handler); };
+                    }
+                };
+                function normalizePhoto(photo) {
+                    if (photo && typeof photo === 'object') return photo;
+                    var value = String(photo || '');
+                    var base64 = value.indexOf(',') >= 0 ? value.split(',').pop() : value;
+                    return {base64: base64, uri: value, width: 0, height: 0, mimeType: 'image/jpeg'};
+                }
+            })(window.craft);
+
             // Dispatch ready event
             window.dispatchEvent(new CustomEvent('craftReady', {detail: window.craft}));
             console.log('Craft Android bridge initialized');
@@ -1455,24 +1534,7 @@ class CraftBridge(
 
     @JavascriptInterface
     fun registerPush() {
-        // This would integrate with Firebase Cloud Messaging
-        // For now, return a placeholder token
-        activity.runOnUiThread {
-            // In a real implementation, you would use Firebase:
-            // FirebaseMessaging.getInstance().token.addOnCompleteListener { task ->
-            //     if (task.isSuccessful) {
-            //         val token = task.result
-            //         webView.evaluateJavascript("window._craftPushResolve('$token')", null)
-            //     } else {
-            //         webView.evaluateJavascript("window._craftPushReject('Failed to get token')", null)
-            //     }
-            // }
-
-            webView.evaluateJavascript(
-                "window._craftPushResolve && window._craftPushResolve('push-token-placeholder')",
-                null
-            )
-        }
+        {{REGISTER_PUSH_IMPLEMENTATION}}
     }
 
     // ==================== Secure Storage ====================
@@ -1506,6 +1568,16 @@ class CraftBridge(
         }
     }
 
+    @JavascriptInterface
+    fun secureClear(): Boolean {
+        return try {
+            securePrefs.edit().clear().apply()
+            true
+        } catch (e: Exception) {
+            false
+        }
+    }
+
     // ==================== Logging ====================
 
     @JavascriptInterface
@@ -1654,6 +1726,58 @@ class CraftBridge(
         locationCallback = null
     }
 
+    @JavascriptInterface
+    fun startLocationRecording(optionsJson: String): String {
+        if (ContextCompat.checkSelfPermission(activity, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
+            return JSONObject().apply {
+                put("id", JSONObject.NULL)
+                put("active", false)
+                put("paused", false)
+                put("startedAt", JSONObject.NULL)
+                put("sampleCount", 0)
+            }.toString()
+        }
+        val id = UUID.randomUUID().toString()
+        CraftLocationRecordingStore.start(activity, id, System.currentTimeMillis())
+        ContextCompat.startForegroundService(
+            activity,
+            Intent(activity, LocationRecordingService::class.java).setAction(LocationRecordingService.ACTION_START)
+        )
+        return CraftLocationRecordingStore.state(activity).toString()
+    }
+
+    @JavascriptInterface
+    fun pauseLocationRecording(): String {
+        CraftLocationRecordingStore.setPaused(activity, true)
+        return CraftLocationRecordingStore.state(activity).toString()
+    }
+
+    @JavascriptInterface
+    fun resumeLocationRecording(): String {
+        CraftLocationRecordingStore.setPaused(activity, false)
+        if (CraftLocationRecordingStore.isActive(activity)) {
+            ContextCompat.startForegroundService(
+                activity,
+                Intent(activity, LocationRecordingService::class.java).setAction(LocationRecordingService.ACTION_START)
+            )
+        }
+        return CraftLocationRecordingStore.state(activity).toString()
+    }
+
+    @JavascriptInterface
+    fun stopLocationRecording(): String {
+        CraftLocationRecordingStore.stop(activity)
+        val result = CraftLocationRecordingStore.state(activity, includeLocations = true).toString()
+        activity.stopService(Intent(activity, LocationRecordingService::class.java).setAction(LocationRecordingService.ACTION_STOP))
+        return result
+    }
+
+    @JavascriptInterface
+    fun getLocationRecordingState(): String = CraftLocationRecordingStore.state(activity).toString()
+
+    @JavascriptInterface
+    fun readLocationRecording(): String = CraftLocationRecordingStore.locations(activity).toString()
+
     // ==================== Clipboard ====================
 
     @JavascriptInterface
@@ -1824,8 +1948,9 @@ class CraftBridge(
                 }
             } else {
                 activity.runOnUiThread {
+                    val message = JSONObject.quote(task.exception?.message ?: "Review flow failed")
                     webView.evaluateJavascript(
-                        "window._craftReviewReject && window._craftReviewReject('${task.exception?.message ?: \"Review flow failed\"}')",
+                        "window._craftReviewReject && window._craftReviewReject($message)",
                         null
                     )
                 }
@@ -2769,17 +2894,24 @@ class CraftBridge(
 
     @JavascriptInterface
     fun requestFitnessAuthorization(typesJson: String) {
-        // Google Fit requires configuration
-        activity.runOnUiThread {
-            webView.evaluateJavascript("window._craftFitnessAuthReject && window._craftFitnessAuthReject('Fitness requires Google Fit configuration')", null)
-        }
+        healthConnect.requestAuthorization(typesJson)
     }
 
     @JavascriptInterface
     fun getFitnessData(type: String, startDate: Long, endDate: Long) {
-        activity.runOnUiThread {
-            webView.evaluateJavascript("window._craftFitnessDataReject && window._craftFitnessDataReject('Fitness requires Google Fit configuration')", null)
-        }
+        healthConnect.getData(type, startDate, endDate)
+    }
+
+    @JavascriptInterface
+    fun saveHealthWorkout(workoutJson: String) {
+        healthConnect.saveWorkout(workoutJson)
+    }
+
+    fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?): Boolean =
+        healthConnect.onActivityResult(requestCode, resultCode, data)
+
+    fun close() {
+        healthConnect.close()
     }
 
     // ==================== Screen Capture ====================

package/dist/android/templates/CraftHealthConnect.kt.template

@@ -0,0 +1,200 @@
+package {{PACKAGE_NAME}}
+
+import android.app.Activity
+import android.content.Intent
+import android.webkit.WebView
+import androidx.health.connect.client.HealthConnectClient
+import androidx.health.connect.client.PermissionController
+import androidx.health.connect.client.permission.HealthPermission
+import androidx.health.connect.client.records.ActiveCaloriesBurnedRecord
+import androidx.health.connect.client.records.DistanceRecord
+import androidx.health.connect.client.records.ExerciseSessionRecord
+import androidx.health.connect.client.records.HeartRateRecord
+import androidx.health.connect.client.records.StepsRecord
+import androidx.health.connect.client.records.metadata.Metadata
+import androidx.health.connect.client.request.AggregateRequest
+import androidx.health.connect.client.time.TimeRangeFilter
+import androidx.health.connect.client.units.Energy
+import androidx.health.connect.client.units.Length
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.launch
+import org.json.JSONArray
+import org.json.JSONObject
+import java.time.Instant
+import java.time.ZoneId
+
+class CraftHealthConnect(
+    private val activity: Activity,
+    private val webView: WebView
+) {
+    companion object {
+        private const val PERMISSION_REQUEST_CODE = 8407
+    }
+
+    private val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
+    private val permissionContract = PermissionController.createRequestPermissionResultContract()
+    private var pendingPermissions: Set<String> = emptySet()
+
+    private val client: HealthConnectClient?
+        get() = if (HealthConnectClient.getSdkStatus(activity) == HealthConnectClient.SDK_AVAILABLE) {
+            HealthConnectClient.getOrCreate(activity)
+        } else {
+            null
+        }
+
+    fun requestAuthorization(typesJson: String) {
+        val requested = permissionsFor(JSONArray(typesJson))
+        val healthClient = client ?: return reject("_craftFitnessAuthReject", "Health Connect is unavailable or requires an update")
+        scope.launch {
+            try {
+                val granted = healthClient.permissionController.getGrantedPermissions()
+                if (granted.containsAll(requested)) {
+                    resolve("_craftFitnessAuthResolve", "true")
+                } else {
+                    pendingPermissions = requested
+                    activity.runOnUiThread {
+                        val intent = permissionContract.createIntent(activity, requested)
+                        activity.startActivityForResult(intent, PERMISSION_REQUEST_CODE)
+                    }
+                }
+            } catch (error: Exception) {
+                reject("_craftFitnessAuthReject", error.message ?: "Health permissions could not be requested")
+            }
+        }
+    }
+
+    fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?): Boolean {
+        if (requestCode != PERMISSION_REQUEST_CODE) return false
+        val granted = permissionContract.parseResult(resultCode, data)
+        resolve("_craftFitnessAuthResolve", if (granted.containsAll(pendingPermissions)) "true" else "false")
+        pendingPermissions = emptySet()
+        return true
+    }
+
+    fun getData(type: String, startDate: Long, endDate: Long) {
+        val healthClient = client ?: return reject("_craftFitnessDataReject", "Health Connect is unavailable or requires an update")
+        val end = if (endDate > 0) Instant.ofEpochMilli(endDate) else Instant.now()
+        val start = if (startDate > 0) Instant.ofEpochMilli(startDate) else end.minusSeconds(7 * 24 * 60 * 60)
+        scope.launch {
+            try {
+                val (unit, value) = when (type) {
+                    "steps" -> {
+                        val metric = StepsRecord.COUNT_TOTAL
+                        val result = healthClient.aggregate(AggregateRequest(setOf(metric), TimeRangeFilter.between(start, end)))
+                        Pair("count", (result[metric] ?: 0L).toDouble())
+                    }
+                    "heartRate" -> {
+                        val metric = HeartRateRecord.BPM_AVG
+                        val result = healthClient.aggregate(AggregateRequest(setOf(metric), TimeRangeFilter.between(start, end)))
+                        Pair("count/min", (result[metric] ?: 0L).toDouble())
+                    }
+                    "activeEnergy" -> {
+                        val metric = ActiveCaloriesBurnedRecord.ACTIVE_CALORIES_TOTAL
+                        val result = healthClient.aggregate(AggregateRequest(setOf(metric), TimeRangeFilter.between(start, end)))
+                        Pair("kcal", (result[metric] ?: Energy.kilocalories(0.0)).inKilocalories)
+                    }
+                    "distance" -> {
+                        val metric = DistanceRecord.DISTANCE_TOTAL
+                        val result = healthClient.aggregate(AggregateRequest(setOf(metric), TimeRangeFilter.between(start, end)))
+                        Pair("m", (result[metric] ?: Length.meters(0.0)).inMeters)
+                    }
+                    else -> throw IllegalArgumentException("Unsupported Health Connect data type")
+                }
+                val payload = JSONObject().put("value", value).put("unit", unit).toString()
+                resolve("_craftFitnessDataResolve", payload)
+            } catch (error: Exception) {
+                reject("_craftFitnessDataReject", error.message ?: "Health data could not be read")
+            }
+        }
+    }
+
+    fun saveWorkout(workoutJson: String) {
+        val healthClient = client ?: return reject("_craftFitnessSaveReject", "Health Connect is unavailable or requires an update")
+        scope.launch {
+            try {
+                val data = JSONObject(workoutJson)
+                val activityId = data.getString("activityId")
+                val start = Instant.ofEpochMilli(data.getLong("startDate"))
+                val end = Instant.ofEpochMilli(data.getLong("endDate"))
+                require(end.isAfter(start)) { "Workout endDate must be after startDate" }
+                val zone = ZoneId.systemDefault().rules.getOffset(start)
+                val exerciseType = when (data.getString("type")) {
+                    "running" -> ExerciseSessionRecord.EXERCISE_TYPE_RUNNING
+                    "walking" -> ExerciseSessionRecord.EXERCISE_TYPE_WALKING
+                    "hiking" -> ExerciseSessionRecord.EXERCISE_TYPE_HIKING
+                    "cycling" -> ExerciseSessionRecord.EXERCISE_TYPE_BIKING
+                    else -> throw IllegalArgumentException("Unsupported workout type")
+                }
+                val records = mutableListOf<androidx.health.connect.client.records.Record>()
+                records.add(ExerciseSessionRecord(
+                    startTime = start,
+                    startZoneOffset = zone,
+                    endTime = end,
+                    endZoneOffset = zone,
+                    exerciseType = exerciseType,
+                    title = "WildLoop",
+                    metadata = Metadata.manualEntry(clientRecordId = activityId)
+                ))
+                val distance = data.optDouble("distanceMeters", 0.0)
+                if (distance > 0) records.add(DistanceRecord(
+                    startTime = start,
+                    startZoneOffset = zone,
+                    endTime = end,
+                    endZoneOffset = zone,
+                    distance = Length.meters(distance),
+                    metadata = Metadata.manualEntry(clientRecordId = "$activityId-distance")
+                ))
+                val calories = data.optDouble("activeEnergyCalories", 0.0)
+                if (calories > 0) records.add(ActiveCaloriesBurnedRecord(
+                    startTime = start,
+                    startZoneOffset = zone,
+                    endTime = end,
+                    endZoneOffset = zone,
+                    energy = Energy.kilocalories(calories),
+                    metadata = Metadata.manualEntry(clientRecordId = "$activityId-energy")
+                ))
+                val result = healthClient.insertRecords(records)
+                val payload = JSONObject().put("id", result.recordIdsList.firstOrNull() ?: activityId).toString()
+                resolve("_craftFitnessSaveResolve", payload)
+            } catch (error: Exception) {
+                reject("_craftFitnessSaveReject", error.message ?: "Workout could not be saved")
+            }
+        }
+    }
+
+    fun close() {
+        scope.cancel()
+    }
+
+    private fun permissionsFor(types: JSONArray): Set<String> {
+        val permissions = mutableSetOf<String>()
+        for (index in 0 until types.length()) {
+            when (types.optString(index)) {
+                "steps" -> permissions.add(HealthPermission.getReadPermission(StepsRecord::class))
+                "heartRate" -> permissions.add(HealthPermission.getReadPermission(HeartRateRecord::class))
+                "activeEnergy" -> permissions.add(HealthPermission.getReadPermission(ActiveCaloriesBurnedRecord::class))
+                "distance" -> permissions.add(HealthPermission.getReadPermission(DistanceRecord::class))
+                "workouts" -> {
+                    permissions.add(HealthPermission.getReadPermission(ExerciseSessionRecord::class))
+                    permissions.add(HealthPermission.getWritePermission(ExerciseSessionRecord::class))
+                    permissions.add(HealthPermission.getWritePermission(ActiveCaloriesBurnedRecord::class))
+                    permissions.add(HealthPermission.getWritePermission(DistanceRecord::class))
+                }
+            }
+        }
+        return permissions
+    }
+
+    private fun resolve(callback: String, json: String) {
+        activity.runOnUiThread {
+            webView.evaluateJavascript("window.$callback && window.$callback($json)", null)
+        }
+    }
+
+    private fun reject(callback: String, message: String) {
+        resolve(callback, JSONObject.quote(message))
+    }
+}

package/dist/android/templates/CraftHealthConnectStub.kt.template

@@ -0,0 +1,28 @@
+package {{PACKAGE_NAME}}
+
+import android.app.Activity
+import android.content.Intent
+import android.webkit.WebView
+import org.json.JSONObject
+
+class CraftHealthConnect(
+    private val activity: Activity,
+    private val webView: WebView
+) {
+    fun requestAuthorization(typesJson: String) = reject("_craftFitnessAuthReject")
+
+    fun getData(type: String, startDate: Long, endDate: Long) = reject("_craftFitnessDataReject")
+
+    fun saveWorkout(workoutJson: String) = reject("_craftFitnessSaveReject")
+
+    fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?): Boolean = false
+
+    fun close() = Unit
+
+    private fun reject(callback: String) {
+        activity.runOnUiThread {
+            val reason = JSONObject.quote("Health Connect is disabled")
+            webView.evaluateJavascript("window.$callback && window.$callback($reason)", null)
+        }
+    }
+}