voltra 1.4.1 → 2.0.0-rc.3

package/android/src/main/java/voltra/VoltraOngoingNotificationDismissedReceiver.kt

@@ -1,15 +0,0 @@
-package voltra
-
-import android.content.BroadcastReceiver
-import android.content.Context
-import android.content.Intent
-
-class VoltraOngoingNotificationDismissedReceiver : BroadcastReceiver() {
-    override fun onReceive(
-        context: Context,
-        intent: Intent,
-    ) {
-        val notificationId = intent.getStringExtra(VoltraNotificationManager.EXTRA_NOTIFICATION_ID) ?: return
-        VoltraNotificationManager.markDismissed(context, notificationId)
-    }
-}

package/android/src/main/java/voltra/VoltraRN.kt

@@ -1,215 +0,0 @@
-package voltra
-
-import android.content.Context
-import android.view.View
-import android.view.ViewGroup
-import android.widget.FrameLayout
-import androidx.compose.ui.unit.DpSize
-import androidx.compose.ui.unit.dp
-import androidx.glance.appwidget.ExperimentalGlanceRemoteViewsApi
-import androidx.glance.appwidget.GlanceRemoteViews
-import expo.modules.kotlin.AppContext
-import expo.modules.kotlin.views.ExpoView
-import kotlinx.coroutines.*
-import voltra.glance.GlanceFactory
-import voltra.parsing.VoltraPayloadParser
-import kotlin.math.abs
-
-@OptIn(ExperimentalGlanceRemoteViewsApi::class)
-class VoltraRN(
-    context: Context,
-    appContext: AppContext,
-) : ExpoView(context, appContext) {
-    private var mainScope: CoroutineScope? = null
-    private val frameLayout = FrameLayout(context)
-    private var viewId: String? = null
-    private var payload: String? = null
-    private var updateJob: Job? = null
-
-    private var lastRenderedPayload: String? = null
-    private var lastRenderedWidthDp: Float = 0f
-    private var lastRenderedHeightDp: Float = 0f
-
-    init {
-        // Ensure FrameLayout takes full space
-        frameLayout.layoutParams =
-            FrameLayout.LayoutParams(
-                ViewGroup.LayoutParams.MATCH_PARENT,
-                ViewGroup.LayoutParams.MATCH_PARENT,
-            )
-        addView(frameLayout)
-    }
-
-    fun setViewId(id: String) {
-        if (this.viewId == id) return
-        this.viewId = id
-        updateView()
-    }
-
-    fun setPayload(payload: String) {
-        if (this.payload == payload) return
-        this.payload = payload
-        updateView()
-    }
-
-    private fun updateView() {
-        val payloadStr = payload ?: return
-        val id = viewId ?: return
-
-        val density = context.resources.displayMetrics.density
-        val widthDp = frameLayout.width.toFloat() / density
-        val heightDp = frameLayout.height.toFloat() / density
-
-        // Don't render until we have real dimensions from layout.
-        // onLayout() will call updateView() once dimensions are available.
-        if (widthDp <= 1f || heightDp <= 1f) return
-
-        // Avoid redundant updates if nothing significant changed and we already have a view
-        if (frameLayout.childCount > 0 &&
-            payloadStr == lastRenderedPayload &&
-            abs(widthDp - lastRenderedWidthDp) < 1.0f &&
-            abs(heightDp - lastRenderedHeightDp) < 1.0f
-        ) {
-            return
-        }
-
-        updateJob?.cancel()
-        updateJob =
-            mainScope?.launch {
-                try {
-                    // Parse payload on background thread
-                    val voltraPayload =
-                        withContext(Dispatchers.Default) {
-                            try {
-                                VoltraPayloadParser.parse(payloadStr)
-                            } catch (e: Exception) {
-                                null
-                            }
-                        } ?: return@launch
-
-                    val node =
-                        voltraPayload.collapsed
-                            ?: voltraPayload.expanded
-                            ?: voltraPayload.variants?.get("content")
-                            ?: voltraPayload.variants?.values?.firstOrNull()
-
-                    if (node == null) {
-                        frameLayout.removeAllViews()
-                        return@launch
-                    }
-
-                    val composeSize = DpSize(widthDp.dp, heightDp.dp)
-
-                    val glanceRemoteViews = GlanceRemoteViews()
-                    val factory = GlanceFactory(id, voltraPayload.e, voltraPayload.s, composeSize)
-
-                    val result =
-                        withContext(Dispatchers.Default) {
-                            glanceRemoteViews.compose(context, composeSize) {
-                                factory.Render(node)
-                            }
-                        }
-
-                    ensureActive()
-
-                    val remoteViews = result.remoteViews
-
-                    // Check if the frameLayout dimensions have changed since we started composing.
-                    // If so, skip this render — a new updateView() will be triggered by onLayout.
-                    val currentWidthDp = frameLayout.width.toFloat() / density
-                    val currentHeightDp = frameLayout.height.toFloat() / density
-                    if (abs(currentWidthDp - widthDp) >= 1.0f || abs(currentHeightDp - heightDp) >= 1.0f) {
-                        return@launch
-                    }
-
-                    withContext(Dispatchers.Main) {
-                        try {
-                            // Try to reapply to the existing view first to avoid flickering/replacing.
-                            // IMPORTANT: Only use reapply for dimension-only changes (same payload).
-                            // When the payload changes, always do a fresh apply to prevent stale
-                            // style bleed (e.g. padding from a previous widget persisting because
-                            // the new widget's RemoteViews doesn't explicitly reset it to zero).
-                            var applied = false
-                            if (frameLayout.childCount > 0 && payloadStr == lastRenderedPayload) {
-                                try {
-                                    val existingView = frameLayout.getChildAt(0)
-                                    remoteViews.reapply(context, existingView)
-                                    applied = true
-                                } catch (e: Exception) {
-                                }
-                            }
-
-                            if (!applied) {
-                                // Inflate with parent to ensure correct LayoutParams, but don't attach yet
-                                val inflatedView = remoteViews.apply(context, frameLayout)
-
-                                // Add new view FIRST, then remove old ones to prevent flickering
-                                frameLayout.addView(inflatedView)
-
-                                val childCount = frameLayout.childCount
-                                if (childCount > 1) {
-                                    frameLayout.removeViews(0, childCount - 1)
-                                }
-                            }
-
-                            // Always re-measure and re-layout after applying RemoteViews.
-                            // This is critical because:
-                            // 1) After fresh inflate: the view was added asynchronously so the parent
-                            //    won't trigger layout automatically.
-                            // 2) After reapply: text content or styles may have changed, requiring
-                            //    re-measurement to avoid stale layout constraints (e.g. truncated text).
-                            frameLayout.measure(
-                                View.MeasureSpec.makeMeasureSpec(frameLayout.width, View.MeasureSpec.EXACTLY),
-                                View.MeasureSpec.makeMeasureSpec(frameLayout.height, View.MeasureSpec.EXACTLY),
-                            )
-                            frameLayout.layout(
-                                frameLayout.left,
-                                frameLayout.top,
-                                frameLayout.right,
-                                frameLayout.bottom,
-                            )
-
-                            // Update tracking state
-                            lastRenderedPayload = payloadStr
-                            lastRenderedWidthDp = widthDp
-                            lastRenderedHeightDp = heightDp
-                        } catch (e: Exception) {
-                        }
-                    }
-                } catch (e: CancellationException) {
-                } catch (e: Exception) {
-                }
-            }
-    }
-
-    override fun onLayout(
-        changed: Boolean,
-        left: Int,
-        top: Int,
-        right: Int,
-        bottom: Int,
-    ) {
-        super.onLayout(changed, left, top, right, bottom)
-        if (changed) {
-            val w = right - left
-            val h = bottom - top
-            // Only trigger update if we actually have a size now
-            if (w > 0 && h > 0) {
-                updateView()
-            }
-        }
-    }
-
-    override fun onAttachedToWindow() {
-        super.onAttachedToWindow()
-        mainScope = CoroutineScope(Dispatchers.Main + SupervisorJob())
-        updateView()
-    }
-
-    override fun onDetachedFromWindow() {
-        super.onDetachedFromWindow()
-        updateJob?.cancel()
-        mainScope?.cancel()
-        mainScope = null
-    }
-}

