voltra 1.4.0 → 2.0.0-rc.3

package/android/src/main/java/voltra/glance/renderers/RenderCommon.kt

@@ -1,198 +0,0 @@
-package voltra.glance.renderers
-
-import android.content.Context
-import android.content.Intent
-import android.graphics.BitmapFactory
-import android.graphics.drawable.Icon
-import android.net.Uri
-import androidx.compose.runtime.Composable
-import androidx.glance.GlanceModifier
-import androidx.glance.ImageProvider
-import androidx.glance.LocalContext
-import androidx.glance.action.Action
-import androidx.glance.appwidget.action.actionStartActivity
-import androidx.glance.layout.ContentScale
-import voltra.glance.LocalVoltraRenderContext
-import voltra.images.VoltraImageManager
-import voltra.models.VoltraElement
-import voltra.models.VoltraNode
-import voltra.payload.ComponentTypeID
-import voltra.styling.CompositeStyle
-
-fun getOnClickAction(
-    context: Context,
-    props: Map<String, Any?>?,
-    widgetId: String,
-    componentId: String,
-): Action {
-    val deepLinkUrl = props?.get("deepLinkUrl") as? String
-
-    if (deepLinkUrl != null && deepLinkUrl.isNotEmpty()) {
-        val intent = Intent(Intent.ACTION_VIEW, Uri.parse(deepLinkUrl))
-        intent.setPackage(context.packageName)
-        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
-        return actionStartActivity(intent)
-    }
-
-    // Fallback: Start main activity
-    val launchIntent = context.packageManager.getLaunchIntentForPackage(context.packageName)
-    if (launchIntent != null) {
-        // Add extras so the app knows what was clicked
-        launchIntent.putExtra("widgetId", widgetId)
-        launchIntent.putExtra("componentId", componentId)
-        launchIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
-        return actionStartActivity(launchIntent)
-    }
-
-    return actionStartActivity(Intent())
-}
-
-fun parseContentScale(value: String?): ContentScale =
-    when (value) {
-        "crop", "cover" -> ContentScale.Crop
-        "fit", "contain" -> ContentScale.Fit
-        "fill-bounds", "stretch" -> ContentScale.FillBounds
-        else -> ContentScale.Fit
-    }
-
-@Composable
-fun extractImageProvider(sourceProp: Any?): ImageProvider? {
-    if (sourceProp == null) return null
-
-    val context = LocalContext.current
-    val source = parseEncodedImageSource(sourceProp) ?: return null
-
-    val assetName = source.assetName
-    val base64 = source.base64
-
-    if (assetName != null) {
-        // Try as drawable resource first
-        val resId = context.resources.getIdentifier(assetName, "drawable", context.packageName)
-        if (resId != 0) return ImageProvider(resId)
-
-        // Try as preloaded asset
-        val imageManager = VoltraImageManager(context)
-        val uriString = imageManager.getUriForKey(assetName)
-        if (uriString != null) {
-            try {
-                val uri = Uri.parse(uriString)
-                context.contentResolver.openInputStream(uri)?.use { stream ->
-                    val bitmap = BitmapFactory.decodeStream(stream)
-                    return ImageProvider(Icon.createWithBitmap(bitmap))
-                }
-            } catch (e: Exception) {
-                android.util.Log.e("RenderCommon", "Failed to decode preloaded image: $assetName", e)
-            }
-        }
-    }
-
-    if (base64 != null) {
-        try {
-            val decodedString = android.util.Base64.decode(base64, android.util.Base64.DEFAULT)
-            val bitmap = BitmapFactory.decodeByteArray(decodedString, 0, decodedString.size)
-            if (bitmap != null) {
-                return ImageProvider(Icon.createWithBitmap(bitmap))
-            }
-        } catch (e: Exception) {
-            android.util.Log.e("RenderCommon", "Failed to decode base64 image", e)
-        }
-    }
-
-    return null
-}
-
-/**
- * Main dispatcher for rendering any VoltraNode.
- * Handles Element, Array, Ref, Text, and null cases.
- * Children rendering is delegated to RenderNode - each component doesn't need to care about node types.
- */
-@Composable
-fun RenderNode(node: VoltraNode?) {
-    val context = LocalVoltraRenderContext.current
-
-    when (node) {
-        is VoltraNode.Element -> {
-            RenderElement(node.element)
-        }
-
-        is VoltraNode.Array -> {
-            node.elements.forEach { RenderNode(it) }
-        }
-
-        is VoltraNode.Ref -> {
-            val resolved = context.sharedElements?.getOrNull(node.ref)
-            RenderNode(resolved)
-        }
-
-        is VoltraNode.Text -> {
-            androidx.glance.text.Text(node.text)
-        }
-
-        null -> { /* Empty */ }
-    }
-}
-
-/**
- * Router that dispatches to specific component renderers based on element type.
- */
-@Composable
-private fun RenderElement(element: VoltraElement) {
-    when (element.t) {
-        ComponentTypeID.TEXT -> RenderText(element)
-        ComponentTypeID.COLUMN -> RenderColumn(element)
-        ComponentTypeID.ROW -> RenderRow(element)
-        ComponentTypeID.BOX -> RenderBox(element)
-        ComponentTypeID.SPACER -> RenderSpacer(element)
-        ComponentTypeID.IMAGE -> RenderImage(element)
-        ComponentTypeID.BUTTON -> RenderButton(element)
-        ComponentTypeID.LINEAR_PROGRESS_INDICATOR -> RenderLinearProgress(element)
-        ComponentTypeID.CIRCULAR_PROGRESS_INDICATOR -> RenderCircularProgress(element)
-        ComponentTypeID.SWITCH -> RenderSwitch(element)
-        ComponentTypeID.RADIO_BUTTON -> RenderRadioButton(element)
-        ComponentTypeID.CHECK_BOX -> RenderCheckBox(element)
-        ComponentTypeID.FILLED_BUTTON -> RenderFilledButton(element)
-        ComponentTypeID.OUTLINE_BUTTON -> RenderOutlineButton(element)
-        ComponentTypeID.CIRCLE_ICON_BUTTON -> RenderCircleIconButton(element)
-        ComponentTypeID.SQUARE_ICON_BUTTON -> RenderSquareIconButton(element)
-        ComponentTypeID.TITLE_BAR -> RenderTitleBar(element)
-        ComponentTypeID.SCAFFOLD -> RenderScaffold(element)
-        ComponentTypeID.LAZY_COLUMN -> RenderLazyColumn(element)
-        ComponentTypeID.LAZY_VERTICAL_GRID -> RenderLazyVerticalGrid(element)
-        ComponentTypeID.CHART -> RenderChart(element)
-    }
-}
-
-/**
- * Used when an element with a pre-computed modifier needs to be rendered.
- * This is used when we need to apply weight separately from other styles (in scopes).
- */
-@Composable
-fun RenderElementWithModifier(
-    element: VoltraElement,
-    modifier: GlanceModifier,
-    compositeStyle: CompositeStyle?,
-) {
-    when (element.t) {
-        ComponentTypeID.TEXT -> RenderText(element, modifier, compositeStyle)
-        ComponentTypeID.COLUMN -> RenderColumn(element, modifier)
-        ComponentTypeID.ROW -> RenderRow(element, modifier)
-        ComponentTypeID.BOX -> RenderBox(element, modifier)
-        ComponentTypeID.SPACER -> RenderSpacer(element, modifier)
-        ComponentTypeID.IMAGE -> RenderImage(element, modifier)
-        ComponentTypeID.BUTTON -> RenderButton(element, modifier)
-        ComponentTypeID.LINEAR_PROGRESS_INDICATOR -> RenderLinearProgress(element, modifier)
-        ComponentTypeID.CIRCULAR_PROGRESS_INDICATOR -> RenderCircularProgress(element, modifier)
-        ComponentTypeID.SWITCH -> RenderSwitch(element, modifier)
-        ComponentTypeID.RADIO_BUTTON -> RenderRadioButton(element, modifier)
-        ComponentTypeID.CHECK_BOX -> RenderCheckBox(element, modifier)
-        ComponentTypeID.FILLED_BUTTON -> RenderFilledButton(element, modifier)
-        ComponentTypeID.OUTLINE_BUTTON -> RenderOutlineButton(element, modifier)
-        ComponentTypeID.CIRCLE_ICON_BUTTON -> RenderCircleIconButton(element, modifier)
-        ComponentTypeID.SQUARE_ICON_BUTTON -> RenderSquareIconButton(element, modifier)
-        ComponentTypeID.TITLE_BAR -> RenderTitleBar(element, modifier)
-        ComponentTypeID.SCAFFOLD -> RenderScaffold(element, modifier)
-        ComponentTypeID.LAZY_COLUMN -> RenderLazyColumn(element, modifier)
-        ComponentTypeID.LAZY_VERTICAL_GRID -> RenderLazyVerticalGrid(element, modifier)
-        ComponentTypeID.CHART -> RenderChart(element, modifier)
-    }
-}

