@craft-native/android 0.0.72

package/templates/CraftWidgetProvider.kt.template

@@ -0,0 +1,246 @@
+package {{PACKAGE_NAME}}
+
+import android.app.PendingIntent
+import android.appwidget.AppWidgetManager
+import android.appwidget.AppWidgetProvider
+import android.content.BroadcastReceiver
+import android.content.ComponentName
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.os.Build
+import android.widget.RemoteViews
+
+/**
+ * Craft Widget Provider
+ *
+ * A customizable home screen widget that displays data from your Craft app.
+ * The widget can show title, subtitle, value, and an icon.
+ *
+ * To use widgets:
+ * 1. Add this provider to your AndroidManifest.xml
+ * 2. Create widget layout in res/layout/craft_widget.xml
+ * 3. Create widget info in res/xml/craft_widget_info.xml
+ * 4. Call window.craft.widget.update() from your web app
+ */
+class CraftWidgetProvider : AppWidgetProvider() {
+
+    companion object {
+        const val ACTION_WIDGET_UPDATE = "{{PACKAGE_NAME}}.WIDGET_UPDATE"
+        const val PREFS_NAME = "craft_widget_prefs"
+        const val PREF_TITLE = "widget_title"
+        const val PREF_SUBTITLE = "widget_subtitle"
+        const val PREF_VALUE = "widget_value"
+        const val PREF_ICON = "widget_icon"
+
+        /**
+         * Update all widgets programmatically
+         */
+        fun updateAllWidgets(context: Context) {
+            val intent = Intent(context, CraftWidgetProvider::class.java).apply {
+                action = AppWidgetManager.ACTION_APPWIDGET_UPDATE
+                val appWidgetManager = AppWidgetManager.getInstance(context)
+                val widgetComponent = ComponentName(context, CraftWidgetProvider::class.java)
+                val appWidgetIds = appWidgetManager.getAppWidgetIds(widgetComponent)
+                putExtra(AppWidgetManager.EXTRA_APPWIDGET_IDS, appWidgetIds)
+            }
+            context.sendBroadcast(intent)
+        }
+    }
+
+    override fun onUpdate(
+        context: Context,
+        appWidgetManager: AppWidgetManager,
+        appWidgetIds: IntArray
+    ) {
+        // Update each widget instance
+        for (appWidgetId in appWidgetIds) {
+            updateAppWidget(context, appWidgetManager, appWidgetId)
+        }
+    }
+
+    override fun onReceive(context: Context, intent: Intent) {
+        super.onReceive(context, intent)
+
+        // Handle custom update action from the app
+        if (intent.action == ACTION_WIDGET_UPDATE) {
+            val appWidgetManager = AppWidgetManager.getInstance(context)
+            val widgetComponent = ComponentName(context, CraftWidgetProvider::class.java)
+            val appWidgetIds = appWidgetManager.getAppWidgetIds(widgetComponent)
+
+            for (appWidgetId in appWidgetIds) {
+                updateAppWidget(context, appWidgetManager, appWidgetId)
+            }
+        }
+    }
+
+    override fun onEnabled(context: Context) {
+        // Register broadcast receiver for widget updates
+        val filter = IntentFilter(ACTION_WIDGET_UPDATE)
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+            context.registerReceiver(widgetUpdateReceiver, filter, Context.RECEIVER_EXPORTED)
+        } else {
+            context.registerReceiver(widgetUpdateReceiver, filter)
+        }
+    }
+
+    override fun onDisabled(context: Context) {
+        // Unregister broadcast receiver
+        try {
+            context.unregisterReceiver(widgetUpdateReceiver)
+        } catch (_: IllegalArgumentException) {
+            // Receiver not registered
+        }
+    }
+
+    private val widgetUpdateReceiver = object : BroadcastReceiver() {
+        override fun onReceive(context: Context, intent: Intent) {
+            if (intent.action == ACTION_WIDGET_UPDATE) {
+                updateAllWidgets(context)
+            }
+        }
+    }
+
+    private fun updateAppWidget(
+        context: Context,
+        appWidgetManager: AppWidgetManager,
+        appWidgetId: Int
+    ) {
+        // Get data from shared preferences
+        val prefs = context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+        val title = prefs.getString(PREF_TITLE, "Craft Widget") ?: "Craft Widget"
+        val subtitle = prefs.getString(PREF_SUBTITLE, "") ?: ""
+        val value = prefs.getString(PREF_VALUE, "") ?: ""
+        val iconName = prefs.getString(PREF_ICON, null)
+
+        // Create remote views
+        val views = RemoteViews(context.packageName, R.layout.craft_widget)
+
+        // Set text values
+        views.setTextViewText(R.id.widget_title, title)
+        views.setTextViewText(R.id.widget_subtitle, subtitle)
+        views.setTextViewText(R.id.widget_value, value)
+
+        // Set visibility for subtitle
+        views.setViewVisibility(
+            R.id.widget_subtitle,
+            if (subtitle.isEmpty()) android.view.View.GONE else android.view.View.VISIBLE
+        )
+
+        // Set visibility for value
+        views.setViewVisibility(
+            R.id.widget_value,
+            if (value.isEmpty()) android.view.View.GONE else android.view.View.VISIBLE
+        )
+
+        // Set icon if provided
+        if (iconName != null) {
+            val iconResId = context.resources.getIdentifier(
+                iconName,
+                "drawable",
+                context.packageName
+            )
+            if (iconResId != 0) {
+                views.setImageViewResource(R.id.widget_icon, iconResId)
+                views.setViewVisibility(R.id.widget_icon, android.view.View.VISIBLE)
+            } else {
+                views.setViewVisibility(R.id.widget_icon, android.view.View.GONE)
+            }
+        } else {
+            views.setViewVisibility(R.id.widget_icon, android.view.View.GONE)
+        }
+
+        // Create click intent to launch main app
+        val launchIntent = context.packageManager.getLaunchIntentForPackage(context.packageName)
+        if (launchIntent != null) {
+            val pendingIntent = PendingIntent.getActivity(
+                context,
+                0,
+                launchIntent,
+                PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
+            )
+            views.setOnClickPendingIntent(R.id.widget_container, pendingIntent)
+        }
+
+        // Update the widget
+        appWidgetManager.updateAppWidget(appWidgetId, views)
+    }
+}
+
+/**
+ * Widget Layout (res/layout/craft_widget.xml):
+ *
+ * <?xml version="1.0" encoding="utf-8"?>
+ * <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+ *     android:id="@+id/widget_container"
+ *     android:layout_width="match_parent"
+ *     android:layout_height="match_parent"
+ *     android:orientation="vertical"
+ *     android:padding="16dp"
+ *     android:background="@drawable/widget_background">
+ *
+ *     <ImageView
+ *         android:id="@+id/widget_icon"
+ *         android:layout_width="32dp"
+ *         android:layout_height="32dp"
+ *         android:visibility="gone" />
+ *
+ *     <TextView
+ *         android:id="@+id/widget_title"
+ *         android:layout_width="wrap_content"
+ *         android:layout_height="wrap_content"
+ *         android:textSize="16sp"
+ *         android:textStyle="bold"
+ *         android:textColor="@color/widget_text_primary" />
+ *
+ *     <TextView
+ *         android:id="@+id/widget_subtitle"
+ *         android:layout_width="wrap_content"
+ *         android:layout_height="wrap_content"
+ *         android:textSize="12sp"
+ *         android:textColor="@color/widget_text_secondary" />
+ *
+ *     <TextView
+ *         android:id="@+id/widget_value"
+ *         android:layout_width="wrap_content"
+ *         android:layout_height="wrap_content"
+ *         android:textSize="32sp"
+ *         android:textStyle="bold"
+ *         android:textColor="@color/widget_accent"
+ *         android:layout_marginTop="8dp" />
+ *
+ * </LinearLayout>
+ */
+
+/**
+ * Widget Info (res/xml/craft_widget_info.xml):
+ *
+ * <?xml version="1.0" encoding="utf-8"?>
+ * <appwidget-provider xmlns:android="http://schemas.android.com/apk/res/android"
+ *     android:minWidth="110dp"
+ *     android:minHeight="110dp"
+ *     android:targetCellWidth="2"
+ *     android:targetCellHeight="2"
+ *     android:updatePeriodMillis="1800000"
+ *     android:initialLayout="@layout/craft_widget"
+ *     android:resizeMode="horizontal|vertical"
+ *     android:widgetCategory="home_screen"
+ *     android:previewImage="@drawable/widget_preview"
+ *     android:description="@string/widget_description" />
+ */
+
+/**
+ * AndroidManifest.xml entries needed:
+ *
+ * <receiver
+ *     android:name=".CraftWidgetProvider"
+ *     android:exported="true">
+ *     <intent-filter>
+ *         <action android:name="android.appwidget.action.APPWIDGET_UPDATE" />
+ *         <action android:name="{{PACKAGE_NAME}}.WIDGET_UPDATE" />
+ *     </intent-filter>
+ *     <meta-data
+ *         android:name="android.appwidget.provider"
+ *         android:resource="@xml/craft_widget_info" />
+ * </receiver>
+ */