package/android/src/main/java/voltra/events/VoltraEvent.kt

@@ -1,25 +0,0 @@
-package voltra.events
-
-/**
- * Represents a Voltra event that can be sent from widgets to the React Native app.
- * Events are persisted to SharedPreferences to survive app process death.
- */
-sealed class VoltraEvent {
-    abstract val type: String
-    abstract val timestamp: Long
-
-    /**
-     * Convert event to a map for React Native bridge.
-     */
-    abstract fun toMap(): Map<String, Any?>
-
-    companion object {
-        /**
-         * Parse event from persisted map data.
-         */
-        fun fromMap(map: Map<String, Any?>): VoltraEvent? {
-            // No events supported currently
-            return null
-        }
-    }
-}

package/android/src/main/java/voltra/events/VoltraEventBus.kt

@@ -1,198 +0,0 @@
-package voltra.events
-
-import android.content.BroadcastReceiver
-import android.content.Context
-import android.content.Intent
-import android.content.IntentFilter
-import android.util.Log
-import org.json.JSONArray
-import org.json.JSONObject
-
-/**
- * A centralized event bus that manages Voltra events from widgets to the React Native app.
- *
- * Event delivery uses a dual-path approach:
- * - Persistent: Events are written to SharedPreferences (survives app death)
- * - Hot: Events are broadcast via LocalBroadcastManager (immediate delivery when app is running)
- *
- * This mirrors the iOS implementation using UserDefaults + NotificationCenter.
- */
-class VoltraEventBus private constructor(
-    private val context: Context,
-) {
-    companion object {
-        private const val TAG = "VoltraEventBus"
-        private const val PREFS_NAME = "voltra_event_queue"
-        private const val KEY_EVENTS = "events"
-        private const val ACTION_VOLTRA_EVENT = "voltra.event.interaction"
-
-        @Volatile
-        private var instance: VoltraEventBus? = null
-
-        fun getInstance(context: Context): VoltraEventBus =
-            instance ?: synchronized(this) {
-                instance ?: VoltraEventBus(context.applicationContext).also { instance = it }
-            }
-    }
-
-    private val prefs = context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
-    private val lock = Any()
-
-    /**
-     * Send an event. Uses dual-path delivery:
-     * 1. Persist to SharedPreferences (survives app death)
-     * 2. Broadcast via Intent (hot delivery when app is running)
-     */
-    fun send(event: VoltraEvent) {
-        Log.d(
-            TAG,
-            "Sending event: ${event.type}",
-        )
-
-        // 1. Persist to SharedPreferences
-        persistEvent(event)
-
-        // 2. Broadcast for hot delivery (best-effort)
-        try {
-            val intent =
-                Intent(ACTION_VOLTRA_EVENT).apply {
-                    // Explicitly set package to ensure broadcast is delivered to our receiver
-                    // This is required for RECEIVER_NOT_EXPORTED on Android 13+
-                    setPackage(context.packageName)
-                    putExtra("eventType", event.type)
-                    event.toMap().forEach { (key, value) ->
-                        when (value) {
-                            is String -> putExtra(key, value)
-                            is Long -> putExtra(key, value)
-                            is Int -> putExtra(key, value)
-                            is Boolean -> putExtra(key, value)
-                            is Double -> putExtra(key, value)
-                            null -> putExtra(key, "")
-                        }
-                    }
-                }
-            context.sendBroadcast(intent)
-            Log.d(TAG, "Broadcast sent for event: ${event.type}")
-        } catch (e: Exception) {
-            Log.w(TAG, "Failed to broadcast event (app may not be running): ${e.message}")
-        }
-    }
-
-    /**
-     * Get all persisted events and clear the queue.
-     * Called when the React Native app starts to replay missed events.
-     */
-    fun popAll(): List<VoltraEvent> {
-        synchronized(lock) {
-            val events = readPersistedEvents()
-            if (events.isNotEmpty()) {
-                prefs.edit().remove(KEY_EVENTS).apply()
-                Log.d(TAG, "Popped ${events.size} persisted events")
-            }
-            return events
-        }
-    }
-
-    /**
-     * Get all persisted events without clearing the queue.
-     */
-    fun peekAll(): List<VoltraEvent> {
-        synchronized(lock) {
-            return readPersistedEvents()
-        }
-    }
-
-    /**
-     * Clear all persisted events.
-     */
-    fun clearAll() {
-        synchronized(lock) {
-            prefs.edit().remove(KEY_EVENTS).apply()
-            Log.d(TAG, "Cleared all persisted events")
-        }
-    }
-
-    private fun persistEvent(event: VoltraEvent) {
-        synchronized(lock) {
-            try {
-                val events = readPersistedEvents().toMutableList()
-                events.add(event)
-
-                // Convert to JSON array
-                val jsonArray = JSONArray()
-                events.forEach { evt ->
-                    val jsonObject = JSONObject(evt.toMap())
-                    jsonArray.put(jsonObject)
-                }
-
-                prefs.edit().putString(KEY_EVENTS, jsonArray.toString()).apply()
-                Log.d(TAG, "Persisted event: ${event.type}, total in queue: ${events.size}")
-            } catch (e: Exception) {
-                Log.e(TAG, "Failed to persist event: ${e.message}", e)
-            }
-        }
-    }
-
-    private fun readPersistedEvents(): List<VoltraEvent> {
-        return try {
-            val jsonString = prefs.getString(KEY_EVENTS, null) ?: return emptyList()
-            val jsonArray = JSONArray(jsonString)
-
-            val events = mutableListOf<VoltraEvent>()
-            for (i in 0 until jsonArray.length()) {
-                val jsonObject = jsonArray.getJSONObject(i)
-                val map =
-                    jsonObject.keys().asSequence().associateWith { key ->
-                        jsonObject.get(key)
-                    }
-
-                VoltraEvent.fromMap(map)?.let { events.add(it) }
-            }
-
-            events
-        } catch (e: Exception) {
-            Log.e(TAG, "Failed to read persisted events: ${e.message}", e)
-            emptyList()
-        }
-    }
-
-    /**
-     * Register a listener for hot event delivery.
-     * Returns a function to unregister the listener.
-     */
-    fun addListener(listener: (VoltraEvent) -> Unit): () -> Unit {
-        val receiver =
-            object : BroadcastReceiver() {
-                override fun onReceive(
-                    context: Context?,
-                    intent: Intent?,
-                ) {
-                    if (intent == null) return
-
-                    try {
-                        val eventType = intent.getStringExtra("eventType") ?: return
-                        val eventMap = mutableMapOf<String, Any?>()
-
-                        intent.extras?.keySet()?.forEach { key ->
-                            eventMap[key] = intent.extras?.get(key)
-                        }
-
-                        VoltraEvent.fromMap(eventMap)?.let { listener(it) }
-                    } catch (e: Exception) {
-                        Log.e(TAG, "Error processing broadcast: ${e.message}", e)
-                    }
-                }
-            }
-
-        val filter = IntentFilter(ACTION_VOLTRA_EVENT)
-        context.registerReceiver(receiver, filter, Context.RECEIVER_NOT_EXPORTED)
-
-        return {
-            try {
-                context.unregisterReceiver(receiver)
-            } catch (e: Exception) {
-                Log.w(TAG, "Failed to unregister receiver: ${e.message}")
-            }
-        }
-    }
-}