package/android/src/main/java/voltra/glance/renderers/RendererJson.kt

@@ -1,128 +0,0 @@
-package voltra.glance.renderers
-
-import android.util.Log
-import kotlinx.serialization.ExperimentalSerializationApi
-import kotlinx.serialization.Serializable
-import kotlinx.serialization.SerializationException
-import kotlinx.serialization.builtins.ListSerializer
-import kotlinx.serialization.builtins.serializer
-import kotlinx.serialization.decodeFromString
-import kotlinx.serialization.json.Json
-import kotlinx.serialization.json.JsonArray
-import kotlinx.serialization.json.JsonObject
-import voltra.parsing.toDynamicObject
-import voltra.parsing.toDynamicValue
-
-private const val TAG = "RendererJson"
-
-@OptIn(ExperimentalSerializationApi::class)
-internal val rendererJson: Json =
-    Json {
-        ignoreUnknownKeys = true
-        explicitNulls = false
-    }
-
-@Serializable
-internal data class EncodedImageSource(
-    val assetName: String? = null,
-    val base64: String? = null,
-)
-
-internal fun parseImageSourceMap(sourceProp: Any?): Map<String, Any?>? =
-    when (sourceProp) {
-        null -> {
-            null
-        }
-
-        is Map<*, *> -> {
-            @Suppress("UNCHECKED_CAST")
-            sourceProp as? Map<String, Any?>
-        }
-
-        is String -> {
-            parseRendererJsonObject(sourceProp, "image source JSON")
-        }
-
-        else -> {
-            null
-        }
-    }
-
-internal fun parseEncodedImageSource(sourceProp: Any?): EncodedImageSource? {
-    return when (sourceProp) {
-        null -> {
-            null
-        }
-
-        is Map<*, *> -> {
-            val map = parseImageSourceMap(sourceProp) ?: return null
-            EncodedImageSource(
-                assetName = map["assetName"] as? String,
-                base64 = map["base64"] as? String,
-            )
-        }
-
-        is String -> {
-            try {
-                rendererJson.decodeFromString<EncodedImageSource>(sourceProp)
-            } catch (error: Exception) {
-                warn("Failed to parse image source JSON: $sourceProp", error)
-                null
-            }
-        }
-
-        else -> {
-            null
-        }
-    }
-}
-
-internal fun parseForegroundStyleScaleEntries(json: String?): List<List<String>>? {
-    if (json.isNullOrEmpty()) return null
-    return try {
-        rendererJson.decodeFromString(ListSerializer(ListSerializer(String.serializer())), json)
-    } catch (error: Exception) {
-        warn("Failed to parse foregroundStyleScale", error)
-        null
-    }
-}
-
-internal fun parseMarksTuples(marksJson: String): List<List<Any?>> {
-    return try {
-        val element = rendererJson.parseToJsonElement(marksJson)
-        val array = element as? JsonArray ?: return emptyList()
-        array.mapNotNull { tupleElement ->
-            val tupleArray = tupleElement as? JsonArray ?: return@mapNotNull null
-            tupleArray.map { it.toDynamicValue() }
-        }
-    } catch (error: Exception) {
-        warn("Failed to parse marks JSON", error)
-        emptyList()
-    }
-}
-
-internal fun parseRendererJsonObject(
-    json: String,
-    label: String,
-): Map<String, Any?>? =
-    try {
-        val element = rendererJson.parseToJsonElement(json)
-        val jsonObject =
-            element as? JsonObject
-                ?: throw SerializationException("Expected JSON object for $label")
-        jsonObject.toDynamicObject()
-    } catch (error: Exception) {
-        warn("Failed to parse $label", error)
-        null
-    }
-
-private fun warn(
-    message: String,
-    error: Throwable,
-) {
-    try {
-        Log.w(TAG, message, error)
-    } catch (_: RuntimeException) {
-        // Local unit tests may not provide android.util.Log.
-    }
-}

