neoagent 2.3.1-beta.20 → 2.3.1-beta.21

package/flutter_app/android/app/src/main/kotlin/com/neoagent/flutter_app/widgets/AiWidgetStore.kt

@@ -0,0 +1,194 @@
+package com.neoagent.flutter_app.widgets
+
+import android.content.Context
+import org.json.JSONArray
+import org.json.JSONObject
+
+data class CachedAiWidgetTask(
+    val id: String,
+    val name: String,
+    val triggerSummary: String,
+)
+
+data class CachedAiWidget(
+    val id: String,
+    val name: String,
+    val template: String,
+    val layoutVariant: String,
+    val refreshCron: String,
+    val enabled: Boolean,
+    val lastError: String?,
+    val latestSnapshot: JSONObject?,
+    val tasks: List<CachedAiWidgetTask>,
+)
+
+internal object AiWidgetPrefs {
+    const val PREFS_NAME = "neoagent_ai_widgets"
+    const val KEY_ENABLED = "enabled"
+    const val KEY_BACKEND_URL = "backend_url"
+    const val KEY_SESSION_COOKIE = "session_cookie"
+    const val KEY_CACHED_WIDGETS = "cached_widgets"
+    const val KEY_LAST_SYNC_AT = "last_sync_at"
+    const val KEY_LAST_ERROR = "last_error"
+    const val KEY_PENDING_OPEN_WIDGET_ID = "pending_open_widget_id"
+    const val KEY_BINDING_PREFIX = "binding_"
+    const val KEY_EXPANDED_PREFIX = "expanded_"
+
+    fun read(context: Context) =
+        context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+}
+
+class AiWidgetStore(private val context: Context) {
+
+    private val pendingOpenLock = Any()
+
+    fun saveConfig(
+        enabled: Boolean,
+        backendUrl: String,
+        sessionCookie: String,
+    ) {
+        AiWidgetPrefs.read(context)
+            .edit()
+            .putBoolean(AiWidgetPrefs.KEY_ENABLED, enabled)
+            .putString(AiWidgetPrefs.KEY_BACKEND_URL, backendUrl.trim())
+            .putString(AiWidgetPrefs.KEY_SESSION_COOKIE, sessionCookie.trim())
+            .apply()
+    }
+
+    fun isEnabled(): Boolean =
+        AiWidgetPrefs.read(context).getBoolean(AiWidgetPrefs.KEY_ENABLED, false)
+
+    fun backendUrl(): String =
+        AiWidgetPrefs.read(context)
+            .getString(AiWidgetPrefs.KEY_BACKEND_URL, "")
+            ?.trim()
+            .orEmpty()
+
+    fun sessionCookie(): String =
+        AiWidgetPrefs.read(context)
+            .getString(AiWidgetPrefs.KEY_SESSION_COOKIE, "")
+            ?.trim()
+            .orEmpty()
+
+    fun saveCachedWidgets(rawJson: String) {
+        AiWidgetPrefs.read(context)
+            .edit()
+            .putString(AiWidgetPrefs.KEY_CACHED_WIDGETS, rawJson)
+            .putString(AiWidgetPrefs.KEY_LAST_SYNC_AT, java.time.Instant.now().toString())
+            .remove(AiWidgetPrefs.KEY_LAST_ERROR)
+            .apply()
+    }
+
+    fun setLastError(message: String) {
+        AiWidgetPrefs.read(context)
+            .edit()
+            .putString(AiWidgetPrefs.KEY_LAST_ERROR, message)
+            .apply()
+    }
+
+    fun cachedWidgets(): List<CachedAiWidget> {
+        val raw =
+            AiWidgetPrefs.read(context).getString(AiWidgetPrefs.KEY_CACHED_WIDGETS, null)
+                ?: return emptyList()
+        return try {
+            val array = JSONArray(raw)
+            buildList {
+                for (index in 0 until array.length()) {
+                    val item = array.optJSONObject(index) ?: continue
+                    add(
+                        CachedAiWidget(
+                            id = item.optString("id").trim(),
+                            name = item.optString("name").trim(),
+                            template = item.optString("template", "summary").trim(),
+                            layoutVariant =
+                                item.optString("layoutVariant", item.optString("layout_variant"))
+                                    .trim(),
+                            refreshCron =
+                                item.optString("refreshCron", item.optString("refresh_cron"))
+                                    .trim(),
+                            enabled = item.optBoolean("enabled", true),
+                            lastError =
+                                item.optString("lastError")
+                                    .trim()
+                                    .ifEmpty { item.optString("last_error").trim() }
+                                    .ifEmpty { "" }
+                                    .let { if (it.isBlank()) null else it },
+                            latestSnapshot = item.optJSONObject("latestSnapshot"),
+                            tasks = buildList {
+                                val tasksArray = item.optJSONArray("tasks")
+                                if (tasksArray != null) {
+                                    for (t in 0 until tasksArray.length()) {
+                                        val tItem = tasksArray.optJSONObject(t) ?: continue
+                                        add(
+                                            CachedAiWidgetTask(
+                                                id = tItem.optString("id"),
+                                                name = tItem.optString("name", "Task"),
+                                                triggerSummary = tItem.optString("triggerSummary"),
+                                            )
+                                        )
+                                    }
+                                }
+                            },
+                        ),
+                    )
+                }
+            }
+        } catch (_: Exception) {
+            emptyList()
+        }
+    }
+
+    fun findWidget(widgetId: String): CachedAiWidget? =
+        cachedWidgets().firstOrNull { it.id == widgetId }
+
+    fun bindAppWidget(appWidgetId: Int, widgetId: String) {
+        AiWidgetPrefs.read(context)
+            .edit()
+            .putString("${AiWidgetPrefs.KEY_BINDING_PREFIX}$appWidgetId", widgetId)
+            .apply()
+    }
+
+    fun widgetIdForAppWidget(appWidgetId: Int): String? =
+        AiWidgetPrefs.read(context)
+            .getString("${AiWidgetPrefs.KEY_BINDING_PREFIX}$appWidgetId", null)
+            ?.trim()
+            ?.let { if (it.isBlank()) null else it }
+
+    fun clearBinding(appWidgetId: Int) {
+        AiWidgetPrefs.read(context)
+            .edit()
+            .remove("${AiWidgetPrefs.KEY_BINDING_PREFIX}$appWidgetId")
+            .apply()
+    }
+
+    fun setPendingOpenWidgetId(widgetId: String?) {
+        AiWidgetPrefs.read(context)
+            .edit()
+            .putString(AiWidgetPrefs.KEY_PENDING_OPEN_WIDGET_ID, widgetId?.trim())
+            .apply()
+    }
+
+    fun consumePendingOpenWidgetId(): String? {
+        synchronized(pendingOpenLock) {
+            val prefs = AiWidgetPrefs.read(context)
+            val widgetId =
+                prefs.getString(AiWidgetPrefs.KEY_PENDING_OPEN_WIDGET_ID, null)
+                    ?.trim()
+                    ?.let { if (it.isBlank()) null else it }
+            if (widgetId != null) {
+                prefs.edit().remove(AiWidgetPrefs.KEY_PENDING_OPEN_WIDGET_ID).commit()
+            }
+            return widgetId
+        }
+    }
+
+    fun isTasksExpanded(appWidgetId: Int): Boolean =
+        AiWidgetPrefs.read(context).getBoolean("${AiWidgetPrefs.KEY_EXPANDED_PREFIX}$appWidgetId", false)
+
+    fun toggleTasksExpanded(appWidgetId: Int) {
+        val prefs = AiWidgetPrefs.read(context)
+        val key = "${AiWidgetPrefs.KEY_EXPANDED_PREFIX}$appWidgetId"
+        val current = prefs.getBoolean(key, false)
+        prefs.edit().putBoolean(key, !current).apply()
+    }
+}