package/android/src/main/java/voltra/generated/ShortNames.kt

@@ -1,183 +0,0 @@
-//
-//  ShortNames.kt
-//
-//  AUTO-GENERATED from data/components.json
-//  DO NOT EDIT MANUALLY - Changes will be overwritten
-//  Schema version: 1.0.0
-
-package voltra.generated
-
-/**
- * Unified short name mappings for props and style properties
- * Used to expand compressed payload keys back to their full names
- */
-object ShortNames {
-    /** Mapping from short names to full names */
-    private val shortToName: Map<String, String> =
-        mapOf(
-            "ap" to "absolutePosition",
-            "ai" to "alignItems",
-            "al" to "alignment",
-            "as" to "alignSelf",
-            "ar" to "aspectRatio",
-            "an" to "assetName",
-            "bkg" to "background",
-            "bg" to "backgroundColor",
-            "bgs" to "backgroundStyle",
-            "b64" to "base64",
-            "bd" to "border",
-            "bc" to "borderColor",
-            "br" to "borderRadius",
-            "bw" to "borderWidth",
-            "b" to "bottom",
-            "bs" to "buttonStyle",
-            "csa" to "chartScrollableAxes",
-            "chk" to "checked",
-            "clip" to "clipped",
-            "c" to "color",
-            "cls" to "colors",
-            "ca" to "contentAlignment",
-            "cc" to "contentColor",
-            "cdesc" to "contentDescription",
-            "cr" to "cornerRadius",
-            "cd" to "countDown",
-            "cvl" to "currentValueLabel",
-            "dlu" to "deepLinkUrl",
-            "dv" to "defaultValue",
-            "dest" to "destination",
-            "dir" to "direction",
-            "dth" to "dither",
-            "dur" to "durationMs",
-            "en" to "enabled",
-            "end" to "endAtMs",
-            "ep" to "endPoint",
-            "flb" to "fallback",
-            "fmh" to "fillMaxHeight",
-            "fmw" to "fillMaxWidth",
-            "fsh" to "fixedSizeHorizontal",
-            "fsv" to "fixedSizeVertical",
-            "fl" to "flex",
-            "fb" to "flexBasis",
-            "fdir" to "flexDirection",
-            "fg" to "flexGrow",
-            "fgw" to "flexGrowWidth",
-            "fk" to "flexShrink",
-            "fnt" to "font",
-            "ff" to "fontFamily",
-            "fs" to "fontSize",
-            "fvar" to "fontVariant",
-            "fw" to "fontWeight",
-            "fgs" to "foregroundStyle",
-            "fss" to "foregroundStyleScale",
-            "f" to "frame",
-            "g" to "gap",
-            "gs" to "gaugeStyle",
-            "ge" to "glassEffect",
-            "h" to "height",
-            "halig" to "horizontalAlignment",
-            "hp" to "horizontalPadding",
-            "ic" to "icon",
-            "id" to "id",
-            "it" to "italic",
-            "jc" to "justifyContent",
-            "kern" to "kerning",
-            "lbl" to "label",
-            "ly" to "layout",
-            "lp" to "layoutPriority",
-            "l" to "left",
-            "lgv" to "legendVisibility",
-            "ls" to "letterSpacing",
-            "lh" to "lineHeight",
-            "ll" to "lineLimit",
-            "lsp" to "lineSpacing",
-            "lw" to "lineWidth",
-            "m" to "margin",
-            "mb" to "marginBottom",
-            "mh" to "marginHorizontal",
-            "ml" to "marginLeft",
-            "mr" to "marginRight",
-            "mt" to "marginTop",
-            "mv" to "marginVertical",
-            "mrk" to "marks",
-            "me" to "maskElement",
-            "maxh" to "maxHeight",
-            "max" to "maximumValue",
-            "maxl" to "maximumValueLabel",
-            "mxl" to "maxLines",
-            "maxw" to "maxWidth",
-            "minh" to "minHeight",
-            "min" to "minimumValue",
-            "minvl" to "minimumValueLabel",
-            "minl" to "minLength",
-            "minw" to "minWidth",
-            "md" to "monospacedDigit",
-            "mta" to "multilineTextAlignment",
-            "n" to "name",
-            "nol" to "numberOfLines",
-            "off" to "offset",
-            "ox" to "offsetX",
-            "oy" to "offsetY",
-            "op" to "opacity",
-            "ov" to "overflow",
-            "pad" to "padding",
-            "pb" to "paddingBottom",
-            "ph" to "paddingHorizontal",
-            "pl" to "paddingLeft",
-            "pr" to "paddingRight",
-            "pt" to "paddingTop",
-            "pv" to "paddingVertical",
-            "pos" to "position",
-            "pc" to "progressColor",
-            "rm" to "resizeMode",
-            "r" to "right",
-            "re" to "rotationEffect",
-            "sc" to "scale",
-            "sce" to "scaleEffect",
-            "sh" to "shadow",
-            "shc" to "shadowColor",
-            "sho" to "shadowOffset",
-            "shop" to "shadowOpacity",
-            "shr" to "shadowRadius",
-            "shrs" to "showHours",
-            "sz" to "size",
-            "smc" to "smallCaps",
-            "src" to "source",
-            "sp" to "spacing",
-            "start" to "startAtMs",
-            "stp" to "startPoint",
-            "sts" to "stops",
-            "st" to "strikethrough",
-            "s" to "style",
-            "si" to "systemImage",
-            "txt" to "text",
-            "ta" to "textAlign",
-            "tdl" to "textDecorationLine",
-            "ts" to "textStyle",
-            "tt" to "textTemplates",
-            "th" to "thumb",
-            "tnt" to "tint",
-            "tc" to "tintColor",
-            "ttl" to "title",
-            "t" to "top",
-            "trc" to "trackColor",
-            "tf" to "transform",
-            "typ" to "type",
-            "ul" to "underline",
-            "v" to "value",
-            "valig" to "verticalAlignment",
-            "wt" to "weight",
-            "w" to "width",
-            "xgs" to "xAxisGridStyle",
-            "xav" to "xAxisVisibility",
-            "ygs" to "yAxisGridStyle",
-            "yav" to "yAxisVisibility",
-            "zi" to "zIndex",
-        )
-
-    /**
-     * Expand a short name to its full form
-     * @param short The short name (e.g., "bg", "al", "sp")
-     * @return The full name (e.g., "backgroundColor", "alignment", "spacing"), or the input if no mapping exists
-     */
-    fun expand(short: String): String = shortToName[short] ?: short
-}

package/android/src/main/java/voltra/glance/GlanceFactory.kt

@@ -1,22 +0,0 @@
-package voltra.glance
-
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.CompositionLocalProvider
-import androidx.compose.ui.unit.DpSize
-import voltra.glance.renderers.RenderNode
-import voltra.models.VoltraNode
-
-class GlanceFactory(
-    private val widgetId: String,
-    private val sharedElements: List<VoltraNode>? = null,
-    private val sharedStyles: List<Map<String, Any?>>? = null,
-    private val widgetSize: DpSize? = null,
-) {
-    @Composable
-    fun Render(node: VoltraNode?) {
-        val context = VoltraRenderContext(widgetId, sharedElements, sharedStyles, widgetSize)
-        CompositionLocalProvider(LocalVoltraRenderContext provides context) {
-            RenderNode(node)
-        }
-    }
-}