tauri-plugin-widgets 0.4.1

Tauri plugin for App Widgets on Android, iOS, and macOS (WidgetKit); Windows Widgets Board (Adaptive Cards) + desktop webview; Linux desktop webview with X11 DESKTOP pin.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

package git.s00d.widgets

import android.appwidget.AppWidgetHost
import android.appwidget.AppWidgetHostView
import android.appwidget.AppWidgetManager
import android.content.ComponentName
import android.os.Bundle
import android.os.SystemClock
import android.view.View
import androidx.core.view.drawToBitmap
import androidx.glance.appwidget.updateAll
import androidx.test.ext.junit.runners.AndroidJUnit4
import androidx.test.platform.app.InstrumentationRegistry
import kotlinx.coroutines.runBlocking
import org.junit.After
import org.junit.Assert.assertTrue
import org.junit.Before
import org.junit.Test
import org.junit.runner.RunWith

/**
 * Level-2 visual stand: AppWidgetHost → real Glance/RemoteViews → bitmap assert.
 *
 * Env: tools/android-up.sh (grantbind, animations off, pinned clock).
 * Record one case:
 *   ./gradlew :connectedDebugAndroidTest \
 *     -Pgolden.record=true \
 *     -Pandroid.testInstrumentationRunnerArguments.case=weather.small
 */
@RunWith(AndroidJUnit4::class)
class WidgetRenderTest {
    private companion object {
        const val HOST_ID = 0x7ADA
        const val DEADLINE_MS = 15_000L
        const val POLL_MS = 250L
    }

    private lateinit var host: AppWidgetHost

    @Before
    fun setUp() {
        val ctx = InstrumentationRegistry.getInstrumentation().targetContext
        host = AppWidgetHost(ctx, HOST_ID)
        host.startListening()
    }

    @After
    fun tearDown() {
        host.stopListening()
    }

    @Test
    fun renderCases() {
        val ctx = InstrumentationRegistry.getInstrumentation().targetContext
        val filter = Golden.caseFilter()
        val cases = Cases.load(ctx, filter)
        assertTrue("no cases loaded (filter=$filter)", cases.isNotEmpty())

        val mgr = AppWidgetManager.getInstance(ctx)
        val provider = ComponentName(ctx, TauriGlanceWidgetReceiver::class.java)
        val failures = mutableListOf<String>()

        for (case in cases) {
            val id = host.allocateAppWidgetId()
            try {
                val bound = mgr.bindAppWidgetIdIfAllowed(id, provider)
                require(bound) {
                    "bindAppWidgetIdIfAllowed failed — run: " +
                        "adb shell appwidget grantbind --package ${ctx.packageName}"
                }

                val (wDp, hDp) = case.dp()
                val opts = Bundle().apply {
                    putInt(AppWidgetManager.OPTION_APPWIDGET_MIN_WIDTH, wDp)
                    putInt(AppWidgetManager.OPTION_APPWIDGET_MAX_WIDTH, wDp)
                    putInt(AppWidgetManager.OPTION_APPWIDGET_MIN_HEIGHT, hDp)
                    putInt(AppWidgetManager.OPTION_APPWIDGET_MAX_HEIGHT, hDp)
                }
                mgr.updateAppWidgetOptions(id, opts)

                VisualStore.reset(ctx)
                val fixtureJson = Cases.fixtureJson(ctx, case)
                VisualStore.putConfig(ctx, id, fixtureJson)
                runBlocking { TauriGlanceWidget().updateAll(ctx) }

                val info = mgr.getAppWidgetInfo(id)
                    ?: error("no AppWidgetProviderInfo for id=$id (provider not merged?)")

                lateinit var view: AppWidgetHostView
                InstrumentationRegistry.getInstrumentation().runOnMainSync {
                    view = host.createView(ctx, id, info)
                    val density = ctx.resources.displayMetrics.density
                    val wPx = (wDp * density).toInt()
                    val hPx = (hDp * density).toInt()
                    val wSpec = View.MeasureSpec.makeMeasureSpec(wPx, View.MeasureSpec.EXACTLY)
                    val hSpec = View.MeasureSpec.makeMeasureSpec(hPx, View.MeasureSpec.EXACTLY)
                    view.measure(wSpec, hSpec)
                    view.layout(0, 0, view.measuredWidth, view.measuredHeight)
                }

                val bmp = awaitStable(view)
                Golden.assertMatches(ctx, case.name, bmp)
            } catch (t: Throwable) {
                failures += "${case.name}: ${t.message}"
            } finally {
                host.deleteAppWidgetId(id)
                VisualStore.reset(ctx)
            }
        }

        if (failures.isNotEmpty()) {
            throw AssertionError(failures.joinToString("\n"))
        }
    }

    /** Poll until two consecutive frames match and content is non-uniform. */
    private fun awaitStable(view: View): android.graphics.Bitmap {
        val t0 = SystemClock.uptimeMillis()
        var prev: String? = null
        var last: android.graphics.Bitmap? = null
        while (SystemClock.uptimeMillis() - t0 < DEADLINE_MS) {
            var bmp: android.graphics.Bitmap? = null
            InstrumentationRegistry.getInstrumentation().runOnMainSync {
                bmp = view.drawToBitmap()
            }
            val frame = bmp!!
            last = frame
            val h = BitmapUtil.sha256(frame)
            if (h == prev && !BitmapUtil.isUniform(frame)) {
                return frame
            }
            prev = h
            SystemClock.sleep(POLL_MS)
        }
        error(
            "widget did not stabilize within ${DEADLINE_MS}ms " +
                "(lastUniform=${last?.let { BitmapUtil.isUniform(it) }})",
        )
    }
}