package/flutter_app/android/app/src/main/kotlin/com/neoagent/flutter_app/widgets/VoiceLaunchWidgetProvider.kt

@@ -0,0 +1,67 @@
+package com.neoagent.flutter_app.widgets
+
+import android.app.PendingIntent
+import android.appwidget.AppWidgetManager
+import android.appwidget.AppWidgetProvider
+import android.content.ComponentName
+import android.content.Context
+import android.content.Intent
+import android.widget.RemoteViews
+import com.neoagent.flutter_app.MainActivity
+import com.neoagent.flutter_app.R
+
+class VoiceLaunchWidgetProvider : AppWidgetProvider() {
+
+    override fun onUpdate(
+        context: Context,
+        appWidgetManager: AppWidgetManager,
+        appWidgetIds: IntArray,
+    ) {
+        refreshAll(context, appWidgetManager, appWidgetIds)
+    }
+
+    companion object {
+        const val ACTION_OPEN_VOICE_ASSISTANT =
+            "com.neoagent.flutter_app.widgets.OPEN_VOICE_ASSISTANT"
+        const val OPEN_TARGET_VOICE_ASSISTANT = "voice_assistant"
+
+        fun refreshAll(context: Context) {
+            val manager = AppWidgetManager.getInstance(context)
+            val componentName = ComponentName(context, VoiceLaunchWidgetProvider::class.java)
+            val ids = manager.getAppWidgetIds(componentName)
+            refreshAll(context, manager, ids)
+        }
+
+        fun refreshAll(
+            context: Context,
+            manager: AppWidgetManager,
+            appWidgetIds: IntArray,
+        ) {
+            appWidgetIds.forEach { appWidgetId ->
+                manager.updateAppWidget(appWidgetId, buildRemoteViews(context, appWidgetId))
+            }
+        }
+
+        private fun buildRemoteViews(context: Context, appWidgetId: Int): RemoteViews {
+            val views = RemoteViews(context.packageName, R.layout.neoagent_voice_widget)
+            val intent =
+                Intent(context, MainActivity::class.java).apply {
+                    action = ACTION_OPEN_VOICE_ASSISTANT
+                    flags =
+                        Intent.FLAG_ACTIVITY_NEW_TASK or
+                            Intent.FLAG_ACTIVITY_CLEAR_TOP or
+                            Intent.FLAG_ACTIVITY_SINGLE_TOP
+                    putExtra(AppWidgetManager.EXTRA_APPWIDGET_ID, appWidgetId)
+                }
+            val pendingIntent =
+                PendingIntent.getActivity(
+                    context,
+                    appWidgetId,
+                    intent,
+                    PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE,
+                )
+            views.setOnClickPendingIntent(R.id.voice_widget_root, pendingIntent)
+            return views
+        }
+    }
+}

