nn-widgets 0.1.4 → 0.1.13

package/android/src/main/java/expo/modules/nnwidgets/NNWidgetsModule.kt

@@ -0,0 +1,126 @@
+package expo.modules.nnwidgets
+
+import android.appwidget.AppWidgetManager
+import android.content.ComponentName
+import android.content.Context
+import android.content.Intent
+import android.content.SharedPreferences
+import androidx.core.os.bundleOf
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+import expo.modules.kotlin.Promise
+import org.json.JSONObject
+
+class NNWidgetsModule : Module() {
+    
+    companion object {
+        const val PREFS_NAME = "nn_widgets_data"
+        const val WIDGET_DATA_KEYS = "widget_data_keys"
+    }
+    
+    private val context get() = requireNotNull(appContext.reactContext)
+    
+    private fun getPreferences(): SharedPreferences {
+        return context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+    }
+    
+    override fun definition() = ModuleDefinition {
+        Name("NNWidgets")
+        
+        // Check if widgets are supported (Android 4.0+, API 14+)
+        Function("isSupported") {
+            true // Widgets are supported on all modern Android versions
+        }
+        
+        // Set widget data to SharedPreferences
+        AsyncFunction("setWidgetData") { data: Map<String, Any?>, promise: Promise ->
+            try {
+                val prefs = getPreferences()
+                val editor = prefs.edit()
+                val keys = mutableListOf<String>()
+                
+                for ((key, value) in data) {
+                    val prefKey = "widget_$key"
+                    keys.add(prefKey)
+                    
+                    when (value) {
+                        is String -> editor.putString(prefKey, value)
+                        is Int -> editor.putInt(prefKey, value)
+                        is Long -> editor.putLong(prefKey, value)
+                        is Float -> editor.putFloat(prefKey, value)
+                        is Double -> editor.putFloat(prefKey, value.toFloat())
+                        is Boolean -> editor.putBoolean(prefKey, value)
+                        null -> editor.remove(prefKey)
+                        else -> editor.putString(prefKey, value.toString())
+                    }
+                }
+                
+                // Store keys list
+                editor.putStringSet(WIDGET_DATA_KEYS, keys.toSet())
+                editor.apply()
+                
+                println("[NNWidgets] Widget data saved: ${keys.joinToString(", ")}")
+                promise.resolve(true)
+            } catch (e: Exception) {
+                println("[NNWidgets] Failed to save widget data: ${e.message}")
+                promise.resolve(false)
+            }
+        }
+        
+        // Get widget data from SharedPreferences
+        AsyncFunction("getWidgetData") { promise: Promise ->
+            try {
+                val prefs = getPreferences()
+                val keys = prefs.getStringSet(WIDGET_DATA_KEYS, emptySet()) ?: emptySet()
+                val result = mutableMapOf<String, Any?>()
+                
+                for (key in keys) {
+                    val cleanKey = key.removePrefix("widget_")
+                    val value = prefs.all[key]
+                    if (value != null) {
+                        result[cleanKey] = value
+                    }
+                }
+                
+                promise.resolve(result)
+            } catch (e: Exception) {
+                println("[NNWidgets] Failed to get widget data: ${e.message}")
+                promise.resolve(emptyMap<String, Any?>())
+            }
+        }
+        
+        // Request widget update
+        AsyncFunction("reloadWidget") { widgetClassName: String?, promise: Promise ->
+            try {
+                val appWidgetManager = AppWidgetManager.getInstance(context)
+                
+                if (widgetClassName != null) {
+                    // Update specific widget
+                    val componentName = ComponentName(context.packageName, widgetClassName)
+                    val widgetIds = appWidgetManager.getAppWidgetIds(componentName)
+                    
+                    if (widgetIds.isNotEmpty()) {
+                        val intent = Intent(AppWidgetManager.ACTION_APPWIDGET_UPDATE).apply {
+                            putExtra(AppWidgetManager.EXTRA_APPWIDGET_IDS, widgetIds)
+                            component = componentName
+                        }
+                        context.sendBroadcast(intent)
+                        println("[NNWidgets] Reloaded widget: $widgetClassName")
+                    }
+                } else {
+                    // Broadcast update to all widgets in the app
+                    // This requires knowing the widget class names
+                    // For now, we'll use a custom broadcast that widgets can listen to
+                    val intent = Intent("${context.packageName}.WIDGET_UPDATE")
+                    context.sendBroadcast(intent)
+                    println("[NNWidgets] Sent update broadcast to all widgets")
+                }
+                
+                promise.resolve(true)
+            } catch (e: Exception) {
+                println("[NNWidgets] Failed to reload widget: ${e.message}")
+                promise.resolve(false)
+            }
+        }
+    }
+}