package/templates/LocationRecordingService.kt.template

@@ -0,0 +1,160 @@
+package {{PACKAGE_NAME}}
+
+import android.Manifest
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.app.Service
+import android.content.Context
+import android.content.Intent
+import android.content.pm.PackageManager
+import android.os.Build
+import android.os.IBinder
+import android.os.Looper
+import androidx.core.app.NotificationCompat
+import androidx.core.content.ContextCompat
+import com.google.android.gms.location.LocationCallback
+import com.google.android.gms.location.LocationRequest
+import com.google.android.gms.location.LocationResult
+import com.google.android.gms.location.LocationServices
+import com.google.android.gms.location.Priority
+import org.json.JSONArray
+import org.json.JSONObject
+import java.io.File
+
+object CraftLocationRecordingStore {
+    private const val PREFS = "craft_location_recording"
+    private const val FILE = "craft-location-recording.jsonl"
+
+    private fun prefs(context: Context) = context.getSharedPreferences(PREFS, Context.MODE_PRIVATE)
+    private fun file(context: Context) = File(context.filesDir, FILE)
+
+    @Synchronized
+    fun start(context: Context, id: String, startedAt: Long) {
+        file(context).writeText("")
+        prefs(context).edit()
+            .putString("id", id)
+            .putBoolean("active", true)
+            .putBoolean("paused", false)
+            .putLong("startedAt", startedAt)
+            .apply()
+    }
+
+    @Synchronized
+    fun setPaused(context: Context, paused: Boolean) {
+        prefs(context).edit().putBoolean("paused", paused).apply()
+    }
+
+    @Synchronized
+    fun stop(context: Context) {
+        prefs(context).edit().putBoolean("active", false).putBoolean("paused", false).apply()
+    }
+
+    fun isActive(context: Context) = prefs(context).getBoolean("active", false)
+    fun isPaused(context: Context) = prefs(context).getBoolean("paused", false)
+
+    @Synchronized
+    fun append(context: Context, location: android.location.Location) {
+        if (!isActive(context) || isPaused(context)) return
+        val json = JSONObject().apply {
+            put("latitude", location.latitude)
+            put("longitude", location.longitude)
+            put("accuracy", location.accuracy)
+            put("altitude", location.altitude)
+            put("speed", location.speed)
+            put("heading", location.bearing)
+            put("timestamp", location.time)
+        }
+        file(context).appendText("$json\n")
+    }
+
+    @Synchronized
+    fun locations(context: Context): JSONArray {
+        val result = JSONArray()
+        val source = file(context)
+        if (!source.exists()) return result
+        source.forEachLine { line ->
+            if (line.isNotBlank()) runCatching { result.put(JSONObject(line)) }
+        }
+        return result
+    }
+
+    fun state(context: Context, includeLocations: Boolean = false): JSONObject {
+        val values = prefs(context)
+        val locations = locations(context)
+        return JSONObject().apply {
+            put("id", values.getString("id", null))
+            put("active", values.getBoolean("active", false))
+            put("paused", values.getBoolean("paused", false))
+            put("startedAt", values.getLong("startedAt", 0).takeIf { it > 0 } ?: JSONObject.NULL)
+            put("sampleCount", locations.length())
+            if (includeLocations) put("locations", locations)
+        }
+    }
+}
+
+class LocationRecordingService : Service() {
+    private val client by lazy { LocationServices.getFusedLocationProviderClient(this) }
+    private var callback: LocationCallback? = null
+
+    override fun onCreate() {
+        super.onCreate()
+        val manager = getSystemService(NotificationManager::class.java)
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            manager.createNotificationChannel(NotificationChannel(CHANNEL, "Activity recording", NotificationManager.IMPORTANCE_LOW))
+        }
+        val notification = NotificationCompat.Builder(this, CHANNEL)
+            .setSmallIcon(android.R.drawable.ic_menu_mylocation)
+            .setContentTitle("Recording your activity")
+            .setContentText("WildLoop is securely saving your route")
+            .setOngoing(true)
+            .setSilent(true)
+            .build()
+        startForeground(NOTIFICATION_ID, notification)
+    }
+
+    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
+        when (intent?.action) {
+            ACTION_STOP -> {
+                stopUpdates()
+                stopSelf()
+                return START_NOT_STICKY
+            }
+            else -> startUpdates()
+        }
+        return if (CraftLocationRecordingStore.isActive(this)) START_STICKY else START_NOT_STICKY
+    }
+
+    private fun startUpdates() {
+        if (callback != null || !CraftLocationRecordingStore.isActive(this)) return
+        if (ContextCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED) return
+        val request = LocationRequest.Builder(Priority.PRIORITY_HIGH_ACCURACY, 5_000)
+            .setMinUpdateIntervalMillis(2_000)
+            .setMaxUpdateDelayMillis(10_000)
+            .build()
+        callback = object : LocationCallback() {
+            override fun onLocationResult(result: LocationResult) {
+                for (location in result.locations) CraftLocationRecordingStore.append(this@LocationRecordingService, location)
+            }
+        }
+        client.requestLocationUpdates(request, callback!!, Looper.getMainLooper())
+    }
+
+    private fun stopUpdates() {
+        callback?.let { client.removeLocationUpdates(it) }
+        callback = null
+    }
+
+    override fun onDestroy() {
+        stopUpdates()
+        super.onDestroy()
+    }
+
+    override fun onBind(intent: Intent?): IBinder? = null
+
+    companion object {
+        const val ACTION_START = "craft.location.START"
+        const val ACTION_STOP = "craft.location.STOP"
+        private const val CHANNEL = "craft_location_recording"
+        private const val NOTIFICATION_ID = 7001
+    }
+}