package/flutter_app/android/app/src/main/kotlin/com/neoagent/flutter_app/widgets/WidgetConfigActivity.kt

@@ -0,0 +1,228 @@
+package com.neoagent.flutter_app.widgets
+
+import android.app.Activity
+import android.appwidget.AppWidgetManager
+import android.content.Intent
+import android.graphics.Color
+import android.graphics.Typeface
+import android.graphics.drawable.GradientDrawable
+import android.os.Bundle
+import android.util.TypedValue
+import android.view.View
+import android.view.ViewGroup
+import android.widget.LinearLayout
+import android.widget.ScrollView
+import android.widget.TextView
+import com.neoagent.flutter_app.R
+
+class WidgetConfigActivity : Activity() {
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+
+        val appWidgetId =
+            intent?.extras?.getInt(
+                AppWidgetManager.EXTRA_APPWIDGET_ID,
+                AppWidgetManager.INVALID_APPWIDGET_ID,
+            ) ?: AppWidgetManager.INVALID_APPWIDGET_ID
+        if (appWidgetId == AppWidgetManager.INVALID_APPWIDGET_ID) {
+            finish()
+            return
+        }
+
+        setResult(RESULT_CANCELED)
+
+        val store = AiWidgetStore(this)
+        val widgets = store.cachedWidgets().filter { it.id.isNotBlank() }
+
+        val root =
+            ScrollView(this).apply {
+                setBackgroundColor(Color.parseColor("#0D1118"))
+                isFillViewport = true
+            }
+        val content =
+            LinearLayout(this).apply {
+                orientation = LinearLayout.VERTICAL
+                setPadding(dp(20), dp(28), dp(20), dp(24))
+            }
+        root.addView(
+            content,
+            ViewGroup.LayoutParams(
+                ViewGroup.LayoutParams.MATCH_PARENT,
+                ViewGroup.LayoutParams.WRAP_CONTENT,
+            ),
+        )
+
+        content.addView(
+            textView(
+                text = getString(R.string.widget_config_title),
+                sizeSp = 28f,
+                color = Color.WHITE,
+                style = Typeface.BOLD,
+            ),
+        )
+        content.addView(spacer(8))
+        content.addView(
+            textView(
+                text = "Choose the widget you want to place on your home screen.",
+                sizeSp = 15f,
+                color = Color.parseColor("#A7B2C5"),
+            ),
+        )
+        content.addView(spacer(22))
+
+        if (widgets.isEmpty()) {
+            content.addView(
+                buildCard(
+                    title = "No widgets available yet",
+                    subtitle = getString(R.string.widget_config_empty_state),
+                    meta = "Open NeoAgent and refresh widgets first",
+                ) {},
+            )
+            setContentView(root)
+            return
+        }
+
+        widgets.forEachIndexed { index, widget ->
+            val cadence =
+                if (widget.enabled) formatCadence(widget.refreshCron) else "Paused"
+            val subtitle =
+                widget.latestSnapshot?.optString("subtitle")
+                    ?.trim()
+                    ?.takeIf { it.isNotEmpty() && !it.equals("null", ignoreCase = true) }
+                    ?: if (widget.latestSnapshot == null) {
+                        "Waiting for first update"
+                    } else {
+                        "Ready on home screen"
+                    }
+            val card =
+                buildCard(
+                    title = displayName(widget.name),
+                    subtitle = subtitle,
+                    meta = cadence,
+                ) {
+                    store.bindAppWidget(appWidgetId, widget.id)
+                    AiHomeWidgetProvider.refreshAll(this)
+                    val resultIntent =
+                        Intent().putExtra(AppWidgetManager.EXTRA_APPWIDGET_ID, appWidgetId)
+                    setResult(RESULT_OK, resultIntent)
+                    finish()
+                }
+            content.addView(card)
+            if (index < widgets.lastIndex) {
+                content.addView(spacer(14))
+            }
+        }
+
+        setContentView(root)
+    }
+
+    private fun buildCard(
+        title: String,
+        subtitle: String,
+        meta: String,
+        onClick: () -> Unit,
+    ): View {
+        val card =
+            LinearLayout(this).apply {
+                orientation = LinearLayout.VERTICAL
+                setPadding(dp(18), dp(18), dp(18), dp(18))
+                background =
+                    GradientDrawable().apply {
+                        cornerRadius = dp(24).toFloat()
+                        setColor(Color.parseColor("#171E29"))
+                        setStroke(dp(1), Color.parseColor("#22FFFFFF"))
+                    }
+                isClickable = true
+                isFocusable = true
+                setOnClickListener { onClick() }
+            }
+        card.addView(
+            textView(
+                text = title,
+                sizeSp = 20f,
+                color = Color.WHITE,
+                style = Typeface.BOLD,
+            ),
+        )
+        card.addView(spacer(8))
+        card.addView(
+            textView(
+                text = subtitle,
+                sizeSp = 14f,
+                color = Color.parseColor("#C7D0E0"),
+            ),
+        )
+        card.addView(spacer(14))
+        card.addView(
+            textView(
+                text = meta,
+                sizeSp = 13f,
+                color = Color.parseColor("#8FB8FF"),
+                style = Typeface.BOLD,
+            ),
+        )
+        return card
+    }
+
+    private fun textView(
+        text: String,
+        sizeSp: Float,
+        color: Int,
+        style: Int = Typeface.NORMAL,
+    ): TextView {
+        return TextView(this).apply {
+            this.text = text
+            setTextSize(TypedValue.COMPLEX_UNIT_SP, sizeSp)
+            setTextColor(color)
+            setTypeface(typeface, style)
+        }
+    }
+
+    private fun spacer(heightDp: Int): View =
+        View(this).apply {
+            layoutParams =
+                LinearLayout.LayoutParams(
+                    ViewGroup.LayoutParams.MATCH_PARENT,
+                    dp(heightDp),
+                )
+        }
+
+    private fun formatCadence(refreshCron: String): String {
+        val normalized = refreshCron.trim()
+        if (normalized == "0 * * * *") {
+            return "Updates hourly"
+        }
+        val hours = Regex("\\*/(\\d+)").find(normalized)?.groupValues?.getOrNull(1)?.toIntOrNull()
+        if (hours != null && hours > 1) {
+            return "Every $hours hours"
+        }
+        return "Refreshes automatically"
+    }
+
+    private fun displayName(raw: String): String {
+        val normalized =
+            raw.trim()
+                .replace(Regex("[_-]+"), " ")
+                .replace(Regex("\\s+"), " ")
+        if (normalized.isBlank()) {
+            return "AI Widget"
+        }
+        return normalized.split(" ")
+            .filter { it.isNotBlank() }
+            .joinToString(" ") { part ->
+                if (part.length <= 2 && part.uppercase() == part) {
+                    part
+                } else {
+                    part.substring(0, 1).uppercase() + part.substring(1)
+                }
+            }
+    }
+
+    private fun dp(value: Int): Int =
+        TypedValue.applyDimension(
+            TypedValue.COMPLEX_UNIT_DIP,
+            value.toFloat(),
+            resources.displayMetrics,
+        ).toInt()
+}

