The widget: Needs you (the top review and newest assigned issue) and a Flow health strip of the last 30 runs; the mark in its own colours (closes #33) 943c54cf6a56

package io.oxygenhub.android.widget

import android.graphics.Bitmap

import android.graphics.Canvas

import android.graphics.Paint

import android.graphics.RectF

import androidx.compose.ui.graphics.toArgb

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

/**

 * The widget's Flow health strip (#33): your last runs, oldest on the left,

 * a bar each in its outcome's colour, and how many of the finished ones

 * passed. Drawn as one picture, as a widget's row holds only ten children.

 */

object HealthStrip {

    /** The kinds a run's status comes to. */

    enum class Kind { Passed, Failed, Live, Other }

    fun kind(status: String): Kind = when (status) {

        "passed" -> Kind.Passed

        "failed", "error" -> Kind.Failed

        "running", "queued" -> Kind.Live

        else -> Kind.Other

    }

    /** "93% of 28 finished runs passed", or null with nothing finished to count. Cancelled runs do not count. */

    fun summary(statuses: List<String>): String? {

        val kinds = statuses.map(::kind)

        val finished = kinds.count { it == Kind.Passed || it == Kind.Failed }

        if (finished == 0) return null

        val passed = kinds.count { it == Kind.Passed }

        val pct = (passed * 100 + finished / 2) / finished

        return if (finished == 1) "$pct% of the last finished run passed" else "$pct% of the last $finished finished runs passed"

    }

    /** The strip for [statuses] (newest first, as the hub lists them) at [width] × [height] pixels. */

    fun render(statuses: List<String>, width: Int, height: Int, density: Float, dark: Boolean): Bitmap {

        val bitmap = Bitmap.createBitmap(width.coerceAtLeast(1), height.coerceAtLeast(1), Bitmap.Config.ARGB_8888)

        val canvas = Canvas(bitmap)

        val runs = statuses.take(MAX).reversed()

        if (runs.isEmpty()) return bitmap

        val gap = 2f * density

        val bar = ((width - gap * (MAX - 1)) / MAX).coerceAtLeast(1f)

        val paint = Paint(Paint.ANTI_ALIAS_FLAG)

        // Right-aligned, so the newest run is always at the right edge.

        var x = width - runs.size * bar - (runs.size - 1) * gap

        for (s in runs) {

            paint.color = colour(kind(s), dark)

            canvas.drawRoundRect(RectF(x, 0f, x + bar, height.toFloat()), 1.5f * density, 1.5f * density, paint)

            x += bar + gap

        }

        return bitmap

    }

    private fun colour(k: Kind, dark: Boolean): Int = when (k) {

        Kind.Passed -> (if (dark) DarkOk else LightOk).toArgb()

        Kind.Failed -> (if (dark) DarkBad else LightBad).toArgb()

        Kind.Live -> (if (dark) DarkWarn else LightWarn).toArgb()

        Kind.Other -> if (dark) 0x66FFFFFF else 0x55000000

    }

    const val MAX = 30

}

## Unreleased

- **Needs you and Flow health on the widget (#33):** the space under the runs shows the proposal at the head of your reviews and your newest assigned issue, a line each that opens it, and a strip of your last 30 runs (oldest on the left, each bar in its outcome's colour) with how many of the finished ones passed. The OxygenHub mark keeps its own colours again; only the word is white.

    /** The proposal at the head of your reviews, and your newest assigned issue: Needs you (#33). */

    val topReview: ProposalBrief? = null,

    val topAssigned: IssueBrief? = null,

    /** Your last runs' statuses, newest first, for the health strip (#33). */

    val health: List<String> = emptyList(),

            val all = runs.await().orEmpty()

                runs = all.take(MAX_RUNS),

                topReview = review?.firstOrNull(),

                topAssigned = issues?.firstOrNull(),

                health = all.take(HealthStrip.MAX).map { it.run.status },

/** The title: white on the dark widget, the text colour on the light one (#31); the mark keeps its own colours (#33). */

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

        NeedsYou(d, body)

        Health(d, mute)

        Spacer(GlanceModifier.height(6.dp))

    }

}

/** Needs you (#33): the top proposal to review and the newest issue assigned, a line each, opening it. */

@Composable

private fun NeedsYou(d: WidgetData, body: TextStyle) {

    val r = d.topReview

    val i = d.topAssigned

    if (r == null && i == null) return

    Spacer(GlanceModifier.height(8.dp))

    Text("Needs you", style = TextStyle(color = GlanceTheme.colors.onSurfaceVariant, fontSize = 11.sp, fontWeight = FontWeight.Bold))

    r?.let { NeedLine(R.drawable.widget_proposal, "Review ${it.repository} #${it.number}: ${it.title}", body, WidgetTaps.action("proposal", it.repository, it.number)) }

    i?.let { NeedLine(R.drawable.widget_issue, "${it.repository} #${it.number}: ${it.title}", body, WidgetTaps.action("issue", it.repository, it.number)) }

}

@Composable

private fun NeedLine(icon: Int, text: String, body: TextStyle, open: Action) {

    Row(GlanceModifier.fillMaxWidth().padding(vertical = 2.dp).clickable(open), verticalAlignment = Alignment.CenterVertically) {

        Image(ImageProvider(icon), contentDescription = null, colorFilter = ColorFilter.tint(headline), modifier = GlanceModifier.size(13.dp))

        Spacer(GlanceModifier.width(8.dp))

        Text(text, style = body, maxLines = 1)

    }

}

/** Flow health (#33): a bar per recent run, and how many of the finished ones passed. */

@Composable

private fun Health(d: WidgetData, mute: TextStyle) {

    val summary = HealthStrip.summary(d.health) ?: return

    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 strip = try {

        // The widget's width less its padding, at 10 dp high.

        ImageProvider(HealthStrip.render(d.health, ((size.width.value - 24f) * density).toInt(), (10f * density).toInt(), density, dark))

    } catch (_: Throwable) {

        null

    }

    Column(GlanceModifier.fillMaxWidth().clickable(actionStartActivity<MainActivity>())) {

        strip?.let { Image(it, contentDescription = summary, contentScale = ContentScale.FillBounds, modifier = GlanceModifier.fillMaxWidth().height(10.dp)) }

        Spacer(GlanceModifier.height(3.dp))

        Text(summary, style = mute, maxLines = 1)

import io.oxygenhub.android.widget.HealthStrip

    @Test

    fun needsYouAndTheHealthStripComeFromWhatTheWidgetFetches() = runTest {

        val api = FakeHubApi()

        val statuses = listOf("running", "passed", "failed", "cancelled", "passed", "passed")

        api.userFlowRuns = { statuses.mapIndexed { i, st -> UserFlowRun("andy/a", FlowRun(number = 10L - i, status = st)) } }

        val d = WidgetData.load(api)

        assertEquals(300L, d.topReview?.number)

        assertEquals(359L, d.topAssigned?.number)

        assertEquals("all the runs fetched, not just the three shown", statuses, d.health)

        assertEquals(3, d.runs.size)

    }

    @Test

    fun theHealthSummaryCountsFinishedRunsOnly() {

        assertEquals("75% of the last 4 finished runs passed", HealthStrip.summary(listOf("running", "passed", "failed", "cancelled", "passed", "passed")))

        assertEquals("100% of the last finished run passed", HealthStrip.summary(listOf("passed", "queued")))

        assertNull("nothing finished", HealthStrip.summary(listOf("running", "cancelled")))

        assertNull(HealthStrip.summary(emptyList()))

        assertEquals(HealthStrip.Kind.Failed, HealthStrip.kind("error"))

    }