package/templates/MainActivity.kt.template

@@ -0,0 +1,230 @@
+package {{PACKAGE_NAME}}
+
+import android.annotation.SuppressLint
+import android.os.Bundle
+import android.content.Intent
+import android.net.Uri
+import android.webkit.WebResourceRequest
+import android.webkit.WebResourceError
+import android.webkit.WebResourceResponse
+import android.webkit.WebChromeClient
+import android.webkit.WebSettings
+import android.webkit.WebView
+import android.webkit.WebViewClient
+import androidx.appcompat.app.AppCompatActivity
+import androidx.core.view.WindowCompat
+import androidx.webkit.WebViewAssetLoader
+import org.json.JSONObject
+import java.io.FileNotFoundException
+import java.net.URLConnection
+
+class MainActivity : AppCompatActivity() {
+    private lateinit var webView: WebView
+    private lateinit var craftBridge: CraftBridge
+    private val devServerUrl: String? by lazy { loadDevServerUrl() }
+    private val trustedOrigins: Set<String> by lazy { loadTrustedOrigins() }
+    private val hasBundledFallback: Boolean by lazy { configJson()?.optBoolean("hasBundledFallback", false) == true }
+    private val bundledAssetLoader: WebViewAssetLoader by lazy {
+        WebViewAssetLoader.Builder()
+            .setDomain(BUNDLED_APP_HOST)
+            .addPathHandler("/", RouteAwareAssetPathHandler())
+            .build()
+    }
+    private var loadedBundledFallback = false
+
+    @SuppressLint("SetJavaScriptEnabled")
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+
+        // Enable edge-to-edge
+        WindowCompat.setDecorFitsSystemWindows(window, false)
+
+        setContentView(R.layout.activity_main)
+
+        webView = findViewById(R.id.webview)
+        craftBridge = CraftBridge(this, webView, CraftHealthConnect(this, webView))
+        handleIncomingDeepLink(intent, dispatch = false)
+
+        setupWebView()
+        loadContent()
+    }
+
+    @SuppressLint("SetJavaScriptEnabled")
+    private fun setupWebView() {
+        webView.settings.apply {
+            javaScriptEnabled = true
+            domStorageEnabled = true
+            allowFileAccess = false
+            allowContentAccess = false
+            allowFileAccessFromFileURLs = false
+            allowUniversalAccessFromFileURLs = false
+            mediaPlaybackRequiresUserGesture = false
+            mixedContentMode = WebSettings.MIXED_CONTENT_NEVER_ALLOW
+            cacheMode = WebSettings.LOAD_DEFAULT
+            setSupportZoom(false)
+            builtInZoomControls = false
+            displayZoomControls = false
+        }
+
+        webView.webViewClient = object : WebViewClient() {
+            override fun onPageFinished(view: WebView?, url: String?) {
+                super.onPageFinished(view, url)
+                if (url != null && isTrustedUrl(url)) craftBridge.injectBridge()
+            }
+
+            override fun shouldInterceptRequest(view: WebView?, request: WebResourceRequest?): WebResourceResponse? {
+                val url = request?.url ?: return null
+                return bundledAssetLoader.shouldInterceptRequest(url)
+                    ?: super.shouldInterceptRequest(view, request)
+            }
+
+            override fun shouldOverrideUrlLoading(view: WebView?, request: WebResourceRequest?): Boolean {
+                val url = request?.url?.toString() ?: return true
+                if (isTrustedUrl(url)) return false
+                runCatching { startActivity(Intent(Intent.ACTION_VIEW, Uri.parse(url))) }
+                return true
+            }
+
+            override fun onReceivedError(view: WebView?, request: WebResourceRequest?, error: WebResourceError?) {
+                super.onReceivedError(view, request, error)
+                if (request?.isForMainFrame == true && hasBundledFallback && !loadedBundledFallback) {
+                    loadedBundledFallback = true
+                    webView.loadUrl(BUNDLED_APP_URL)
+                }
+            }
+        }
+
+        webView.webChromeClient = WebChromeClient()
+
+        // Add JavaScript interface
+        webView.addJavascriptInterface(craftBridge, "CraftAndroid")
+    }
+
+    private fun loadContent() {
+        // Check for dev server URL in config
+        val remoteUrl = devServerUrl
+        if (remoteUrl != null) {
+            webView.loadUrl(remoteUrl)
+        } else {
+            // Load from assets
+            webView.loadUrl(BUNDLED_APP_URL)
+        }
+    }
+
+    private inner class RouteAwareAssetPathHandler : WebViewAssetLoader.PathHandler {
+        override fun handle(path: String): WebResourceResponse? {
+            val cleanPath = Uri.decode(path).substringBefore('?').trimStart('/')
+            if (cleanPath.split('/').any { it == ".." }) return null
+            val candidates = when {
+                cleanPath.isBlank() -> listOf("index.html")
+                cleanPath.endsWith('/') -> listOf("${cleanPath}index.html")
+                cleanPath.substringAfterLast('/').contains('.') -> listOf(cleanPath)
+                else -> listOf("${cleanPath}.html", "${cleanPath}/index.html")
+            }
+
+            for (candidate in candidates) {
+                try {
+                    val stream = assets.open(candidate)
+                    val mimeType = URLConnection.guessContentTypeFromName(candidate)
+                        ?: when (candidate.substringAfterLast('.', "").lowercase()) {
+                            "js", "mjs" -> "text/javascript"
+                            "css" -> "text/css"
+                            "json", "webmanifest" -> "application/json"
+                            "svg" -> "image/svg+xml"
+                            else -> "application/octet-stream"
+                        }
+                    val encoding = if (mimeType.startsWith("text/") || mimeType.contains("javascript") || mimeType.contains("json")) "UTF-8" else null
+                    return WebResourceResponse(mimeType, encoding, stream)
+                } catch (_: FileNotFoundException) {
+                    // Try the next clean-route candidate.
+                }
+            }
+            return null
+        }
+    }
+
+    private fun handleIncomingDeepLink(source: Intent?, dispatch: Boolean) {
+        val url = source?.data?.toString() ?: return
+        craftBridge.setInitialURL(url)
+        if (dispatch) craftBridge.dispatchDeepLink(url)
+    }
+
+    private fun configJson(): JSONObject? {
+        return try {
+            assets.open("craft.config.json").bufferedReader().use { JSONObject(it.readText()) }
+        } catch (_: Exception) {
+            null
+        }
+    }
+
+    private fun loadDevServerUrl(): String? {
+        return try {
+            configJson()?.optString("devServerURL")?.takeIf { it.isNotBlank() }
+        } catch (e: Exception) {
+            null
+        }
+    }
+
+    private fun loadTrustedOrigins(): Set<String> {
+        val origins = mutableSetOf<String>()
+        val config = configJson()
+        val configured = config?.optJSONArray("trustedOrigins")
+        if (configured != null) {
+            for (index in 0 until configured.length()) origins.add(configured.optString(index))
+        }
+        devServerUrl?.let { url ->
+            val uri = Uri.parse(url)
+            origins.add("${uri.scheme}://${uri.authority}")
+        }
+        return origins
+    }
+
+    private fun isTrustedUrl(value: String): Boolean {
+        val uri = Uri.parse(value)
+        if (uri.scheme == "https" && uri.host == BUNDLED_APP_HOST) return true
+        val origin = "${uri.scheme}://${uri.authority}"
+        val localDevelopment = uri.scheme == "http" && uri.host in setOf("localhost", "127.0.0.1", "10.0.2.2")
+        return (uri.scheme == "https" || localDevelopment) && origin in trustedOrigins
+    }
+
+    override fun onNewIntent(intent: Intent) {
+        super.onNewIntent(intent)
+        setIntent(intent)
+        handleIncomingDeepLink(intent, dispatch = true)
+    }
+
+    override fun onBackPressed() {
+        if (webView.canGoBack()) {
+            webView.goBack()
+        } else {
+            super.onBackPressed()
+        }
+    }
+
+    override fun onResume() {
+        super.onResume()
+        webView.onResume()
+    }
+
+    override fun onPause() {
+        webView.onPause()
+        super.onPause()
+    }
+
+    override fun onDestroy() {
+        craftBridge.close()
+        webView.destroy()
+        super.onDestroy()
+    }
+
+    @Deprecated("Delegates the Health Connect permission contract on Android 13 and earlier")
+    override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
+        if (craftBridge.onActivityResult(requestCode, resultCode, data)) return
+        super.onActivityResult(requestCode, resultCode, data)
+    }
+
+    companion object {
+        private const val BUNDLED_APP_HOST = "appassets.androidplatform.net"
+        private const val BUNDLED_APP_URL = "https://appassets.androidplatform.net/"
+    }
+}