The widget: the OxygenHub mark and Your sky behind it (closes #30) 6823c243eaac

package io.oxygenhub.android.widget

import android.graphics.Bitmap

import android.graphics.Canvas

import android.graphics.LinearGradient

import android.graphics.Paint

import android.graphics.Path

import android.graphics.Shader

import androidx.compose.ui.graphics.Color

import androidx.compose.ui.graphics.toArgb

import io.oxygenhub.android.api.UserSky

import io.oxygenhub.android.ui.backdrop.Frame

import io.oxygenhub.android.ui.backdrop.STAR

import io.oxygenhub.android.ui.backdrop.skyEvents

import io.oxygenhub.android.ui.backdrop.straight

import io.oxygenhub.android.ui.theme.DarkBad

import io.oxygenhub.android.ui.theme.DarkOk

import io.oxygenhub.android.ui.theme.DarkWarn

import io.oxygenhub.android.ui.theme.LightBad

import io.oxygenhub.android.ui.theme.LightOk

import io.oxygenhub.android.ui.theme.LightWarn

import uniffi.rust_core.Backdrop as Scene

/**

 * Your sky behind the widget: the dashboard's scene, stepped in rust-core

 * until it settles and drawn once into a bitmap at the widget's size. A

 * widget cannot animate, so each refresh draws it anew from the caller's

 * own activity; it is real data, never decoration (the hub's

 * docs/backgrounds.md), and with nothing of the caller's to draw there is no

 * bitmap and the widget keeps its plain surface.

 */

internal object SkyBitmap {

    /** Steps to let a still scene settle; it says when it has. */

    private const val SETTLE_STEPS = 240

    private const val DT = 1f / 30f

    /** Whether there is anything of the caller's to draw. */

    fun drawable(sky: UserSky?): Boolean = sky != null && sky.repos.isNotEmpty() && skyEvents(sky).isNotEmpty()

    /** The scene's colours, as the app's backdrop has them for each theme: mark, lit, link, ok, warn, bad. */

    fun colours(dark: Boolean): List<Float> {

        val (mark, lit, link) = if (dark) {

            Triple(Color(0, 224, 240).copy(alpha = 0.16f), Color(0, 240, 255).copy(alpha = 0.9f), Color(0, 240, 255).copy(alpha = 0.35f))

        } else {

            Triple(Color(95, 106, 129).copy(alpha = 0.22f), Color(0, 100, 224).copy(alpha = 0.75f), Color(0, 100, 224).copy(alpha = 0.25f))

        }

        val status = if (dark) listOf(DarkOk, DarkWarn, DarkBad) else listOf(LightOk, LightWarn, LightBad)

        return (listOf(mark, lit, link) + status).flatMap { listOf(it.red, it.green, it.blue, it.alpha) }

    }

    /** The settled frame of Your sky at [widthDp] × [heightDp], or null when there is nothing to draw. */

    fun frame(sky: UserSky?, widthDp: Float, heightDp: Float, dark: Boolean): Frame? {

        if (!drawable(sky) || widthDp <= 0f || heightDp <= 0f) return null

        val scene = Scene.sky(sky!!.repos, skyEvents(sky), widthDp, heightDp, true)

        return try {

            scene.colours(colours(dark))

            var n = 0

            while (n < SETTLE_STEPS && scene.step(DT)) n++

            Frame.of(scene.frame()).takeIf { it.marks.isNotEmpty() }

        } finally {

            scene.close()

        }

    }

    /** [frame] drawn into a bitmap of [widthPx] × [heightPx] pixels, [density] pixels to the dp. */

    fun render(frame: Frame, widthPx: Int, heightPx: Int, density: Float, dark: Boolean): Bitmap {

        val bitmap = Bitmap.createBitmap(widthPx, heightPx, Bitmap.Config.ARGB_8888)

        draw(Canvas(bitmap), frame, density, dark)

        return bitmap

    }

    private fun draw(canvas: Canvas, f: Frame, density: Float, dark: Boolean) {

        val line = Paint(Paint.ANTI_ALIAS_FLAG).apply { strokeWidth = density; style = Paint.Style.STROKE }

        val l = f.links

        var i = 0

        while (i + 12 <= l.size) {

            val (ax, ay, bx, by) = listOf(l[i], l[i + 1], l[i + 6], l[i + 7]).map { it * density }

            val ca = straight(l[i + 2], l[i + 3], l[i + 4], l[i + 5]).toArgb()

            val cb = straight(l[i + 8], l[i + 9], l[i + 10], l[i + 11]).toArgb()

            line.shader = LinearGradient(ax, ay, bx, by, ca, cb, Shader.TileMode.CLAMP)

            canvas.drawLine(ax, ay, bx, by, line)

            i += 12

        }

        val fill = Paint(Paint.ANTI_ALIAS_FLAG)

        val ring = Paint(Paint.ANTI_ALIAS_FLAG).apply { style = Paint.Style.STROKE }

        val m = f.marks

        i = 0

        while (i + 8 <= m.size) {

            val (x, y, s) = Triple(m[i] * density, m[i + 1] * density, m[i + 2] * density)

            val colour = straight(m[i + 4], m[i + 5], m[i + 6], m[i + 7])

            // On a dark widget a lit mark glows a little, as in the app.

            if (dark && colour.alpha > 0.5f) {

                fill.color = colour.copy(alpha = colour.alpha * 0.14f).toArgb()

                canvas.drawCircle(x, y, s * 2.6f, fill)

            }

            fill.color = colour.toArgb()

            ring.color = colour.toArgb()

            when (Math.round(m[i + 3])) {

                0 -> canvas.drawCircle(x, y, s, fill) // a push: a dot

                1 -> canvas.drawPath(polygon(x, y, DIAMOND, s / 0.85f), fill) // a proposal: a diamond

                2 -> canvas.drawCircle(x, y, s * 0.72f, ring.apply { strokeWidth = s * 0.56f }) // an issue: a ring

                3 -> canvas.drawPath(polygon(x, y, STAR, s), fill) // a release: a star

                4 -> canvas.drawCircle(x, y, s * 0.85f, ring.apply { strokeWidth = s * 0.24f }) // a repository: a thin ring

                else -> { // a Flow run: a square

                    val h = s / 1.15f

                    canvas.drawRect(x - h, y - h, x + h, y + h, fill)

                }

            }

            i += 8

        }

    }

    private val DIAMOND = floatArrayOf(1f, 0f, 0f, 1f, -1f, 0f, 0f, -1f)

    private fun polygon(x: Float, y: Float, unit: FloatArray, r: Float): Path = Path().apply {

        moveTo(x + unit[0] * r, y + unit[1] * r)

        var j = 2

        while (j < unit.size) {

            lineTo(x + unit[j] * r, y + unit[j + 1] * r)

            j += 2

        }

        close()

    }

}

- **A flashier widget (#30):** the home screen widget now has the OxygenHub mark beside its title and Your sky behind its runs, drawn by the same scene as the dashboard's backdrop, settled into a still picture at the widget's size (a widget cannot animate) and redrawn from your own activity at each refresh, with a veil so the text stays readable in light and dark. With nothing of yours to draw, it keeps the plain surface.

internal val STAR = (1f / 4.5f).let { k -> floatArrayOf(1f, 0f, k, k, 0f, 1f, -k, k, -1f, 0f, -k, -k, 0f, -1f, k, -k) }

import android.content.res.Configuration

import androidx.glance.Image

import androidx.glance.ImageProvider

import androidx.glance.LocalContext

import androidx.glance.LocalSize

import androidx.glance.appwidget.SizeMode

import androidx.glance.layout.ContentScale

import io.oxygenhub.android.R

import io.oxygenhub.android.api.UserSky

    /** Your sky, drawn behind the content; null keeps the plain surface. */

    val sky: UserSky? = null,

            val sky = async { quietly { api.userSky() } }

            WidgetData(true, runs.await().orEmpty().take(MAX_RUNS), unread.await(), reviews.await(), sky.await())

/**

 * A home screen widget (#28): your latest runs, unread notifications and

 * reviews waiting; a tap opens the app. The OxygenHub mark heads it and Your

 * sky is drawn behind it, at the widget's own size (#30).

 */

    /** Composed for each size the launcher shows it at, so the sky fits exactly. */

    override val sizeMode: SizeMode = SizeMode.Exact

    val context = LocalContext.current

    val size = LocalSize.current

    val dark = (context.resources.configuration.uiMode and Configuration.UI_MODE_NIGHT_MASK) == Configuration.UI_MODE_NIGHT_YES

    val density = context.resources.displayMetrics.density

    val sky = if (d.signedIn) skyImage(d.sky, size.width.value, size.height.value, density, dark) else null

    Box(GlanceModifier.fillMaxSize().cornerRadius(16.dp).background(GlanceTheme.colors.surfaceVariant).clickable(actionStartActivity<MainActivity>())) {

        if (sky != null) {

            Image(sky, contentDescription = null, contentScale = ContentScale.Crop, modifier = GlanceModifier.fillMaxSize())

            // Text stays readable over the marks.

            Box(GlanceModifier.fillMaxSize().background(scrim)) {}

        }

        Column(GlanceModifier.fillMaxSize().padding(12.dp)) { Body(d, title, body, mute) }

    }

}

/** The widget's sky as an image, or null when there is nothing to draw or drawing fails (the plain surface stays). */

private fun skyImage(sky: UserSky?, widthDp: Float, heightDp: Float, density: Float, dark: Boolean): ImageProvider? = try {

    SkyBitmap.frame(sky, widthDp, heightDp, dark)?.let {

        ImageProvider(SkyBitmap.render(it, (widthDp * density).toInt().coerceAtLeast(1), (heightDp * density).toInt().coerceAtLeast(1), density, dark))

    }

} catch (_: Throwable) {

    // A missing native library, or a launcher's odd size: the widget is worth more than its backdrop.

    null

}

private val scrim = ColorProvider(LightColorScheme.surfaceVariant.copy(alpha = 0.55f), DarkColorScheme.surfaceVariant.copy(alpha = 0.5f))

@Composable

private fun Body(d: WidgetData, title: TextStyle, body: TextStyle, mute: TextStyle) {

    Column {

        Row(verticalAlignment = Alignment.CenterVertically) {

            Image(ImageProvider(R.drawable.mark), contentDescription = null, modifier = GlanceModifier.size(width = 28.dp, height = 14.dp))

            Spacer(GlanceModifier.width(6.dp))

            Text("OxygenHub", style = title)

        }

import io.oxygenhub.android.api.UserSky

import io.oxygenhub.android.widget.SkyBitmap

import org.junit.Assert.assertNotEquals

import org.junit.Assert.assertTrue

    @Test

    fun theWidgetFetchesYourSkyAndALostSkyLeavesThePlainSurface() = runTest {

        val api = FakeHubApi()

        val sky = UserSky(now = 10 * 86_400_000L, repos = listOf("andy/a"), events = listOf(listOf(0L, 0L, 9 * 86_400_000L, 3L)))

        api.userSky = { sky }

        assertEquals(sky, WidgetData.load(api).sky)

        api.userSky = { throw HubException.Http(404, "no such API route") }

        val d = WidgetData.load(api)

        assertNull(d.sky)

        assertEquals(1, d.reviews)

    }

    @Test

    fun onlyRealActivityIsDrawn() {

        assertFalse("nothing fetched", SkyBitmap.drawable(null))

        assertFalse("no repositories", SkyBitmap.drawable(UserSky()))

        assertFalse("repositories but no events", SkyBitmap.drawable(UserSky(repos = listOf("andy/a"))))

        assertFalse("only malformed events", SkyBitmap.drawable(UserSky(repos = listOf("andy/a"), events = listOf(listOf(7L, 0L, 0L, 1L)))))

        assertTrue(SkyBitmap.drawable(UserSky(now = 1, repos = listOf("andy/a"), events = listOf(listOf(0L, 4L, 0L, 1L)))))

    }

    @Test

    fun theSkysColoursFollowTheTheme() {

        val (light, dark) = SkyBitmap.colours(false) to SkyBitmap.colours(true)

        assertEquals(24, light.size)

        assertEquals(24, dark.size)

        assertNotEquals(light, dark)

        assertTrue("every channel is a fraction", (light + dark).all { it in 0f..1f })

    }