craft-native 0.0.37 → 0.0.49

package/dist/android/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/dist/android/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>
+ */