package/android/src/main/java/voltra/glance/renderers/TextAndImageRenderers.kt

@@ -1,177 +0,0 @@
-package voltra.glance.renderers
-
-import android.graphics.drawable.Icon
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.unit.dp
-import androidx.glance.GlanceModifier
-import androidx.glance.Image
-import androidx.glance.ImageProvider
-import androidx.glance.LocalContext
-import androidx.glance.background
-import androidx.glance.layout.ContentScale
-import androidx.glance.layout.height
-import androidx.glance.layout.width
-import androidx.glance.text.Text
-import androidx.glance.unit.ColorProvider
-import voltra.glance.LocalVoltraRenderContext
-import voltra.glance.applyClickableIfNeeded
-import voltra.glance.resolveAndApplyStyle
-import voltra.models.VoltraElement
-import voltra.models.VoltraNode
-import voltra.models.componentProp
-import voltra.styling.JSColorParser
-import voltra.styling.VoltraColorValue
-import voltra.styling.resolveColor
-import voltra.styling.toColorProvider
-import voltra.styling.toGlanceTextStyle
-
-@Composable
-fun RenderText(
-    element: VoltraElement,
-    modifier: GlanceModifier? = null,
-    compositeStyle: voltra.styling.CompositeStyle? = null,
-) {
-    val renderContext = LocalVoltraRenderContext.current
-    val baseModifier = modifier ?: resolveAndApplyStyle(element.p, renderContext.sharedStyles).modifier
-    val finalModifier =
-        applyClickableIfNeeded(
-            baseModifier,
-            element.p,
-            element.i,
-            renderContext.widgetId,
-            element.t,
-            element.hashCode(),
-        )
-
-    val resolvedStyle =
-        if (compositeStyle != null) {
-            compositeStyle
-        } else {
-            resolveAndApplyStyle(element.p, renderContext.sharedStyles).compositeStyle
-        }
-
-    val text = extractTextFromNode(element.c)
-    val renderAsBitmap = element.p?.get("renderAsBitmap") as? Boolean ?: false
-    val textStyle = resolvedStyle?.text ?: voltra.styling.TextStyle.Default
-
-    if (renderAsBitmap && textStyle.fontFamily != null) {
-        val context = LocalContext.current
-        val density = context.resources.displayMetrics.density
-        val isBold =
-            textStyle.fontWeight?.let {
-                it == androidx.glance.text.FontWeight.Bold
-            } ?: false
-        val typeface = loadTypeface(context, textStyle.fontFamily, isBold)
-
-        if (typeface != null) {
-            val bitmapTextStyle =
-                textStyle.copy(
-                    color = textStyle.color?.let { VoltraColorValue.Static(it.resolveColor(context)) },
-                )
-            // Use screen width as max constraint
-            val maxWidthPx = (context.resources.displayMetrics.widthPixels * 0.9f).toInt()
-            val bitmap =
-                renderTextBitmap(
-                    context = context,
-                    text = text,
-                    textStyle = bitmapTextStyle,
-                    typeface = typeface,
-                    maxWidthPx = maxWidthPx,
-                )
-            val icon = Icon.createWithBitmap(bitmap)
-            val widthDp = (bitmap.width / density).toInt()
-            val heightDp = (bitmap.height / density).toInt()
-            Image(
-                provider = ImageProvider(icon),
-                contentDescription = text,
-                contentScale = ContentScale.Fit,
-                modifier =
-                    finalModifier
-                        .width(widthDp.dp)
-                        .height(heightDp.dp),
-            )
-            return
-        }
-    }
-
-    val glanceTextStyle = textStyle.toGlanceTextStyle()
-    Text(text = text, modifier = finalModifier, style = glanceTextStyle)
-}
-
-@Composable
-fun RenderImage(
-    element: VoltraElement,
-    modifier: GlanceModifier? = null,
-) {
-    val renderContext = LocalVoltraRenderContext.current
-    val baseModifier = modifier ?: resolveAndApplyStyle(element.p, renderContext.sharedStyles).modifier
-    val finalModifier =
-        applyClickableIfNeeded(
-            baseModifier,
-            element.p,
-            element.i,
-            renderContext.widgetId,
-            element.t,
-            element.hashCode(),
-        )
-
-    val contentDescription = element.p?.get("contentDescription") as? String
-    val contentScale =
-        parseContentScale(
-            (element.p?.get("contentScale") as? String) ?: (element.p?.get("resizeMode") as? String),
-        )
-    val alpha = (element.p?.get("alpha") as? Number)?.toFloat() ?: 1.0f
-
-    val tintColorString = element.p?.get("tintColor") as? String
-    val colorFilter =
-        if (tintColorString != null) {
-            voltra.styling.JSColorParser.parse(tintColorString)?.let {
-                androidx.glance.ColorFilter.tint(it.toColorProvider())
-            }
-        } else {
-            null
-        }
-
-    val imageProvider = extractImageProvider(element.p?.get("source"))
-
-    if (imageProvider != null) {
-        Image(
-            provider = imageProvider,
-            contentDescription = contentDescription,
-            modifier = finalModifier,
-            contentScale = contentScale,
-            colorFilter = colorFilter,
-            alpha = alpha,
-        )
-    } else {
-        val fallbackNode =
-            element.componentProp(
-                "fallback",
-                renderContext.sharedStyles,
-                renderContext.sharedElements,
-            )
-
-        if (fallbackNode != null) {
-            androidx.glance.layout.Box(modifier = finalModifier) {
-                RenderNode(fallbackNode)
-            }
-        } else {
-            androidx.glance.layout.Box(modifier = finalModifier) {}
-        }
-    }
-}
-
-private fun extractTextFromNode(node: VoltraNode?): String =
-    when (node) {
-        is VoltraNode.Text -> {
-            node.text
-        }
-
-        is VoltraNode.Array -> {
-            node.elements.filterIsInstance<VoltraNode.Text>().joinToString("") { it.text }
-        }
-
-        else -> {
-            ""
-        }
-    }