package/expo-module.config.json

@@ -4,6 +4,7 @@
     "modules": ["NNWidgetsModule"]
   },
   "android": {
-    "modules": ["expo.modules.nnwidgets.NNWidgetsModule"]
+    "modules": ["expo.modules.nnwidgets.NNWidgetsModule"],
+    "packageImportPath": "expo.modules.nnwidgets"
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nn-widgets",
-  "version": "0.1.4",
+  "version": "0.1.13",
   "description": "Expo config plugin for adding native widgets (iOS WidgetKit & Android App Widgets)",
   "main": "build/index.js",
   "types": "build/index.d.ts",

package/plugin/build/withIosWidget.js

@@ -927,24 +927,24 @@ struct ${w.name}Provider: TimelineProvider {
 
 struct ${w.name}FlexCell: View {
     let item: WidgetListItem
+    let cellRatio: Double
     let defaultTitleColor: Color
     let defaultDescColor: Color
     let defaultAccentColor: Color
     
-    // Determine display mode based on item data:
-    // - hasRightIconOrDesc: show as list row (horizontal)
-    // - hasTitle: show as card (icon top, title bottom)
-    // - else: icon only
-    private var isListMode: Bool {
-        item.rightIcon != nil || item.description != nil
+    // Display mode based on cell ratio:
+    // - ratio == 1.0: list row style (icon left, text right)
+    // - ratio < 1.0: card style (icon top, text bottom)
+    private var isFullWidth: Bool {
+        cellRatio >= 1.0
     }
     
     private var isIconOnly: Bool {
-        item.title.text.isEmpty && !isListMode
+        item.title.text.isEmpty
     }
     
     var body: some View {
-        if isListMode {
+        if isFullWidth {
             // List row style: [icon] [title + desc] [rightIcon]
             HStack(spacing: 8) {
                 if let icon = item.icon {
@@ -992,21 +992,18 @@ struct ${w.name}FlexCell: View {
                 WidgetIconView(config: icon, accentColor: defaultAccentColor)
             }
         } else {
-            // Card style: icon on top, title below
+            // Card style: icon on top, small title below
             VStack(spacing: 4) {
                 if let icon = item.icon {
                     WidgetIconView(config: icon, accentColor: defaultAccentColor)
                 }
                 
                 Text(item.title.text)
-                    .font(item.title.resolvedFont(default: .caption))
-                    .fontWeight(item.title.resolvedWeight(default: .medium))
-                    .foregroundColor(
-                        item.title.color != nil
-                            ? Color(hex: item.title.color!)
-                            : defaultTitleColor
-                    )
-                    .lineLimit(1)
+                    .font(.caption2)
+                    .fontWeight(.medium)
+                    .foregroundColor(defaultTitleColor)
+                    .lineLimit(2)
+                    .multilineTextAlignment(.center)
                     .truncationMode(.tail)
             }
             .frame(maxWidth: .infinity, maxHeight: .infinity)
@@ -1179,6 +1176,7 @@ struct ${w.name}FlexRow: View {
     @ViewBuilder
     private func cellView(colIndex: Int, width: CGFloat) -> some View {
         let index = getItemIndex(rowIndex: rowIndex, colIndex: colIndex)
+        let cellRatio = rowRatios[colIndex]
         let verticalAlignment: Alignment = {
             switch alignItems {
             case .flexStart: return .top
@@ -1193,6 +1191,7 @@ struct ${w.name}FlexRow: View {
                 Link(destination: url) {
                     ${w.name}FlexCell(
                         item: item,
+                        cellRatio: cellRatio,
                         defaultTitleColor: titleColor,
                         defaultDescColor: subtitleColor,
                         defaultAccentColor: accentColor
@@ -1202,6 +1201,7 @@ struct ${w.name}FlexRow: View {
             } else {
                 ${w.name}FlexCell(
                     item: item,
+                    cellRatio: cellRatio,
                     defaultTitleColor: titleColor,
                     defaultDescColor: subtitleColor,
                     defaultAccentColor: accentColor