@craft-native/android 0.0.72

package/templates/CraftBridgeExtensions.kt.template

@@ -0,0 +1,383 @@
+package {{PACKAGE_NAME}}
+
+import android.app.Activity
+import android.content.Context
+import androidx.compose.foundation.layout.*
+import androidx.compose.material3.*
+import androidx.compose.runtime.*
+import androidx.compose.ui.Modifier
+import androidx.work.*
+import com.google.android.material.color.DynamicColors
+import com.google.firebase.analytics.FirebaseAnalytics
+import com.google.firebase.crashlytics.FirebaseCrashlytics
+import com.google.firebase.messaging.FirebaseMessaging
+import com.google.firebase.remoteconfig.FirebaseRemoteConfig
+import java.util.concurrent.TimeUnit
+
+/// Android 13+ Advanced Features
+
+// MARK: - Jetpack Compose Integration
+
+@Composable
+fun CraftComposeApp(content: @Composable () -> Unit) {
+    MaterialTheme(
+        colorScheme = dynamicColorScheme(),
+        typography = Typography(),
+        content = content
+    )
+}
+
+@Composable
+fun dynamicColorScheme(): ColorScheme {
+    return if (DynamicColors.isDynamicColorAvailable()) {
+        dynamicDarkColorScheme()
+    } else {
+        darkColorScheme()
+    }
+}
+
+@Composable
+fun CraftWebViewComposable(
+    url: String,
+    modifier: Modifier = Modifier
+) {
+    AndroidView(
+        factory = { context ->
+            android.webkit.WebView(context).apply {
+                settings.javaScriptEnabled = true
+                loadUrl(url)
+            }
+        },
+        modifier = modifier.fillMaxSize()
+    )
+}
+
+// MARK: - Material You Dynamic Colors
+
+class DynamicColorManager(private val activity: Activity) {
+
+    fun applyDynamicColors() {
+        if (DynamicColors.isDynamicColorAvailable()) {
+            DynamicColors.applyToActivityIfAvailable(activity)
+        }
+    }
+
+    fun isDynamicColorAvailable(): Boolean {
+        return DynamicColors.isDynamicColorAvailable()
+    }
+}
+
+// MARK: - Predictive Back Gesture (Android 13+)
+
+class PredictiveBackHandler(private val activity: Activity) {
+
+    fun enablePredictiveBack() {
+        if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.TIRAMISU) {
+            activity.onBackPressedDispatcher.addCallback(activity, object : androidx.activity.OnBackPressedCallback(true) {
+                override fun handleOnBackPressed() {
+                    // Handle predictive back gesture
+                    // Can animate the exit transition
+                    isEnabled = false
+                    activity.onBackPressedDispatcher.onBackPressed()
+                }
+            })
+        }
+    }
+}
+
+// MARK: - Per-App Language Preferences (Android 13+)
+
+class LanguageManager(private val context: Context) {
+
+    fun setAppLanguage(languageCode: String) {
+        if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.TIRAMISU) {
+            val localeList = android.os.LocaleList(java.util.Locale.forLanguageTag(languageCode))
+            context.getSystemService(android.app.LocaleManager::class.java)
+                ?.applicationLocales = localeList
+        }
+    }
+
+    fun getAppLanguage(): String? {
+        if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.TIRAMISU) {
+            val locales = context.getSystemService(android.app.LocaleManager::class.java)
+                ?.applicationLocales
+            return locales?.get(0)?.toLanguageTag()
+        }
+        return null
+    }
+}
+
+// MARK: - Photo Picker (Android 13+)
+
+class PhotoPickerManager(private val activity: Activity) {
+
+    fun launchPhotoPicker(maxItems: Int = 1, callback: (List<android.net.Uri>) -> Unit) {
+        if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.TIRAMISU) {
+            val intent = android.content.Intent(android.provider.MediaStore.ACTION_PICK_IMAGES).apply {
+                putExtra(android.provider.MediaStore.EXTRA_PICK_IMAGES_MAX, maxItems)
+            }
+            // Launch intent and handle result
+        }
+    }
+}
+
+// MARK: - Notification Permission (Android 13+)
+
+class NotificationPermissionManager(private val activity: Activity) {
+
+    fun requestNotificationPermission(callback: (Boolean) -> Unit) {
+        if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.TIRAMISU) {
+            if (androidx.core.app.ActivityCompat.checkSelfPermission(
+                    activity,
+                    android.Manifest.permission.POST_NOTIFICATIONS
+                ) != android.content.pm.PackageManager.PERMISSION_GRANTED
+            ) {
+                androidx.core.app.ActivityCompat.requestPermissions(
+                    activity,
+                    arrayOf(android.Manifest.permission.POST_NOTIFICATIONS),
+                    100
+                )
+            } else {
+                callback(true)
+            }
+        } else {
+            callback(true)
+        }
+    }
+
+    fun hasNotificationPermission(): Boolean {
+        if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.TIRAMISU) {
+            return androidx.core.app.ActivityCompat.checkSelfPermission(
+                activity,
+                android.Manifest.permission.POST_NOTIFICATIONS
+            ) == android.content.pm.PackageManager.PERMISSION_GRANTED
+        }
+        return true
+    }
+}
+
+// MARK: - Foreground Services
+
+class ForegroundServiceManager(private val context: Context) {
+
+    fun startForegroundService(
+        serviceClass: Class<*>,
+        notificationTitle: String,
+        notificationText: String
+    ) {
+        val intent = android.content.Intent(context, serviceClass)
+        if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.O) {
+            context.startForegroundService(intent)
+        } else {
+            context.startService(intent)
+        }
+    }
+
+    fun stopForegroundService(serviceClass: Class<*>) {
+        val intent = android.content.Intent(context, serviceClass)
+        context.stopService(intent)
+    }
+}
+
+// MARK: - WorkManager for Background Tasks
+
+class BackgroundTaskManager(private val context: Context) {
+
+    fun scheduleOneTimeWork(
+        tag: String,
+        initialDelay: Long = 0,
+        requiresCharging: Boolean = false,
+        requiresWifi: Boolean = false
+    ) {
+        val constraints = Constraints.Builder()
+            .setRequiresCharging(requiresCharging)
+            .setRequiredNetworkType(if (requiresWifi) NetworkType.UNMETERED else NetworkType.CONNECTED)
+            .build()
+
+        val workRequest = OneTimeWorkRequestBuilder<CraftWorker>()
+            .setConstraints(constraints)
+            .setInitialDelay(initialDelay, TimeUnit.MILLISECONDS)
+            .addTag(tag)
+            .build()
+
+        WorkManager.getInstance(context).enqueue(workRequest)
+    }
+
+    fun schedulePeriodicWork(
+        tag: String,
+        intervalMinutes: Long,
+        requiresCharging: Boolean = false
+    ) {
+        val constraints = Constraints.Builder()
+            .setRequiresCharging(requiresCharging)
+            .build()
+
+        val workRequest = PeriodicWorkRequestBuilder<CraftWorker>(
+            intervalMinutes, TimeUnit.MINUTES
+        )
+            .setConstraints(constraints)
+            .addTag(tag)
+            .build()
+
+        WorkManager.getInstance(context).enqueue(workRequest)
+    }
+
+    fun cancelWork(tag: String) {
+        WorkManager.getInstance(context).cancelAllWorkByTag(tag)
+    }
+
+    class CraftWorker(context: Context, params: WorkerParameters) : Worker(context, params) {
+        override fun doWork(): Result {
+            // Perform background task
+            return Result.success()
+        }
+    }
+}
+
+// MARK: - Firebase Integration
+
+class FirebaseManager(private val context: Context) {
+
+    private val analytics: FirebaseAnalytics by lazy {
+        FirebaseAnalytics.getInstance(context)
+    }
+
+    private val crashlytics: FirebaseCrashlytics by lazy {
+        FirebaseCrashlytics.getInstance()
+    }
+
+    private val remoteConfig: FirebaseRemoteConfig by lazy {
+        FirebaseRemoteConfig.getInstance()
+    }
+
+    // Analytics
+    fun logEvent(eventName: String, params: Map<String, Any>) {
+        val bundle = android.os.Bundle().apply {
+            params.forEach { (key, value) ->
+                when (value) {
+                    is String -> putString(key, value)
+                    is Int -> putInt(key, value)
+                    is Long -> putLong(key, value)
+                    is Double -> putDouble(key, value)
+                    is Boolean -> putBoolean(key, value)
+                }
+            }
+        }
+        analytics.logEvent(eventName, bundle)
+    }
+
+    fun setUserProperty(name: String, value: String) {
+        analytics.setUserProperty(name, value)
+    }
+
+    // Crashlytics
+    fun logCrash(message: String) {
+        crashlytics.log(message)
+    }
+
+    fun recordException(throwable: Throwable) {
+        crashlytics.recordException(throwable)
+    }
+
+    fun setUserId(userId: String) {
+        crashlytics.setUserId(userId)
+    }
+
+    // Remote Config
+    fun fetchRemoteConfig(callback: (Boolean) -> Unit) {
+        remoteConfig.fetchAndActivate()
+            .addOnCompleteListener { task ->
+                callback(task.isSuccessful)
+            }
+    }
+
+    fun getString(key: String): String {
+        return remoteConfig.getString(key)
+    }
+
+    fun getBoolean(key: String): Boolean {
+        return remoteConfig.getBoolean(key)
+    }
+
+    fun getLong(key: String): Long {
+        return remoteConfig.getLong(key)
+    }
+
+    // FCM
+    fun getFirebaseToken(callback: (String?) -> Unit) {
+        FirebaseMessaging.getInstance().token
+            .addOnCompleteListener { task ->
+                if (task.isSuccessful) {
+                    callback(task.result)
+                } else {
+                    callback(null)
+                }
+            }
+    }
+
+    fun subscribeToTopic(topic: String) {
+        FirebaseMessaging.getInstance().subscribeToTopic(topic)
+    }
+
+    fun unsubscribeFromTopic(topic: String) {
+        FirebaseMessaging.getInstance().unsubscribeFromTopic(topic)
+    }
+}
+
+// MARK: - Bottom Sheet
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun CraftBottomSheet(
+    sheetContent: @Composable ColumnScope.() -> Unit,
+    content: @Composable () -> Unit
+) {
+    val sheetState = rememberModalBottomSheetState()
+    var showBottomSheet by remember { mutableStateOf(false) }
+
+    if (showBottomSheet) {
+        ModalBottomSheet(
+            onDismissRequest = { showBottomSheet = false },
+            sheetState = sheetState
+        ) {
+            sheetContent()
+        }
+    }
+
+    content()
+}
+
+// MARK: - Navigation Drawer
+
+@Composable
+fun CraftNavigationDrawer(
+    drawerContent: @Composable ColumnScope.() -> Unit,
+    content: @Composable () -> Unit
+) {
+    val drawerState = rememberDrawerState(DrawerValue.Closed)
+    val scope = rememberCoroutineScope()
+
+    ModalNavigationDrawer(
+        drawerState = drawerState,
+        drawerContent = {
+            ModalDrawerSheet {
+                drawerContent()
+            }
+        }
+    ) {
+        content()
+    }
+}
+
+// MARK: - Bridge Integration
+
+fun CraftBridge.initializeAdvancedFeatures() {
+    // Initialize all advanced Android features
+    DynamicColorManager(activity).applyDynamicColors()
+    PredictiveBackHandler(activity).enablePredictiveBack()
+}
+
+fun CraftBridge.setupFirebase() {
+    // Setup Firebase services
+    // Called from MainActivity onCreate
+}

package/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/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)
+        }
+    }
+}