package/android/src/main/java/voltra/glance/renderers/TextBitmapRenderer.kt

@@ -1,137 +0,0 @@
-package voltra.glance.renderers
-
-import android.content.Context
-import android.graphics.Bitmap
-import android.graphics.Canvas
-import android.graphics.Paint
-import android.graphics.Typeface
-import android.text.Layout
-import android.text.StaticLayout
-import android.text.TextPaint
-import android.util.Log
-import android.util.LruCache
-import androidx.compose.ui.graphics.toArgb
-import voltra.styling.TextAlignment
-import voltra.styling.TextDecoration
-import voltra.styling.TextStyle
-import voltra.styling.VoltraColorValue
-
-private const val TAG = "TextBitmapRenderer"
-
-/** Cache loaded typefaces to avoid repeated asset reads. */
-private val typefaceCache = LruCache<String, Typeface>(10)
-
-/**
- * Attempt to load a custom [Typeface] by family name.
- *
- * Tries in order:
- * 1. `fonts/<family>.ttf` in app assets
- * 2. `fonts/<family>.otf` in app assets
- * 3. `Typeface.create(family, …)` which resolves system-installed fonts
- *
- * Returns null if nothing could be resolved.
- */
-fun loadTypeface(
-    context: Context,
-    family: String,
-    bold: Boolean = false,
-): Typeface? {
-    val cacheKey = "$family-$bold"
-    typefaceCache.get(cacheKey)?.let { return it }
-
-    val baseStyle = if (bold) Typeface.BOLD else Typeface.NORMAL
-
-    val candidates =
-        listOf(
-            "fonts/$family.ttf",
-            "fonts/$family.otf",
-        )
-
-    for (path in candidates) {
-        try {
-            val tf = Typeface.createFromAsset(context.assets, path)
-            if (tf != null) {
-                val styled = if (bold) Typeface.create(tf, baseStyle) else tf
-                typefaceCache.put(cacheKey, styled)
-                return styled
-            }
-        } catch (_: Exception) {
-            // Asset not found, try next
-        }
-    }
-
-    // Fallback: try system font by name
-    return try {
-        val tf = Typeface.create(family, baseStyle)
-        typefaceCache.put(cacheKey, tf)
-        tf
-    } catch (_: Exception) {
-        null
-    }
-}
-
-/**
- * Render text into a [Bitmap] using Android Canvas with a custom [Typeface].
- * Supports color, font size, weight, alignment, line limit, decoration, and letter spacing.
- */
-fun renderTextBitmap(
-    context: Context,
-    text: String,
-    textStyle: TextStyle,
-    typeface: Typeface,
-    maxWidthPx: Int,
-): Bitmap {
-    val density = context.resources.displayMetrics.density
-    val fontSizePx = textStyle.fontSize.value * density
-
-    val paint =
-        TextPaint(Paint.ANTI_ALIAS_FLAG).apply {
-            this.typeface = typeface
-            this.textSize = fontSizePx
-            if (textStyle.color is VoltraColorValue.Static) {
-                this.color = textStyle.color.color.toArgb()
-            }
-            if (textStyle.letterSpacing.value > 0) {
-                this.letterSpacing = textStyle.letterSpacing.value / textStyle.fontSize.value
-            }
-            if (textStyle.decoration == TextDecoration.UNDERLINE ||
-                textStyle.decoration == TextDecoration.UNDERLINE_LINE_THROUGH
-            ) {
-                this.isUnderlineText = true
-            }
-            if (textStyle.decoration == TextDecoration.LINE_THROUGH ||
-                textStyle.decoration == TextDecoration.UNDERLINE_LINE_THROUGH
-            ) {
-                this.isStrikeThruText = true
-            }
-        }
-
-    val layoutAlignment =
-        when (textStyle.alignment) {
-            TextAlignment.CENTER -> Layout.Alignment.ALIGN_CENTER
-            TextAlignment.END -> Layout.Alignment.ALIGN_OPPOSITE
-            TextAlignment.START -> Layout.Alignment.ALIGN_NORMAL
-        }
-
-    val lineSpacingPx = textStyle.lineSpacing.value * density
-
-    val width = if (maxWidthPx > 0) maxWidthPx else (paint.measureText(text) + 1).toInt()
-
-    val layout =
-        StaticLayout.Builder
-            .obtain(text, 0, text.length, paint, width)
-            .setAlignment(layoutAlignment)
-            .setLineSpacing(lineSpacingPx, 1f)
-            .setMaxLines(textStyle.lineLimit ?: Int.MAX_VALUE)
-            .setIncludePad(false)
-            .build()
-
-    val bitmapWidth = width.coerceAtLeast(1)
-    val bitmapHeight = layout.height.coerceAtLeast(1)
-
-    val bitmap = Bitmap.createBitmap(bitmapWidth, bitmapHeight, Bitmap.Config.ARGB_8888)
-    val canvas = Canvas(bitmap)
-    layout.draw(canvas)
-
-    return bitmap
-}