package/flutter_app/android/app/src/main/kotlin/com/neoagent/flutter_app/widgets/WidgetSyncScheduler.kt

@@ -0,0 +1,72 @@
+package com.neoagent.flutter_app.widgets
+
+import android.content.Context
+import androidx.work.Constraints
+import androidx.work.ExistingPeriodicWorkPolicy
+import androidx.work.ExistingWorkPolicy
+import androidx.work.NetworkType
+import androidx.work.OneTimeWorkRequestBuilder
+import androidx.work.PeriodicWorkRequestBuilder
+import androidx.work.WorkManager
+import java.util.concurrent.TimeUnit
+
+class WidgetSyncScheduler(private val context: Context) {
+
+    fun configure(
+        enabled: Boolean,
+        backendUrl: String,
+        sessionCookie: String,
+    ) {
+        val store = AiWidgetStore(context)
+        store.saveConfig(
+            enabled = enabled,
+            backendUrl = backendUrl,
+            sessionCookie = sessionCookie,
+        )
+
+        val workManager = WorkManager.getInstance(context)
+        if (!enabled) {
+            workManager.cancelUniqueWork(UNIQUE_PERIODIC_WORK)
+            workManager.cancelUniqueWork(UNIQUE_IMMEDIATE_WORK)
+            return
+        }
+
+        val constraints = Constraints.Builder()
+            .setRequiredNetworkType(NetworkType.CONNECTED)
+            .build()
+
+        val periodicRequest =
+            PeriodicWorkRequestBuilder<WidgetSyncWorker>(1, TimeUnit.HOURS)
+                .setConstraints(constraints)
+                .build()
+
+        workManager.enqueueUniquePeriodicWork(
+            UNIQUE_PERIODIC_WORK,
+            ExistingPeriodicWorkPolicy.UPDATE,
+            periodicRequest,
+        )
+    }
+
+    fun syncNow() {
+        if (!AiWidgetStore(context).isEnabled()) {
+            return
+        }
+        val constraints = Constraints.Builder()
+            .setRequiredNetworkType(NetworkType.CONNECTED)
+            .build()
+        val request =
+            OneTimeWorkRequestBuilder<WidgetSyncWorker>()
+                .setConstraints(constraints)
+                .build()
+        WorkManager.getInstance(context).enqueueUniqueWork(
+            UNIQUE_IMMEDIATE_WORK,
+            ExistingWorkPolicy.REPLACE,
+            request,
+        )
+    }
+
+    companion object {
+        private const val UNIQUE_PERIODIC_WORK = "neoagent_widgets_periodic_sync"
+        private const val UNIQUE_IMMEDIATE_WORK = "neoagent_widgets_immediate_sync"
+    }
+}