Compare commits
1
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
 logan
|
7699fcd9dc |
@@ -194,13 +194,9 @@ like the app's fault and none is:
|
||||
|---|---|---|
|
||||
| x86_64 | modernc's raw `lstat` vs seccomp | SIGSYS, syscall 6 |
|
||||
| arm64, translated | Go reads `ID_AA64ISAR0_EL1` | SIGILL |
|
||||
| arm64, real device | **runs** (2026-08-20) | — |
|
||||
| arm64, real device | — | unverified, still |
|
||||
|
||||
**A physical arm64 device remains the only verification path**, and it
|
||||
has now been walked: a Light Phone III (TLP301, Android 14 / SDK 34,
|
||||
arm64-v8a, WebView Chrome 113 at 424x439). The app builds, installs,
|
||||
launches and stays up; `make android-smoke SECONDS=60` passes on it.
|
||||
What that run *found* is the lifecycle fault below.
|
||||
**A physical arm64 device remains the only verification path.**
|
||||
|
||||
### What was fixed to get here
|
||||
|
||||
@@ -214,11 +210,6 @@ no-op. `backend/system` gained no import of the Wails application
|
||||
package, which matters for the same reason `backend/events` is split by
|
||||
the `indexbuild` tag.
|
||||
|
||||
**And `main()` is now latched to one run per process** (#52). That is
|
||||
the second `os.Exit(1)` in this file's history and it had the same
|
||||
signature as the first, which is the argument for #160: both were named
|
||||
exactly by an `slog` line that went to `/dev/null`.
|
||||
|
||||
### What is still not done
|
||||
|
||||
The shell is still a desktop shell, and the x86_64 half of the APK is
|
||||
@@ -258,25 +249,10 @@ one.
|
||||
`build/android/Taskfile.yml` ships more than the Makefile wraps, and
|
||||
they are the right thing to reach for when you want something one-off:
|
||||
|
||||
> **These four were unsafe until #159 and are now the way in.** All of
|
||||
> them began with `adb uninstall {{.APP_ID}}`, where `APP_ID` defaulted
|
||||
> to `app.yellowjacket` — the **release** id — while `run` and
|
||||
> `run:device` build the **debug** variant, whose id is
|
||||
> `app.yellowjacket.dev`. So they uninstalled the user's app, taking
|
||||
> the library with it, installed a different package, and then failed
|
||||
> to launch the one they had removed.
|
||||
>
|
||||
> They share `scripts/android-deploy.sh` now, which **never**
|
||||
> uninstalls (`install -r`, and a changed signing certificate is
|
||||
> reported with the command rather than acted on), reads the package id
|
||||
> back out of the built APK, and refuses a target that is not the kind
|
||||
> the task names. There is nothing left to avoid; the manual sequence
|
||||
> below is kept because it is still the smallest thing that works.
|
||||
|
||||
```
|
||||
wails3 task android:run # debug build + emulator install + launch
|
||||
wails3 task android:run:device # debug build + install + launch on a phone
|
||||
wails3 task android:deploy-device # release build, same
|
||||
wails3 task android:run:device # same, first connected physical device
|
||||
wails3 task android:deploy-device # production APK to a device
|
||||
wails3 task android:bundle:fat # AAB, for a Play Store upload
|
||||
wails3 task android:studio # open build/android/ in Android Studio
|
||||
wails3 task android:device:list
|
||||
@@ -284,16 +260,6 @@ wails3 task android:logs:all
|
||||
wails3 task android:clean
|
||||
```
|
||||
|
||||
**`run` and `deploy-emulator` mean the emulator, and now say so to
|
||||
adb.** They used a bare `adb install`, which with exactly one device
|
||||
attached picks that device whatever it is — so with a phone plugged in
|
||||
and no emulator running, the task whose summary reads "in the Android
|
||||
Emulator" installed on the phone. They pass `--target emulator` and
|
||||
refuse with `make android-emulator` as the remedy.
|
||||
|
||||
**`DEVICE_ID=<serial>` still names a device, and several attached
|
||||
devices is now an error rather than a silent pick of the first.**
|
||||
|
||||
Two are deliberately **not** wrapped. `android:logs` greps logcat for
|
||||
`(Wails|yellowjacket)`, which catches the `WailsBridge` tag but misses
|
||||
the app's own process tag (`app.yellowjacket` — lowercase, so `Wails`
|
||||
@@ -303,51 +269,16 @@ instead. And `ensure-emulator` boots whatever `-list-avds | tail -1`
|
||||
returns, with no pidfile and no boot wait, so it cannot be stopped or
|
||||
sequenced.
|
||||
|
||||
## The identity is read back from the APK
|
||||
## The identity is declared twice
|
||||
|
||||
It used to be **declared twice**, and that is what #159 was.
|
||||
`applicationId` in `build/android/app/build.gradle` is what Gradle
|
||||
installs; `APP_ID` in `build/android/Taskfile.yml` was what every
|
||||
adb-driven task uninstalled, launched and filtered, and nothing
|
||||
enforced that they agree. They did not: the debug buildType carries
|
||||
`applicationIdSuffix ".dev"`, so every task that assembles a debug APK
|
||||
addressed the release id. This file flagged the hazard for five phases
|
||||
and it cashed out twice — once as a wrong `am start`, once as an
|
||||
uninstall of the user's library.
|
||||
|
||||
**`scripts/android-pkgid.sh` is the one answer now.** It prints the
|
||||
package id an APK declares (`aapt2 dump packagename`, falling back to
|
||||
`aapt dump badging`), and the deploy path installs and launches *that*.
|
||||
The APK is the authority because the task that installs it has just
|
||||
built it: whatever Gradle resolved the applicationId to, suffixes and
|
||||
flavours included, is in the file, and no default can disagree with it.
|
||||
An APK it cannot read is a hard failure, never a fallback to a written
|
||||
down default — guessing is the bug.
|
||||
|
||||
**`APP_ID` survives as an assertion, not a setting**, and has no
|
||||
default. `wails3 task android:run APP_ID=app.yellowjacket` says "this
|
||||
build had better declare that id" and is refused, naming both, *before*
|
||||
anything is installed or a device is even chosen. It could never have
|
||||
been a setting: `ANDROID.md`'s advice to put it in `build/config.yml`
|
||||
does not work in beta.8 — `wails3 task` never reads that file (verified
|
||||
with `--dry`) — and even when set it fed only the adb commands, never
|
||||
Gradle.
|
||||
|
||||
`scripts/android-emulator.sh` derives `PKG` the same way, from
|
||||
`bin/yellowjacket.apk` when one is built, so `make android-install`,
|
||||
`android-launch`, `android-logs` and `android-smoke` follow whichever
|
||||
variant is actually in `bin/`. `YJ_ANDROID_PKG` still overrides, and
|
||||
the old literal survives only for a tree with no APK built yet.
|
||||
|
||||
**The uninstall is gone and is not coming back.** It existed to make
|
||||
the bare `install` on the next line work at all — without `-r` Android
|
||||
refuses an install over an existing package — so `install -r` removes
|
||||
the *reason* for it rather than merely removing it. What is left is the
|
||||
one case an uninstall really is the remedy, a changed signing
|
||||
certificate, and that is exactly the case where performing it silently
|
||||
costs the user their library. So it is named and not done, which is the
|
||||
answer `scripts/android-emulator.sh` had already reached for
|
||||
`make android-install`.
|
||||
installs. `APP_ID` in `build/android/Taskfile.yml` is what every
|
||||
adb-driven task uninstalls, launches and filters. **Nothing enforces
|
||||
that they agree**, and `ANDROID.md`'s advice to set `APP_ID` in
|
||||
`build/config.yml` does not work in beta.8 — `wails3 task` never reads
|
||||
that file (verified with `--dry`), and even when set it feeds only the
|
||||
adb commands, never Gradle. Change both or the official `run`/`deploy`
|
||||
tasks address a package that is not installed.
|
||||
|
||||
Related, and it will bite once: the launcher activity is
|
||||
`com.wails.app.MainActivity` and the applicationId is
|
||||
@@ -356,27 +287,6 @@ resolves the leading dot against the *applicationId* and fails with a
|
||||
class-not-found that reads like a broken build. Always the
|
||||
fully-qualified form.
|
||||
|
||||
**`wails3 task android:run:device` is the way to put a debug build on a
|
||||
real device**, since #159. What #52 used, before it was safe, was the
|
||||
longer form, and it is still the smallest thing that works if you want
|
||||
no script between you and adb:
|
||||
|
||||
```bash
|
||||
wails3 task android:build ARCH=arm64 && wails3 task android:assemble:apk
|
||||
adb install -r bin/yellowjacket.apk # -r, never uninstall
|
||||
adb shell am start -n app.yellowjacket.dev/com.wails.app.MainActivity
|
||||
```
|
||||
|
||||
The id in that last line is the one thing to keep an eye on by hand —
|
||||
`./scripts/android-pkgid.sh bin/yellowjacket.apk` is what the tasks ask,
|
||||
and it is a good habit before any `am start` written out in full.
|
||||
|
||||
`YJ_ANDROID_PKG=app.yellowjacket.dev` still overrides what
|
||||
`scripts/android-emulator.sh` — and therefore `make android-smoke`,
|
||||
`android-logs`, `android-launch` — addresses, but it is rarely needed
|
||||
now: that default is read from `bin/yellowjacket.apk`, so it already
|
||||
follows whichever variant was built last.
|
||||
|
||||
## What only a device can answer
|
||||
|
||||
The emulator cannot run this app (three separate reasons, none of them
|
||||
@@ -401,91 +311,6 @@ system bars, the back gesture, focus and audio interruptions,
|
||||
permission dialogs, the keyboard — not about what the app draws. The
|
||||
drawing is what the other five tiers already cover.
|
||||
|
||||
**The third such fault was the activity lifecycle** (#52), and it is
|
||||
the one to re-check after touching `main()`, `WailsBridge` or
|
||||
`MainActivity`. Android destroys and recreates an activity **without
|
||||
restarting the process**, and Wails' `nativeInit` — which
|
||||
`MainActivity.onCreate` calls — runs `go mainFunc()` every time. So
|
||||
Go's `main()` ran again on a live app, `app.Run()` refused (`a.starting`
|
||||
is still true behind Android's `select{}`), and the `os.Exit(1)` under
|
||||
it took the healthy first app down with it.
|
||||
|
||||
### The lifecycle check, and how to trigger it on demand
|
||||
|
||||
This is the regression guard for #52 on this tier, because no other
|
||||
tier runs `main()` on Android at all. The Go-side guard
|
||||
(`TestMainClaimsBeforeItDoesAnything`) catches work creeping above the
|
||||
latch; only the device catches the latch not working.
|
||||
|
||||
**Trigger a relaunch with a configuration change the manifest does not
|
||||
declare.** `AndroidManifest.xml` lists
|
||||
`orientation|screenSize|keyboardHidden|uiMode`, so those are handled
|
||||
in-place and are *not* triggers. `fontScale` is not listed, and it is a
|
||||
one-liner:
|
||||
|
||||
```bash
|
||||
adb shell settings put system font_scale 1.15 # restore the old value after
|
||||
```
|
||||
|
||||
That is the same in-process destroy/recreate that "Don't keep
|
||||
activities", a locale change and a memory trim produce, but on demand.
|
||||
|
||||
**"Don't keep activities" is the report's own lever and did not work on
|
||||
this device**: `settings put global always_finish_activities 1` reads
|
||||
back as `1`, `am set-always-finish-activities` does not exist on this
|
||||
build, and the activity was never finished on backgrounding. Do not
|
||||
spend an afternoon on it; use the config change.
|
||||
|
||||
**The assertion is the pid, and the tell is two bridge inits in one.**
|
||||
|
||||
```bash
|
||||
adb logcat -d | grep -E "Wails bridge initialized|has died|finishDrawing of relaunch"
|
||||
```
|
||||
|
||||
Healthy is one pid appearing twice — the process surviving the
|
||||
recreation:
|
||||
|
||||
```
|
||||
I/WailsBridge(28420): Wails bridge initialized
|
||||
I/WailsBridge(28420): Wails bridge initialized <- same pid, recreated
|
||||
```
|
||||
|
||||
Broken is that pair followed within a second by:
|
||||
|
||||
```
|
||||
I/WindowManager: finishDrawing of relaunch: Window{...MainActivity} 603ms
|
||||
I/ActivityManager: Process app.yellowjacket.dev (pid 22956) has died: fg TOP
|
||||
W/ActivityTaskManager: Force removing ActivityRecord{...}: app died, no saved state
|
||||
```
|
||||
|
||||
Two things about reading that. **`has died: fg TOP` is not a memory
|
||||
kill** — the system does not reclaim the foreground process, so this is
|
||||
the app leaving of its own accord. And there is **no crash record
|
||||
anywhere**: `logcat -b crash` is empty, no `AndroidRuntime`, no
|
||||
`libc: Fatal signal`, no tombstone. That is the `os.Exit` signature,
|
||||
and it is why "the system killed it" is the wrong first hypothesis.
|
||||
|
||||
**Surviving is only half of it — check the recreated WebView is still
|
||||
wired to the running app.** A plausible-looking fix (making
|
||||
`WailsBridge.initialized` static, so the second `nativeInit` is skipped)
|
||||
keeps the process alive and silently breaks this, because `nativeInit`
|
||||
is also what re-points the JNI reference at the new bridge. Go would go
|
||||
on executing JavaScript against the destroyed activity's WebView: the
|
||||
app opens, renders, and never receives another backend event.
|
||||
|
||||
Ask the page, after a relaunch and a resume:
|
||||
|
||||
```bash
|
||||
make android-inspect
|
||||
make android-eval EXPR='(()=>{window.__probe=[];const o=window._wails.dispatchWailsEvent.bind(window._wails);window._wails.dispatchWailsEvent=(e)=>{window.__probe.push(e&&e.name);return o(e)};return "ok"})()'
|
||||
# background and foreground the app, then:
|
||||
make android-eval EXPR='JSON.stringify(window.__probe)'
|
||||
```
|
||||
|
||||
A healthy build answers with events from the live services —
|
||||
`["IndexStatusChanged","JobsChanged","JobsChanged","android:storageAccess"]`.
|
||||
`[]` means the bridge reference is stale.
|
||||
|
||||
## Asking the device, not just looking at it
|
||||
|
||||
A real phone can be inspected, and that turns this tier from "reported
|
||||
@@ -515,75 +340,6 @@ Four things about it, each of which costs an hour if met cold:
|
||||
script. Plug in over USB for anything longer than a couple of probes.
|
||||
- **The socket name carries the pid**, which changes on every launch, so
|
||||
it is resolved rather than remembered.
|
||||
- **A reinstall resets the runtime permissions**, and the grant dialog
|
||||
is a separate activity that takes focus — so the app is up, `am start`
|
||||
reports "delivered to currently running top-most instance", and
|
||||
`pidof` is empty because it never got to the foreground.
|
||||
`dumpsys window | grep mCurrentFocus` naming
|
||||
`GrantPermissionsActivity` is the tell. `adb shell pm grant
|
||||
app.yellowjacket.dev android.permission.READ_MEDIA_AUDIO` (and
|
||||
`POST_NOTIFICATIONS`) ahead of the launch skips it.
|
||||
|
||||
### Calling a binding on the device
|
||||
|
||||
**The runtime call does not go over HTTP on Android**, and this is worth
|
||||
knowing before an hour is spent on it. The WebView cannot deliver a
|
||||
`fetch()` POST body to `shouldInterceptRequest`, so v3 routes runtime
|
||||
calls through the `addJavascriptInterface` bridge instead: the
|
||||
@wailsio/runtime installs a `customTransport` that calls
|
||||
`window.wails.invokeAsync(id, payload)` and receives the answer on
|
||||
`window._wailsAndroidCallback`. Two consequences:
|
||||
|
||||
- **`.playwright/init-events.js` does not transfer to the device.** Its
|
||||
outbound half hooks `fetch`, which sees nothing here, and its
|
||||
`call()` posts to `/wails/runtime`, which answers
|
||||
`Invalid runtime call: missing object value` — the interceptor got the
|
||||
URL with no body. Its *inbound* half is still right, because
|
||||
`dispatchWailsEvent` is the entry point in every mode.
|
||||
- **Hooking `fetch` from an eval is too late anyway**, on any platform:
|
||||
the bundle captured its reference at module scope, so a wrapper
|
||||
installed afterwards records nothing. That is why the harness is an
|
||||
`initScript` and not a step in a spec.
|
||||
|
||||
What works is to borrow the bridge, chaining the runtime's own callback
|
||||
so its pending calls still resolve:
|
||||
|
||||
```js
|
||||
const pending = new Map();
|
||||
const prev = window._wailsAndroidCallback;
|
||||
window._wailsAndroidCallback = (id, response, error) => {
|
||||
if (!pending.has(id)) return prev && prev(id, response, error);
|
||||
const p = pending.get(id); pending.delete(id);
|
||||
const env = JSON.parse(response || "{}");
|
||||
return env.ok ? p.resolve(env.data ?? env.text) : p.reject(new Error(env.error));
|
||||
};
|
||||
window.__yj = { call(name, args) {
|
||||
return new Promise((resolve, reject) => {
|
||||
const id = "yj" + Math.random().toString(36).slice(2);
|
||||
pending.set(id, { resolve, reject });
|
||||
window.wails.invokeAsync(id, JSON.stringify({
|
||||
object: 0, method: 0, windowName: "",
|
||||
args: { "call-id": id, methodName: "yellowjacket/backend/" + name, args: args || [] },
|
||||
clientId: window._wails.clientId,
|
||||
}));
|
||||
});
|
||||
} };
|
||||
```
|
||||
|
||||
That turns the device into a tier that can be *driven* rather than only
|
||||
looked at — `__yj.call("player.Player.LoadFile", [path])` and
|
||||
`__yj.call("library.Library.AddLibrary", ["/sdcard/Music/..."])` are how
|
||||
#53 was measured. Names are the Go ones (`GetTracks`, not
|
||||
`GetAllTracks`); an unknown one comes back as a plain
|
||||
`unknown bound method name`, so a wrong guess is loud.
|
||||
|
||||
**Getting audio onto the phone**: `adb push` into
|
||||
`/sdcard/Android/data/<pkg>/files/` looks like it works and then the
|
||||
files are not there — scoped storage. `/sdcard/Music/...` plus
|
||||
`pm grant … READ_MEDIA_AUDIO` does work, and `AddLibrary` takes the
|
||||
plain path. The generated fixtures are **~2 seconds** each, which is
|
||||
fine for a scan and useless for watching a seek bar, so synthesise a
|
||||
long one: `ffmpeg -f lavfi -i sine=frequency=440:duration=240`.
|
||||
|
||||
**And the reason to bother: the phone is an engine, not a screen.** The
|
||||
first device here renders in **Chrome 113** at 424x439 CSS px. Every
|
||||
|
||||
@@ -3961,74 +3961,6 @@ The general rule for this repo's fixture library: it is deliberately
|
||||
full of edge cases (untagged, unicode, duplicates, extremes), so a spec
|
||||
that wants an *ordinary* track has to **say so** — filter on the
|
||||
property it depends on rather than slicing.
|
||||
## A nested rule starting with an element name is dropped on the phone (2026-08-20)
|
||||
|
||||
`CLAUDE.md` records that the device renders in **Chrome 113**, which
|
||||
does not have relaxed CSS nesting (Chrome 120). The consequence is
|
||||
sharper than "some syntax is unavailable": a nested rule whose selector
|
||||
begins with a bare identifier is not a parse error you would notice, it
|
||||
is **silently dropped**.
|
||||
|
||||
Three such rules were live in `frontend/index.css`, all inside
|
||||
`.bottom-bar`, and all therefore dead on the phone and only on the
|
||||
phone:
|
||||
|
||||
```css
|
||||
.bottom-bar {
|
||||
#track-info { p { … } } /* the metadata's ellipsis */
|
||||
now-playing { overflow: hidden; }
|
||||
audio-player { margin: 0.5em 1em; }
|
||||
}
|
||||
```
|
||||
|
||||
The first is the interesting one: it is the *ellipsis* on the bottom
|
||||
bar's track title and artist, so on the device that text has never
|
||||
truncated — the same class of fault as `now-playing`'s marquee, whose
|
||||
`text-overflow` sat on the wrong box and had never produced an ellipsis
|
||||
in any mode. Both are invisible to every assertion and visible in a
|
||||
screenshot.
|
||||
|
||||
`& p`, `& now-playing`, `& audio-player` are valid in both, so the fix
|
||||
is one character per rule. What is worth keeping is the rule of thumb:
|
||||
**inside a nested block, always write `&`** — and note that a rule
|
||||
inside `@media` is *not* nested, so `@media … { bottom-nav { … } }`
|
||||
elsewhere in that file is fine and needs nothing.
|
||||
|
||||
`make css-check` does not catch this (it looks for backticks that end a
|
||||
tagged template early). Filed as an issue: the check is the natural
|
||||
place for it, being the same shape of trap — a silent, phone-only,
|
||||
screenshot-only failure.
|
||||
|
||||
## Centring a bar costs the control in the middle of it (measured 2026-08-20)
|
||||
|
||||
#23 asks for the transport centred in the bottom bar. The obvious
|
||||
implementation — make the outer two grid tracks the same width, so the
|
||||
middle is centred by construction — is right, and the first cut of it
|
||||
was a regression, because "the same width" was taken to mean *the
|
||||
metadata's* width on both sides.
|
||||
|
||||
Measured at 800px, with the seek bar's own track:
|
||||
|
||||
| layout | seek track | transport column |
|
||||
|---|---|---|
|
||||
| `320px 1fr auto` (before) | 257 | 407 |
|
||||
| both sides `--now-playing-width` | **61** | 179 |
|
||||
| both sides `min(--now-playing-width, 25%)` | 246 | 364 |
|
||||
|
||||
At 200% text the middle row is worse still: 130 before, **0** with the
|
||||
uncapped sides. Centring is free at 1440 and expensive at 800, so a
|
||||
change checked only at a comfortable width looks perfect.
|
||||
|
||||
The general form: **a symmetric layout reserves space on the side that
|
||||
does not need it.** The right-hand group here is ~141px (volume plus
|
||||
the queue button) and was being given 320 to keep the arithmetic
|
||||
symmetric. Cap the side tracks against the *bar*, not against their
|
||||
content, and the middle gets the difference.
|
||||
|
||||
The spec that pins this is two assertions, not one, and that split is
|
||||
deliberate: an uncapped build is *perfectly centred* and fails only the
|
||||
seek-bar width, so a spec asserting centring alone would have passed
|
||||
the regression.
|
||||
|
||||
## The phone's way into Now Playing was under the artwork (measured 2026-08-20)
|
||||
|
||||
@@ -4077,276 +4009,3 @@ have saved the other two cycles.
|
||||
first track with no cover art" selects nothing in particular. The
|
||||
placeholder's presence is asserted instead, which is the property the
|
||||
test actually depends on.
|
||||
|
||||
## An activity recreation kills the process, deterministically (measured 2026-08-20)
|
||||
|
||||
#52's report was "sometimes crashes or restarts when reopened after
|
||||
running in the background". Measured on a real device, the *fault* is
|
||||
not intermittent at all — only its trigger is.
|
||||
|
||||
Device: Light Phone III (TLP301), Android 14 / SDK 34, arm64-v8a,
|
||||
WebView **Chrome 113** at 424x439 CSS px. Debug build
|
||||
(`app.yellowjacket.dev`), installed beside the released `v0.3.1` with
|
||||
`install -r`.
|
||||
|
||||
**Conditional on the activity actually being recreated in a live
|
||||
process, the process died 8 times out of 8** — 3 by hand, then 5/5 in a
|
||||
scripted loop. The runs where it survived were runs where no recreation
|
||||
happened (one `Wails bridge initialized` in the log rather than two), so
|
||||
they are inconclusive rather than passes; a harness that does not check
|
||||
for the second init reports those as green and reads as flakiness.
|
||||
After the fix: 5/5 recreations survived, plus 6 background/foreground
|
||||
cycles and 3 interleaved recreations on one pid.
|
||||
|
||||
The mechanism is three log lines:
|
||||
|
||||
```
|
||||
12:47:56.159 I/WailsBridge(22956): Wails bridge initialized
|
||||
12:48:38.898 I/WailsBridge(22956): Wails bridge initialized <- same pid
|
||||
12:48:39.357 I/ActivityManager: Process app.yellowjacket.dev (pid 22956) has died: fg TOP
|
||||
```
|
||||
|
||||
`nativeInit` runs `go mainFunc()` on every activity creation; the second
|
||||
`main()` reaches `app.Run()`, which refuses because `a.starting` is
|
||||
still true behind Android's `select{}`, and `os.Exit(1)` takes the whole
|
||||
process — including the healthy first app — with it.
|
||||
|
||||
Four things worth keeping:
|
||||
|
||||
- **`has died: fg TOP` is not a memory kill.** The system does not
|
||||
reclaim the foreground process. This reads as "the OS killed us",
|
||||
which is the wrong hypothesis and the reason the issue sat unverified.
|
||||
- **There is no crash record of any kind**: `logcat -b crash` empty, no
|
||||
`AndroidRuntime`, no `libc: Fatal signal`, no tombstone. `os.Exit` is
|
||||
not a crash. The one line that named the fault —
|
||||
`slog.Error("application error", "err", ...)`, carrying
|
||||
`"application is running or a previous run has failed"` — went to
|
||||
`/dev/null`. That is #160.
|
||||
- **"Don't keep activities" does not work on this device.**
|
||||
`settings put global always_finish_activities 1` reads back as `1`,
|
||||
`am set-always-finish-activities` does not exist on this build, and
|
||||
the activity was never finished on backgrounding. The report's own
|
||||
suggested lever is a dead end here. What *does* work, deterministically
|
||||
and in one line, is a configuration change the manifest does not
|
||||
declare: `adb shell settings put system font_scale 1.15`
|
||||
(`AndroidManifest.xml` declares `orientation|screenSize|
|
||||
keyboardHidden|uiMode`, so none of those are triggers).
|
||||
- **Surviving is only half the property.** The recreated WebView has to
|
||||
still be wired to the running app, which was verified by hooking
|
||||
`window._wails.dispatchWailsEvent` and backgrounding/foregrounding:
|
||||
`["IndexStatusChanged","JobsChanged","JobsChanged",
|
||||
"android:storageAccess"]`. The tempting Java-side fix — making
|
||||
`WailsBridge.initialized` static — passes the pid check and fails
|
||||
this one, because `nativeInit` is also what re-points the JNI
|
||||
reference at the new bridge.
|
||||
|
||||
## The Taskfile's device tasks uninstall the released app (2026-08-20)
|
||||
|
||||
`android:run:device` builds the **debug** variant
|
||||
(`applicationIdSuffix ".dev"`) and then runs
|
||||
`adb uninstall {{.APP_ID}}`, where `APP_ID` defaults to
|
||||
`app.yellowjacket` — the **release** id. So it deletes the user's
|
||||
installed app and its library, installs a different package, and then
|
||||
fails to launch the one it removed. `deploy-device` carries the same
|
||||
uninstall. Filed as #159; `android-tier.md` had been recommending
|
||||
`run:device` as the way onto a device.
|
||||
|
||||
This is the hazard that file already names — "The identity is declared
|
||||
twice ... **Nothing enforces that they agree**" — reached by a second
|
||||
route: the two ids differ not because someone edited one, but because
|
||||
the debug buildType suffixes it.
|
||||
|
||||
## The uninstall was there to make a bare `install` work (measured 2026-08-20)
|
||||
|
||||
Fixing #159 turned up *why* the `adb uninstall` was in all four tasks,
|
||||
which the issue does not say and which decides whether it can simply be
|
||||
deleted. The line under it was `adb install`, with **no `-r`** — and
|
||||
Android refuses an install over an existing package without it. So the
|
||||
uninstall was not a deliberate clean-slate step; it was the price of
|
||||
the missing flag, paid on every run, and `install -r` removes the
|
||||
reason for it rather than merely removing it.
|
||||
|
||||
That matters because "should the uninstall go at all" looked like a
|
||||
trade — drop it and a signing-certificate change fails with
|
||||
`INSTALL_FAILED_UPDATE_INCOMPATIBLE` instead of being handled. It is
|
||||
not a trade: nothing else was relying on it. The certificate case is
|
||||
reported with the command to run, which is what
|
||||
`scripts/android-emulator.sh` already did for `make android-install`,
|
||||
so this is one existing judgement applied consistently rather than a
|
||||
new one.
|
||||
|
||||
## `wails3 task android:run` installs on a phone (measured 2026-08-20)
|
||||
|
||||
The emulator tasks (`run`, `deploy-emulator`) used a bare `adb install`
|
||||
with no `-s`. adb with exactly one device attached uses that device
|
||||
whatever kind it is, so with a phone plugged in and no emulator
|
||||
running, the task whose summary reads "in the Android Emulator"
|
||||
installed on the phone — and, before #159 was fixed, ran
|
||||
`adb uninstall app.yellowjacket` against it first. The reported data
|
||||
loss was reachable from the *emulator* task, which is not what the
|
||||
issue describes and is worse, because nothing in the name warns you.
|
||||
|
||||
Measured after the fix, phone attached and emulator stopped:
|
||||
|
||||
```
|
||||
$ ./scripts/android-deploy.sh --apk bin/yellowjacket.apk --target emulator
|
||||
android-deploy: no emulator target is online.
|
||||
LP3LHMA531900746 device
|
||||
Start one with: make android-emulator
|
||||
```
|
||||
|
||||
The general form: **a task that names a target has to say so to adb.**
|
||||
The device tasks always filtered on `$1 !~ /^emulator-/`; the emulator
|
||||
tasks filtered on nothing at all.
|
||||
|
||||
## The package id can be read back, and costs nothing (2026-08-20)
|
||||
|
||||
`aapt2 dump packagename <apk>` answers in one word and ~40 ms, from
|
||||
`$ANDROID_HOME/build-tools/*/aapt2` (versioned, so resolved not
|
||||
pinned); `aapt dump badging` is the fallback for older build-tools and
|
||||
is what #159's own measurement used. That is cheap enough to do on
|
||||
every deploy, which is what makes "the two ids agree by construction"
|
||||
affordable rather than aspirational — the alternative considered was
|
||||
giving the debug-flavoured tasks `APP_ID` + `.dev`, which is one line
|
||||
and leaves the class of bug alive for the next flavour or suffix.
|
||||
|
||||
The guard runs **before** a target is chosen, deliberately: it is a
|
||||
question about the artifact, so it can be exercised with nothing
|
||||
plugged in, and a build whose id is wrong should be refused whether or
|
||||
not there is anything to install it onto. That is what let the negative
|
||||
test run safely with the user's phone attached:
|
||||
|
||||
```
|
||||
$ ./scripts/android-deploy.sh --apk bin/yellowjacket.apk \
|
||||
--target device --expect app.yellowjacket
|
||||
android-pkgid: refusing to act on a package this APK does not declare.
|
||||
the APK declares: app.yellowjacket.dev
|
||||
the task expects: app.yellowjacket
|
||||
rc=2
|
||||
```
|
||||
|
||||
That is exactly #159's configuration — debug APK, release id, real
|
||||
device — refused with no adb call made.
|
||||
|
||||
## `make android-emulator`'s boot wait can be satisfied by a phone (2026-08-20)
|
||||
|
||||
Noticed while booting the emulator for #159's verification, with a
|
||||
phone also attached. `scripts/android-emulator.sh start` reported
|
||||
`waiting for boot ok / android 14` about **eight seconds** after
|
||||
launching the emulator, which had not appeared in `adb devices` yet —
|
||||
`pick_device`'s last resort is "exactly one device online", and at that
|
||||
moment the one online device was the phone. So it waited for the
|
||||
phone's boot, found it long since booted, and returned. The emulator
|
||||
took another ~10 s to come up.
|
||||
|
||||
Harmless here (the emulator was up before anything used it) and a
|
||||
straightforward race otherwise: `start` should wait for a device that
|
||||
is an emulator, not for whatever `pick_device` returns. Filed as #162.
|
||||
|
||||
## The Android runtime transport is not HTTP (measured 2026-08-20)
|
||||
|
||||
Found while trying to drive the phone for #53. `wails3` routes runtime
|
||||
calls through `addJavascriptInterface` on Android, not through
|
||||
`/wails/runtime` — the WebView cannot deliver a `fetch()` POST body to
|
||||
`shouldInterceptRequest`, which the v3 source says in as many words
|
||||
(`application_android.go`, "The Android transport"). The runtime
|
||||
installs a `customTransport` over `window.wails.invokeAsync(id,
|
||||
payload)` and takes the answer on `window._wailsAndroidCallback`.
|
||||
|
||||
Two things follow, and both cost time before the source was read:
|
||||
|
||||
- **`.playwright/init-events.js` does not transfer to the device.** Its
|
||||
outbound half hooks `fetch`; a POST to `/wails/runtime` answers
|
||||
`Invalid runtime call: missing object value`, which reads like a
|
||||
wrong payload shape and is actually the interceptor receiving a URL
|
||||
with no body at all. The payload shape was right the whole time. Its
|
||||
*inbound* half is still correct, because `dispatchWailsEvent` is the
|
||||
entry point in every mode.
|
||||
- **Hooking `fetch` from an `eval` is too late on any platform.** The
|
||||
bundle captured its reference at module scope, so a wrapper installed
|
||||
afterwards records nothing — which is exactly why the harness is an
|
||||
`initScript`. Measured: zero calls captured while the app was
|
||||
demonstrably making them.
|
||||
|
||||
The working recipe is in `android-tier.md`; it chains the runtime's own
|
||||
callback rather than replacing it, so its pending calls still resolve.
|
||||
This is what makes the device a tier that can be *driven*.
|
||||
|
||||
## #53's frontend is byte-identical to the build it was reported against (2026-08-20)
|
||||
|
||||
`git diff v0.3.1 HEAD -- frontend/src/components/audio-player/seekbar/
|
||||
frontend/src/store/player-store.ts` is **empty**; the whole diff in that
|
||||
area is `backend/player/`. The phone carries the released `v0.3.1`, so
|
||||
whatever #53 saw, the component was not what changed — and v0.4.0 is
|
||||
where the player audit (#122–#127) landed.
|
||||
|
||||
Measured on that phone, current `main`, with a synthesised 4-minute
|
||||
track: the Now Playing seek bar tracks correctly when mounted
|
||||
mid-playback (`seekValue` 28 of 240), when the view is opened before
|
||||
playback starts, after a tap on the track, and across an activity
|
||||
recreation (same pid, bar resumes at 30 → 35). The issue's stated
|
||||
symptom did not reproduce in any of them.
|
||||
|
||||
Reverting **only** `backend/player/` to v0.3.1 — the frontend and
|
||||
everything else at HEAD — does reproduce a real position defect on the
|
||||
same device: six seconds into a 20-second file with no database row,
|
||||
played after a 240-second one, the bar read **01:27 of 240**. That is
|
||||
#125's stale `trackLengthMs` ("cleared only by UnloadTrack, so a file
|
||||
with no row inherited the previous track's duration"), and it is fixed
|
||||
at HEAD. Note the *shape* of it: the fraction is roughly right and the
|
||||
absolute numbers are wrong, so it presents as a clock that lies rather
|
||||
than as a handle that will not move.
|
||||
|
||||
The one-line experiment is worth remembering: v0.3.1's `backend/player`
|
||||
compiles against HEAD with a single shim
|
||||
(`SetPlaybackFinishedHandler` gained a `srcErr error` parameter), which
|
||||
makes "did the backend fix cause this" a ten-minute question instead of
|
||||
a full checkout.
|
||||
|
||||
## An overlay band is not a notification, it is a lid (measured 2026-08-20)
|
||||
|
||||
#62 asks for background jobs to become "a notification" on the phone,
|
||||
and the app has exactly one notification surface, so the first version
|
||||
of the fix put `<job-panel>` in `notification-host`'s band — which is
|
||||
`position: fixed` under the header. It renders correctly, it is on top,
|
||||
it is inside the viewport, and it is unusable.
|
||||
|
||||
At the device's 424x439 viewport a **compact** panel showing two active
|
||||
jobs is ~216px — half the screen — drawn over the content, with
|
||||
`pointer-events: auto` so it swallows every tap underneath. Nothing in
|
||||
the component tier could see it. The e2e suite could: four specs failed,
|
||||
and *none* of them was about jobs — two `phone-shell` journeys into the
|
||||
full-screen Now Playing and `header-action-overflow`'s phone case, all
|
||||
three because the band was intercepting taps meant for the app.
|
||||
|
||||
`<job-band>` is in the shell's grid instead, as a row between the top
|
||||
bar and the main panel, so it **pushes**. That is #24's one sentence
|
||||
("no action is ever unreachable at any supported size") deciding a
|
||||
layout question: a band that hides the app in order to say the app is
|
||||
busy has traded the popover's fault for a worse one.
|
||||
|
||||
Two things fell out of it worth keeping:
|
||||
|
||||
- **A finished row in flow is furniture.** The overlay could afford to
|
||||
keep terminal jobs around; a row that holds the content down after
|
||||
the work is done cannot. `job-panel` grew `active-only` for the band,
|
||||
and Settings keeps finished rows because that is where "did the last
|
||||
scan work" is asked.
|
||||
- **`job-row` already had the right density.** `variant="compact"` is
|
||||
described in its own source as "the popover density", which is
|
||||
exactly what the band is replacing — 216px against 259px for the
|
||||
same two jobs, and no per-job statistics that a phone has no room
|
||||
for.
|
||||
|
||||
## The e2e suite is the tier that sees a shell regression (2026-08-20)
|
||||
|
||||
Worth stating because it decided how #62 was verified. The change is
|
||||
one component, one stylesheet and one line of `index.html`; `make
|
||||
ui-test` (955 tests) passed on the broken overlay version and so did
|
||||
`tsc`, `lint` and the whole Go suite. The failure was three specs that
|
||||
have nothing to do with jobs, failing on `click()` timeouts.
|
||||
|
||||
The corollary for anything that draws over the shell: **run the whole
|
||||
e2e suite, not the spec you wrote.** A spec written for a feature
|
||||
asserts the feature works; what a new overlay breaks is everything
|
||||
else, and only the suite is looking at that.
|
||||
|
||||
@@ -317,60 +317,6 @@ stacking dialogs. Window state moved off that path entirely, onto a
|
||||
window still exists and `OnShutdown` has neither a context nor a
|
||||
window.
|
||||
|
||||
**An activity is a view onto the process, and `main()` runs once per
|
||||
process.** On Android the Wails entry point is `nativeInit`, which
|
||||
`MainActivity.onCreate` calls — and it does two things: it re-points the
|
||||
native library's global JNI reference at the calling `WailsBridge`, and
|
||||
it runs `go mainFunc()`. Android destroys and recreates an activity
|
||||
**without restarting the process** (a configuration change the manifest
|
||||
does not declare, memory pressure, or every background under "Don't keep
|
||||
activities"), so `main()` ran again on a live app. `application.New`
|
||||
returns the *existing* app rather than building a second one,
|
||||
`app.Run()` then refuses — `a.starting` is still true, because Android's
|
||||
`platformRun` is `select{}` and never returns — and the `os.Exit(1)`
|
||||
under that error took the **first**, healthy app down with it: its
|
||||
database, its queue, and the audio a `mediaPlayback` foreground service
|
||||
was holding the process alive to play. `mainStarted` latches it, first
|
||||
statement in `main()`.
|
||||
|
||||
Four things about it are load-bearing.
|
||||
|
||||
**The answer to "restore the session or cold-start" is settled by
|
||||
playback, not by preference.** The audio lives in the Go process, so a
|
||||
cold start on every activity recreation would stop the music mid-song —
|
||||
which is the exact thing the foreground service exists to prevent. The
|
||||
activity is a view; the app is the process. The frontend already
|
||||
cooperates, because a recreated WebView loads the page fresh and fetches
|
||||
its state from a backend that never went away.
|
||||
|
||||
**Returning early is not a degraded mode, and that is why the latch is
|
||||
in Go rather than in Java.** The obvious fix — making
|
||||
`WailsBridge.initialized` `static`, so the second `nativeInit` is
|
||||
skipped — keeps the process alive and silently breaks the app, because
|
||||
skipping `nativeInit` skips the reference re-point too: Go would keep
|
||||
executing JavaScript against the *destroyed* activity's WebView, and the
|
||||
app would open, render, and never receive another backend event. The
|
||||
latch lets `nativeInit` do its first job and declines only its second.
|
||||
|
||||
**`ServiceShutdown` has never run on Android**, and nothing should be
|
||||
built on the assumption that it will. `App.Quit()` reaches an
|
||||
`androidApp.destroy()` that is an empty method, and `Run()`'s deferred
|
||||
`shutdownServices()` cannot fire behind `select{}`. Durability on this
|
||||
platform is the persist writers, which submit on every mutation rather
|
||||
than at exit — which is also why `MainActivity.onDestroy` no longer
|
||||
calls `bridge.shutdown()`: the activity going away is not the app
|
||||
shutting down, and there is no callback for the process going away
|
||||
because Android simply kills it.
|
||||
|
||||
**No tier here can see any of this**, so the guard is split. A source
|
||||
sweep (`TestMainClaimsBeforeItDoesAnything`) asserts the latch is the
|
||||
*first* statement of `main()` — the failure it exists for is not
|
||||
deletion, which is loud, but a line creeping in above it, since a second
|
||||
`NewYellowJacketApp` opens the SQLite database again on every
|
||||
recreation. The rest is a documented device check in
|
||||
`.pi/skills/yellowjacket-dev/references/android-tier.md`, with the
|
||||
logcat signature and a one-line way to force a recreation.
|
||||
|
||||
`internalServiceMethods` auto-excludes `ServiceStartup`,
|
||||
`ServiceShutdown`, `ServiceName` and `ServeHTTP` from bindings, so this
|
||||
shape **removed** 12 spurious bindings and the bogus `context` model
|
||||
@@ -593,38 +539,11 @@ rather than renaming them.
|
||||
`ClearFinishedJobs` is global — a Clear under Libraries would discard
|
||||
the index build's history too; a finished row dismisses itself.
|
||||
|
||||
The header `job-indicator` is still the one view of everything at
|
||||
once, from every page — **on a desktop.** One consequence worth
|
||||
knowing before writing a spec: a section holding a `job-panel` also
|
||||
holds a `job-details-drawer`, whose own header carries `.header` — so
|
||||
The header `job-indicator` is untouched and is still the one view of
|
||||
everything at once, from every page. One consequence worth knowing
|
||||
before writing a spec: a section holding a `job-panel` also holds a
|
||||
`job-details-drawer`, whose own header carries `.header` — so
|
||||
`config-section .header` is ambiguous the moment a job exists.
|
||||
|
||||
**Below 600px that indicator stands down and `<job-band>` takes
|
||||
over** (#62), because a popover is a *disclosure* and background work
|
||||
is the one thing a phone should not make you open something to see —
|
||||
and because #57 deletes the bar it is anchored to and is blocked on
|
||||
it having somewhere else to live. The band is the same `job-panel`,
|
||||
so `applyJobControl` and its index-build confirmation come along
|
||||
rather than being reimplemented; `kinds="*"` is how it says "every
|
||||
kind", which is what the indicator was for.
|
||||
|
||||
Three things about it are load-bearing. **It is in the layout, not
|
||||
over it**, as its own grid row above the main panel: the first
|
||||
version put it in `notification-host`'s fixed band, which reads fine
|
||||
in a screenshot and is unusable — at 424×439 a compact panel is
|
||||
~200px of a 439px screen and it *covers* what is under it, which four
|
||||
e2e specs caught by failing on taps it was intercepting. **It shows
|
||||
active work only** (`active-only`), because in flow a finished row is
|
||||
furniture that keeps the content pushed down after the work is done;
|
||||
finished rows stay where the work was started, which is #27's rule.
|
||||
And **it renders nothing above 600px**, from `matchMedia` rather than
|
||||
a media query, because that decides whether the element *exists* —
|
||||
Settings already holds four `job-panel`s and a fifth answering for
|
||||
every kind is `bottom-nav`'s "resolved to 2 elements" trap again.
|
||||
`index.css` keeps it `display: none` outside the phone for a second
|
||||
reason: an in-flow grid child with no named area is auto-placed into
|
||||
one of the shell's rows, which is what the skip link is absolutely
|
||||
positioned to avoid.
|
||||
- `config` — TOML-based settings. Settings page uses HTMX + templ for server-rendered HTML fragments.
|
||||
- `playlist` / `smartplaylist` — Playlist CRUD and rule-based smart playlists.
|
||||
- `mediacontrols` — OS media controls behind one `Handler`: MPRIS over
|
||||
@@ -1653,50 +1572,6 @@ And **the bar does not resize when a job starts**, which is the case the
|
||||
whole thing is for — a ResizeObserver on the header alone never fires,
|
||||
so every element child is observed too.
|
||||
|
||||
**The bottom bar is three columns whose outer two are the same width,
|
||||
and that is what "centred" means.** It was `320px 1fr auto`, so the
|
||||
transport sat in the middle of the space the metadata and the queue
|
||||
button did not use — its centre was ~140px right of the window's at
|
||||
every size (#23). The outer tracks are now the same expression, so the
|
||||
middle one is centred by construction rather than by arithmetic that
|
||||
has to be redone whenever a control joins the bar.
|
||||
|
||||
Four things about it are load-bearing.
|
||||
|
||||
**The side width is the metadata's, capped at a quarter of the bar**,
|
||||
and the cap is not tidiness — it was measured as a regression first.
|
||||
Reserving the full `--now-playing-width` on *both* sides costs the
|
||||
transport twice: at 800px the outer pair wanted 640 of 800 and the seek
|
||||
bar's track fell from **257px to 61px**, and to 0 at 200% text. The
|
||||
control you drag was being squeezed to centre the buttons above it.
|
||||
With the cap it is 246px at 800, which is parity with the uncentred
|
||||
layout.
|
||||
|
||||
**The cap is a `min()` rather than a breakpoint** because
|
||||
`--now-playing-width` is *user state* — the metadata panel has a drag
|
||||
handle — and the same reasoning the queue panel's overlay mode uses
|
||||
applies: a rule that assumed the default 320 would be wrong by whatever
|
||||
the user dragged. Tying both sides to that variable is also what keeps
|
||||
the handle meaningful; a plain `1fr … 1fr` would centre the transport
|
||||
just as well and silently make dragging a no-op.
|
||||
|
||||
**The volume moved out of `audio-player` and into the bar** (#42),
|
||||
because the transport column has to hold the transport and nothing
|
||||
else or "centred" means centred with a slider bolted to one side. It
|
||||
lives in `.bar-end` with the queue button — one cell, not two columns,
|
||||
since the centring compares *columns* and a separate volume track would
|
||||
make the outer pair unequal by whatever the slider measures.
|
||||
|
||||
And **the slider is inline by default, with the popup as a setting**
|
||||
whose stored flag names the *popup*: `backend/config`'s polarity rule,
|
||||
where the zero value has to be the intended answer, so an existing
|
||||
`config.toml` with no key gets the new default without a migration.
|
||||
Inline, the icon becomes the mute toggle and is named after that action
|
||||
rather than after the state, because with the slider beside it there is
|
||||
nothing left to disclose. It stands down below 600px whatever the
|
||||
setting says — that is about the platform rather than preference, and
|
||||
is why `mediacontrols`' Android handler implements no volume callback.
|
||||
|
||||
**900 is the worst desktop width, not the 800×600 minimum.** The
|
||||
sidebar collapses to icons *below* 900, so the main panel is 843px at
|
||||
899 and 700px at 900 — the narrowest content area any desktop width
|
||||
|
||||
@@ -666,49 +666,6 @@ func (c *Config) SetAllowMeteredCatalogDownload(allow bool) error {
|
||||
return nil
|
||||
}
|
||||
|
||||
// GetPopupVolume reports whether the bottom bar's volume control is a
|
||||
// click-to-open popup rather than an inline slider (#42).
|
||||
func (c *Config) GetPopupVolume() bool {
|
||||
if c.General == nil {
|
||||
return false
|
||||
}
|
||||
|
||||
return c.General.PopupVolume
|
||||
}
|
||||
|
||||
// SetPopupVolume saves the volume control's presentation.
|
||||
//
|
||||
// Nothing to validate: both values are legal at every width, and the
|
||||
// frontend additionally stands the inline slider down below the phone
|
||||
// breakpoint whatever this says, because that is about room rather than
|
||||
// about preference.
|
||||
func (c *Config) SetPopupVolume(popup bool) error {
|
||||
if c.General == nil {
|
||||
c.General = &GeneralConfig{}
|
||||
c.General.ApplyDefaults()
|
||||
}
|
||||
|
||||
c.General.PopupVolume = popup
|
||||
|
||||
if err := c.Save(); err != nil {
|
||||
return fmt.Errorf(
|
||||
"could not save config: %w", err,
|
||||
)
|
||||
}
|
||||
|
||||
events.Emit(
|
||||
c.ctx,
|
||||
events.GeneralConfigChanged,
|
||||
map[string]any{
|
||||
"PopupVolume": popup,
|
||||
},
|
||||
)
|
||||
|
||||
c.logger.Info("volume control presentation updated", "popup", popup)
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// GetViewVisibility reports which primary views the sidebar should
|
||||
// show, answered for every known view rather than only the ones the
|
||||
// config mentions -- so the frontend filters on a value and never has
|
||||
|
||||
@@ -188,43 +188,3 @@ func TestEmit_FavoritesChangeCarriesFullConfig(t *testing.T) {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// TestEmit_PopupVolumeRoundTripsAndDefaultsToInline pins both halves of
|
||||
// #42's storage decision.
|
||||
//
|
||||
// The **default** is the load-bearing one: inline is what a fresh
|
||||
// install and an existing `config.toml` with no such key must both
|
||||
// produce, which is why the field names the popup rather than the
|
||||
// inline slider. A flag spelled the other way round would default to
|
||||
// false, hand every existing install the popup this issue exists to
|
||||
// stop being the only option, and need a migration to say otherwise.
|
||||
func TestEmit_PopupVolumeRoundTripsAndDefaultsToInline(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
conf, rec := setupRecordedConfig(t)
|
||||
|
||||
if conf.GetPopupVolume() {
|
||||
t.Error("a config with no PopupVolume key wants the popup, want inline")
|
||||
}
|
||||
|
||||
if err := conf.SetPopupVolume(true); err != nil {
|
||||
t.Fatalf("SetPopupVolume: %v", err)
|
||||
}
|
||||
|
||||
if !conf.GetPopupVolume() {
|
||||
t.Error("GetPopupVolume = false after setting it true")
|
||||
}
|
||||
|
||||
data := payloadMap(t, rec, events.GeneralConfigChanged)
|
||||
if data["PopupVolume"] != true {
|
||||
t.Errorf("PopupVolume = %v, want true", data["PopupVolume"])
|
||||
}
|
||||
|
||||
if err := conf.SetPopupVolume(false); err != nil {
|
||||
t.Fatalf("SetPopupVolume(false): %v", err)
|
||||
}
|
||||
|
||||
if conf.GetPopupVolume() {
|
||||
t.Error("GetPopupVolume = true after setting it false")
|
||||
}
|
||||
}
|
||||
|
||||
@@ -54,16 +54,6 @@ type GeneralConfig struct {
|
||||
// so an existing config with no such key refuses by default rather
|
||||
// than needing a migration to become careful.
|
||||
AllowMeteredCatalogDownload bool `toml:"AllowMeteredCatalogDownload"`
|
||||
// PopupVolume draws the bottom bar's volume as a click-to-open popup
|
||||
// instead of a slider that is always there (#42).
|
||||
//
|
||||
// The polarity is the rule this file already states twice: **the
|
||||
// zero value is the intended answer**. Inline is the new default, so
|
||||
// the flag has to name the *other* choice — an `InlineVolume bool`
|
||||
// would default to false and give every existing install the popup
|
||||
// this issue exists to stop being the only option, and would need a
|
||||
// migration to say otherwise.
|
||||
PopupVolume bool `toml:"PopupVolume"`
|
||||
}
|
||||
|
||||
// ApplyDefaults fills zero-value fields with sensible defaults.
|
||||
|
||||
+55
-25
@@ -4,28 +4,18 @@ includes:
|
||||
common: ../Taskfile.yml
|
||||
|
||||
vars:
|
||||
# APP_ID is an *assertion*, not a setting, and it has no default.
|
||||
# The *installed* package name, which every adb-driven task below uses
|
||||
# to uninstall, launch and filter. It must agree with `applicationId`
|
||||
# in app/build.gradle, and nothing enforces that.
|
||||
#
|
||||
# It used to be the id every adb-driven task below uninstalled,
|
||||
# launched and filtered, defaulting to "app.yellowjacket". It could
|
||||
# never have been a setting: `wails3 task` builds its var set from CLI
|
||||
# KEY=VALUE arguments and the Taskfile tree only -- nothing reads
|
||||
# build/config.yml, contrary to ANDROID.md, checked with --dry -- and
|
||||
# even when set it fed only the adb commands, never Gradle. So the
|
||||
# identity was declared twice, here and as `applicationId` in
|
||||
# app/build.gradle, with nothing enforcing that they agree.
|
||||
#
|
||||
# They did not agree. The debug buildType carries
|
||||
# `applicationIdSuffix ".dev"`, so the tasks that assemble a debug APK
|
||||
# addressed the *release* id -- on a device, the user's installed app
|
||||
# and their library (#159).
|
||||
#
|
||||
# The id is now read back from the built APK by scripts/android-
|
||||
# pkgid.sh, so the thing installed and the thing launched agree by
|
||||
# construction. Passing APP_ID= says "this build had better declare
|
||||
# that id", and the deploy refuses before touching anything if it does
|
||||
# not -- which is the check that would have caught #159 statically.
|
||||
APP_ID: '{{.APP_ID | default ""}}'
|
||||
# ANDROID.md says to set this in build/config.yml. That does not work
|
||||
# in beta.8, checked both ways: `wails3 task` builds its var set from
|
||||
# CLI KEY=VALUE arguments and the Taskfile tree only -- nothing reads
|
||||
# config.yml -- and even when set it feeds only these adb commands,
|
||||
# never Gradle. So the identity is declared twice, here and in
|
||||
# build.gradle, and a change to one alone means the official run and
|
||||
# deploy tasks address a package that is not installed.
|
||||
APP_ID: '{{.APP_ID | default "app.yellowjacket"}}'
|
||||
MIN_SDK: '21'
|
||||
TARGET_SDK: '35'
|
||||
# The emulator runs the host architecture; physical devices are arm64
|
||||
@@ -382,7 +372,9 @@ tasks:
|
||||
ARCH: '{{.ARCH | default .HOST_ARCH}}'
|
||||
cmds:
|
||||
- task: ensure-emulator
|
||||
- './scripts/android-deploy.sh --apk "{{.BIN_DIR}}/{{.APP_NAME}}.apk" --target emulator{{if .APP_ID}} --expect "{{.APP_ID}}"{{end}}'
|
||||
- '"{{.ADB}}" uninstall {{.APP_ID}} 2>/dev/null || true'
|
||||
- '"{{.ADB}}" install "{{.BIN_DIR}}/{{.APP_NAME}}.apk"'
|
||||
- '"{{.ADB}}" shell am start -n {{.APP_ID}}/com.wails.app.MainActivity'
|
||||
|
||||
run:
|
||||
summary: Build, install and launch a debug build in the Android Emulator
|
||||
@@ -391,7 +383,9 @@ tasks:
|
||||
- task: build
|
||||
cmds:
|
||||
- task: assemble:apk
|
||||
- './scripts/android-deploy.sh --apk "{{.BIN_DIR}}/{{.APP_NAME}}.apk" --target emulator{{if .APP_ID}} --expect "{{.APP_ID}}"{{end}}'
|
||||
- '"{{.ADB}}" uninstall {{.APP_ID}} 2>/dev/null || true'
|
||||
- '"{{.ADB}}" install "{{.BIN_DIR}}/{{.APP_NAME}}.apk"'
|
||||
- '"{{.ADB}}" shell am start -n {{.APP_ID}}/com.wails.app.MainActivity'
|
||||
|
||||
device:list:
|
||||
summary: Lists connected Android devices and emulators (serials)
|
||||
@@ -406,7 +400,25 @@ tasks:
|
||||
ARCH: arm64
|
||||
cmds:
|
||||
- task: assemble:apk
|
||||
- './scripts/android-deploy.sh --apk "{{.BIN_DIR}}/{{.APP_NAME}}.apk" --target device{{if .DEVICE_ID}} --serial "{{.DEVICE_ID}}"{{end}}{{if .APP_ID}} --expect "{{.APP_ID}}"{{end}}'
|
||||
- |
|
||||
DEVICE='{{.DEVICE_ID | default ""}}'
|
||||
if [ -z "$DEVICE" ]; then
|
||||
DEVICE="${DEVICE_ID:-}"
|
||||
fi
|
||||
if [ -z "$DEVICE" ]; then
|
||||
DEVICE=$("{{.ADB}}" devices | awk 'NR > 1 && $2 == "device" && $1 !~ /^emulator-/ { print $1; exit }')
|
||||
fi
|
||||
if [ -z "$DEVICE" ]; then
|
||||
echo "Error: no connected physical Android device found."
|
||||
echo "Pass DEVICE_ID=<serial> to target a device explicitly."
|
||||
echo "Find connected device serials with: {{.ADB}} devices"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
echo "Deploying {{.BIN_DIR}}/{{.APP_NAME}}.apk to device $DEVICE..."
|
||||
"{{.ADB}}" -s "$DEVICE" uninstall {{.APP_ID}} 2>/dev/null || true
|
||||
"{{.ADB}}" -s "$DEVICE" install "{{.BIN_DIR}}/{{.APP_NAME}}.apk"
|
||||
"{{.ADB}}" -s "$DEVICE" shell am start -n {{.APP_ID}}/com.wails.app.MainActivity
|
||||
preconditions:
|
||||
- sh: '[ -x "{{.ADB}}" ] || command -v adb'
|
||||
msg: "adb not found. Install the Android SDK platform-tools (or set ANDROID_HOME)"
|
||||
@@ -418,7 +430,25 @@ tasks:
|
||||
vars:
|
||||
ARCH: arm64
|
||||
cmds:
|
||||
- './scripts/android-deploy.sh --apk "{{.BIN_DIR}}/{{.APP_NAME}}.apk" --target device{{if .DEVICE_ID}} --serial "{{.DEVICE_ID}}"{{end}}{{if .APP_ID}} --expect "{{.APP_ID}}"{{end}}'
|
||||
- |
|
||||
DEVICE='{{.DEVICE_ID | default ""}}'
|
||||
if [ -z "$DEVICE" ]; then
|
||||
DEVICE="${DEVICE_ID:-}"
|
||||
fi
|
||||
if [ -z "$DEVICE" ]; then
|
||||
DEVICE=$("{{.ADB}}" devices | awk 'NR > 1 && $2 == "device" && $1 !~ /^emulator-/ { print $1; exit }')
|
||||
fi
|
||||
if [ -z "$DEVICE" ]; then
|
||||
echo "Error: no connected physical Android device found."
|
||||
echo "Pass DEVICE_ID=<serial> to target a device explicitly."
|
||||
echo "Find connected device serials with: {{.ADB}} devices"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
echo "Deploying {{.BIN_DIR}}/{{.APP_NAME}}.apk to device $DEVICE..."
|
||||
"{{.ADB}}" -s "$DEVICE" uninstall {{.APP_ID}} 2>/dev/null || true
|
||||
"{{.ADB}}" -s "$DEVICE" install "{{.BIN_DIR}}/{{.APP_NAME}}.apk"
|
||||
"{{.ADB}}" -s "$DEVICE" shell am start -n {{.APP_ID}}/com.wails.app.MainActivity
|
||||
preconditions:
|
||||
- sh: '[ -x "{{.ADB}}" ] || command -v adb'
|
||||
msg: "adb not found. Install the Android SDK platform-tools (or set ANDROID_HOME)"
|
||||
|
||||
@@ -891,41 +891,13 @@ public class MainActivity extends AppCompatActivity {
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* The activity going away is not the app shutting down.
|
||||
*
|
||||
* <p>The scaffold called {@code bridge.shutdown()} here, which is
|
||||
* the natural reading of onDestroy and is wrong for this app twice
|
||||
* over. Android destroys and recreates an activity for a
|
||||
* configuration change the manifest does not declare, under memory
|
||||
* pressure, and on every background if the user has "Don't keep
|
||||
* activities" on -- all **without restarting the process**. And
|
||||
* when the user really does leave, this app's reason for existing
|
||||
* in the background is that a song is playing, which is what the
|
||||
* {@code mediaPlayback} foreground service is holding the process
|
||||
* alive for. Either way, tearing the Go side down here would stop
|
||||
* the music.
|
||||
*
|
||||
* <p>It was harmless only by accident: {@code nativeShutdown} calls
|
||||
* {@code App.Quit()}, whose Android {@code destroy()} is an empty
|
||||
* method, and {@code Run()}'s deferred {@code shutdownServices()}
|
||||
* can never fire because Android's {@code platformRun} is
|
||||
* {@code select{}} and does not return. So no {@code
|
||||
* ServiceShutdown} has ever run on Android, and removing this call
|
||||
* changes nothing today -- it stops the day someone implements
|
||||
* {@code destroy()} from silently killing playback on a rotation.
|
||||
*
|
||||
* <p>There is no callback for "the process is going away"; Android
|
||||
* simply kills it. Durability on this platform is the persist
|
||||
* writers, which submit on every mutation rather than at exit.
|
||||
*
|
||||
* <p>See #52, and CLAUDE.md, "An activity is a view onto the
|
||||
* process".
|
||||
*/
|
||||
@Override
|
||||
protected void onDestroy() {
|
||||
super.onDestroy();
|
||||
unregisterSystemEventReceivers();
|
||||
if (bridge != null) {
|
||||
bridge.shutdown();
|
||||
}
|
||||
if (webView != null) {
|
||||
webView.destroy();
|
||||
}
|
||||
|
||||
@@ -129,24 +129,7 @@ public class WailsBridge {
|
||||
}
|
||||
|
||||
/**
|
||||
* Initialize the native Go library.
|
||||
*
|
||||
* <p><b>{@code initialized} is deliberately per-instance, and making
|
||||
* it {@code static} is the trap this comment exists for.</b> A
|
||||
* recreated activity builds a new bridge and calls this again, in a
|
||||
* process where the native library is already loaded and Go's
|
||||
* {@code main()} is already running -- so "initialise once per
|
||||
* process" looks like exactly the right rule. It is not, because
|
||||
* {@code nativeInit} does <i>two</i> things: it runs
|
||||
* {@code go mainFunc()}, and it stores the global JNI reference to
|
||||
* <i>this</i> bridge. Skip it and Go keeps executing JavaScript
|
||||
* against the destroyed activity's WebView: the app opens, renders,
|
||||
* and never receives another backend event.
|
||||
*
|
||||
* <p>So this is called every time, and the half that must not repeat
|
||||
* is latched on the Go side instead, at the top of {@code main()} --
|
||||
* which is also where the damage was ({@code os.Exit(1)}), and the
|
||||
* only place that can see it. See #52.
|
||||
* Initialize the native Go library
|
||||
*/
|
||||
public void initialize() {
|
||||
if (initialized) {
|
||||
|
||||
@@ -1,147 +0,0 @@
|
||||
import { test, expect, callBinding, NO_QUEUE_SOURCE } from '../support/fixtures.js';
|
||||
import type { Page } from '@playwright/test';
|
||||
|
||||
/**
|
||||
* The bottom bar's two promises (#23, #42): the transport is centred in
|
||||
* the window, and the volume is a slider rather than a popup.
|
||||
*
|
||||
* **"Centred" is measured against the window, not against the space
|
||||
* left over**, which is the whole of #23. The bar was
|
||||
* `320px 1fr auto`, so the transport sat in the middle of what the
|
||||
* metadata and the queue button did not use — its centre was ~140px
|
||||
* right of the window's at every size, which reads as an alignment
|
||||
* mistake rather than as a layout choice.
|
||||
*
|
||||
* The mechanism is that the outer two columns are the same width, so
|
||||
* this asserts the *outcome* (centre lines up) rather than the CSS. A
|
||||
* spec that checked `grid-template-columns` would pass on any build
|
||||
* that kept the declaration and broke the result.
|
||||
*/
|
||||
|
||||
/** Where the transport sits, against where the window's centre is. */
|
||||
const geometry = (app: Page) =>
|
||||
app.evaluate(() => {
|
||||
const bar = document.querySelector<HTMLElement>('.bottom-bar')!;
|
||||
const player = document.querySelector<HTMLElement>('audio-player')!;
|
||||
const b = bar.getBoundingClientRect();
|
||||
const p = player.getBoundingClientRect();
|
||||
|
||||
const seek = player.shadowRoot
|
||||
?.querySelector('seek-bar')
|
||||
?.shadowRoot?.querySelector('wa-slider');
|
||||
|
||||
return {
|
||||
offset: Math.round(p.left + p.width / 2 - (b.left + b.width / 2)),
|
||||
barHeight: Math.round(b.height),
|
||||
seekWidth: seek ? Math.round(seek.getBoundingClientRect().width) : -1,
|
||||
};
|
||||
});
|
||||
|
||||
/** Something has to be playing before the transport draws a seek bar. */
|
||||
async function play(app: Page): Promise<void> {
|
||||
const paths = await app.evaluate(async () => {
|
||||
const tracks = (await window.__yjEvents.call(
|
||||
'library.Library.GetTracks',
|
||||
[0],
|
||||
10_000,
|
||||
)) as { FilePath: string }[];
|
||||
|
||||
return tracks.slice(0, 3).map((t) => t.FilePath);
|
||||
});
|
||||
|
||||
await callBinding(app, 'queue.Queue.SetQueue', [
|
||||
paths,
|
||||
0,
|
||||
false,
|
||||
NO_QUEUE_SOURCE,
|
||||
]);
|
||||
await callBinding(app, 'queue.Queue.Play');
|
||||
await expect(app.getByTestId('now-playing-title')).not.toBeEmpty();
|
||||
}
|
||||
|
||||
test.describe('the bottom bar', () => {
|
||||
test.afterEach(async ({ app }) => {
|
||||
await callBinding(app, 'queue.Queue.Clear').catch(() => {
|
||||
/* already empty */
|
||||
});
|
||||
await app.setViewportSize({ width: 1440, height: 900 });
|
||||
});
|
||||
|
||||
/**
|
||||
* Four widths, because a centring bug is a function of width: the old
|
||||
* layout was off by half the difference between the two outer
|
||||
* columns, so it was wrong by a different amount at each one and
|
||||
* exactly right at none.
|
||||
*/
|
||||
for (const width of [800, 900, 1100, 1440]) {
|
||||
test(`centres the transport in the window at ${width}px`, async ({
|
||||
app,
|
||||
}) => {
|
||||
await app.setViewportSize({ width, height: 700 });
|
||||
await play(app);
|
||||
|
||||
await expect.poll(() => geometry(app).then((g) => g.offset)).toBe(0);
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* The seek bar is what the centring is *paid for* with, so it is
|
||||
* asserted rather than assumed.
|
||||
*
|
||||
* Reserving the metadata's full width on both sides centres the
|
||||
* transport perfectly and squeezes the control you drag: measured
|
||||
* during this work at **61px of track at 800px**, against 257 before
|
||||
* the change. The side columns are capped at a quarter of the bar for
|
||||
* that reason, and this is the number that says so — 246 at 800px,
|
||||
* which is parity with the uncentred layout.
|
||||
*/
|
||||
test('does not pay for the centring with the seek bar', async ({ app }) => {
|
||||
await app.setViewportSize({ width: 800, height: 700 });
|
||||
await play(app);
|
||||
|
||||
await expect
|
||||
.poll(() => geometry(app).then((g) => g.seekWidth))
|
||||
.toBeGreaterThan(200);
|
||||
});
|
||||
|
||||
/**
|
||||
* #42: the slider is simply there. Three gestures — click open, drag,
|
||||
* click closed — is what a bottom bar has room not to ask for.
|
||||
*/
|
||||
test('shows the volume slider without a click', async ({ app }) => {
|
||||
await app.setViewportSize({ width: 1440, height: 900 });
|
||||
|
||||
const volume = app.locator('.bottom-bar volume-control');
|
||||
|
||||
await expect(volume).toBeVisible();
|
||||
await expect(volume.locator('wa-slider')).toBeVisible();
|
||||
});
|
||||
|
||||
/**
|
||||
* And the inline icon is the mute toggle, because with the slider
|
||||
* beside it there is nothing left to disclose. The name follows the
|
||||
* action rather than the state for the same reason.
|
||||
*/
|
||||
test('names the inline icon after what it does', async ({ app }) => {
|
||||
await app.setViewportSize({ width: 1440, height: 900 });
|
||||
|
||||
await expect(
|
||||
app.locator('.bottom-bar volume-control').getByRole('button', {
|
||||
name: 'Mute',
|
||||
}),
|
||||
).toBeVisible();
|
||||
});
|
||||
|
||||
/**
|
||||
* The bar is a fixed 4em row and the transport sits in it. A slider
|
||||
* with a label grows `#slider` by 8px unless `wa-slider-label.css`
|
||||
* suppresses it, which moved the whole bar the last time — so the
|
||||
* height is pinned here rather than left to a screenshot.
|
||||
*/
|
||||
test('stays 4em tall', async ({ app }) => {
|
||||
await app.setViewportSize({ width: 1440, height: 900 });
|
||||
await play(app);
|
||||
|
||||
await expect.poll(() => geometry(app).then((g) => g.barHeight)).toBe(64);
|
||||
});
|
||||
});
|
||||
@@ -29,13 +29,18 @@ test.describe('a control says what it controls', () => {
|
||||
});
|
||||
|
||||
test('the volume slider is announced as Volume', async ({ app }) => {
|
||||
// No disclosure to open first, and no state to put back afterwards:
|
||||
// #42 made the slider inline, so it is simply there. The assertion
|
||||
// is unchanged — the *name* is the subject here, and the route to
|
||||
// the control got shorter rather than different.
|
||||
// The popup renders no slider at all while closed, the same way the
|
||||
// queue panel renders no list — so this has to open it first.
|
||||
await app.getByRole('button', { name: /volume/i }).click();
|
||||
|
||||
await expect(
|
||||
app.getByRole('slider', { name: 'Volume' }),
|
||||
).toBeVisible();
|
||||
|
||||
// Leave the transport as it was found: the specs share one page in
|
||||
// file order, and an open popup covers the buttons beneath it.
|
||||
await app.keyboard.press('Escape');
|
||||
await app.locator('body').click({ position: { x: 5, y: 5 } });
|
||||
});
|
||||
|
||||
test('naming the slider did not move the transport', async ({ app }) => {
|
||||
|
||||
@@ -1,204 +0,0 @@
|
||||
import { test, expect } from '../support/fixtures.js';
|
||||
|
||||
/**
|
||||
* #62. On a phone, background work is shown in the notification band
|
||||
* and the header indicator stands down.
|
||||
*
|
||||
* The report was that the indicator's popover "is obscured by other UI,
|
||||
* so it cannot be read while jobs run". Worth saying plainly: **that
|
||||
* symptom did not reproduce in this tier.** Measured at the device's
|
||||
* own 424x439 viewport, the popover was neither clipped nor covered —
|
||||
* `elementFromPoint` at its centre returned the indicator at every
|
||||
* width tried. So this is not a fix for a stacking bug, and a spec
|
||||
* asserting one would be a spec asserting something that was never
|
||||
* true here.
|
||||
*
|
||||
* What is true regardless, and is what these assert:
|
||||
*
|
||||
* - a popover is a **disclosure**, and it is anchored to a bar 3.25em
|
||||
* tall on a screen 439px tall. Background work is the one thing a
|
||||
* phone should not make you open something to see.
|
||||
* - #57 deletes that bar and is *blocked on this issue*, because the
|
||||
* indicator needs somewhere else to live first. Somewhere else is
|
||||
* the band, and the test that matters for #57 is that the bar no
|
||||
* longer holds the indicator at all.
|
||||
*
|
||||
* This is the media-query tier by necessity: a query inside a shadow
|
||||
* root is answered by the viewport, and `notification-host` decides
|
||||
* whether the panel *exists* from `matchMedia`. The component tier
|
||||
* cannot set either.
|
||||
*/
|
||||
|
||||
type Page = import('@playwright/test').Page;
|
||||
|
||||
const JOBS = [
|
||||
{
|
||||
id: 'phone:scan',
|
||||
kind: 'library-scan',
|
||||
state: 'running',
|
||||
title: 'Scanning Music',
|
||||
current: 40,
|
||||
total: 100,
|
||||
caps: { pausable: true, cancellable: true },
|
||||
},
|
||||
{
|
||||
id: 'phone:idx',
|
||||
kind: 'index-build',
|
||||
state: 'running',
|
||||
title: 'Building the search index',
|
||||
current: 2,
|
||||
total: 9,
|
||||
caps: { pausable: true, cancellable: true },
|
||||
},
|
||||
];
|
||||
|
||||
/** The panel the band renders. Playwright's CSS engine pierces open
|
||||
* shadow roots, which is what keeps this one line. */
|
||||
const bandPanel = (page: Page) => page.locator('job-band').locator('job-panel');
|
||||
|
||||
const PHONE = { width: 424, height: 439 };
|
||||
const DESKTOP = { width: 1100, height: 800 };
|
||||
|
||||
test.describe('background jobs on a phone', () => {
|
||||
test('are shown in the band, without opening anything', async ({
|
||||
app,
|
||||
testctl,
|
||||
}) => {
|
||||
await app.setViewportSize(PHONE);
|
||||
await testctl.emit('JobsChanged', JOBS);
|
||||
|
||||
await expect(bandPanel(app)).toBeVisible();
|
||||
|
||||
// Both jobs, drawn by real `job-row`s -- asking the rows what they
|
||||
// hold rather than reading the panel's text, which would pass
|
||||
// whether or not a row rendered. Playwright's CSS engine pierces
|
||||
// open shadow roots, which is what makes this one line;
|
||||
// `querySelectorAll` does not, and stops at `job-panel`.
|
||||
await expect(bandPanel(app).locator('job-row')).toHaveCount(2);
|
||||
|
||||
await expect(
|
||||
bandPanel(app).locator('job-row').first(),
|
||||
).toContainText('Scanning Music');
|
||||
});
|
||||
|
||||
/**
|
||||
* The #57 assertion. Not "the indicator is invisible" — that could be
|
||||
* true because the bar overflowed — but that the shell's own rule
|
||||
* puts it away at this width.
|
||||
*/
|
||||
test('leave the top bar, which is what #57 is waiting for', async ({
|
||||
app,
|
||||
testctl,
|
||||
}) => {
|
||||
await app.setViewportSize(PHONE);
|
||||
await testctl.emit('JobsChanged', JOBS);
|
||||
await expect(bandPanel(app)).toBeVisible();
|
||||
|
||||
await expect(app.locator('job-indicator')).toBeHidden();
|
||||
});
|
||||
|
||||
/**
|
||||
* The property the first attempt at this got wrong, so it is the one
|
||||
* worth pinning: the band is **in the layout**, not over it.
|
||||
*
|
||||
* A fixed band reads fine in a screenshot and is unusable -- at
|
||||
* 424x439 a compact panel is ~200px of a 439px screen and it covers
|
||||
* what is under it. Four specs failed on that version, two
|
||||
* phone-shell journeys and the header's action menu, because the
|
||||
* panel was intercepting the taps. So: nothing of the app is
|
||||
* underneath it, and the main panel starts below it.
|
||||
*/
|
||||
test('push the content down rather than covering it', async ({
|
||||
app,
|
||||
testctl,
|
||||
}) => {
|
||||
await app.setViewportSize(PHONE);
|
||||
|
||||
const before = await app
|
||||
.getByTestId('main-content')
|
||||
.evaluate((el) => el.getBoundingClientRect().top);
|
||||
|
||||
await testctl.emit('JobsChanged', JOBS);
|
||||
await expect(bandPanel(app)).toBeVisible();
|
||||
|
||||
const after = await app.evaluate(() => {
|
||||
const band = document.querySelector('job-band') as HTMLElement;
|
||||
const main = document.querySelector(
|
||||
'[data-testid="main-content"]',
|
||||
) as HTMLElement;
|
||||
const b = band.getBoundingClientRect();
|
||||
const m = main.getBoundingClientRect();
|
||||
|
||||
// What the browser reports at the band's own centre. If this is
|
||||
// anything but the band, the band is sitting on top of it.
|
||||
const hit = document.elementFromPoint(
|
||||
Math.round(b.x + b.width / 2),
|
||||
Math.round(b.y + b.height / 2),
|
||||
);
|
||||
|
||||
return {
|
||||
mainTop: m.top,
|
||||
bandBottom: b.bottom,
|
||||
withinViewport: b.bottom <= window.innerHeight + 0.5,
|
||||
hit: hit?.tagName.toLowerCase() ?? null,
|
||||
};
|
||||
});
|
||||
|
||||
expect({
|
||||
pushed: after.mainTop > before,
|
||||
mainClearsBand: after.mainTop >= after.bandBottom - 0.5,
|
||||
withinViewport: after.withinViewport,
|
||||
hit: after.hit,
|
||||
}).toEqual({
|
||||
pushed: true,
|
||||
mainClearsBand: true,
|
||||
withinViewport: true,
|
||||
hit: 'job-band',
|
||||
});
|
||||
});
|
||||
|
||||
/**
|
||||
* A running job repaints several times a second. The stack it sits
|
||||
* beside is `role="status" aria-live="polite"`, and a progress bar
|
||||
* inside a live region is a screen reader reading a number out over
|
||||
* and over — so the two are siblings in the band rather than one
|
||||
* list, and this is what says so.
|
||||
*/
|
||||
test('are not inside the live region they sit beside', async ({
|
||||
app,
|
||||
testctl,
|
||||
}) => {
|
||||
await app.setViewportSize(PHONE);
|
||||
await testctl.emit('JobsChanged', JOBS);
|
||||
await expect(bandPanel(app)).toBeVisible();
|
||||
|
||||
const insideLiveRegion = await app.evaluate(() => {
|
||||
const band = document.querySelector('job-band');
|
||||
|
||||
// Neither the band itself nor anything it is nested in may be a
|
||||
// live region -- `closest` answers both at once.
|
||||
return !!band?.closest('[aria-live]') || band?.hasAttribute('aria-live');
|
||||
});
|
||||
|
||||
expect(insideLiveRegion).toBe(false);
|
||||
});
|
||||
|
||||
/**
|
||||
* `bottom-nav` rendering its duplicate `<app-sidebar>` unconditionally
|
||||
* broke 30 specs with "resolved to 2 elements" on a viewport where it
|
||||
* was not even visible. Settings already holds four `job-panel`s, so
|
||||
* a fifth that answers for *every* kind is the same trap — which is
|
||||
* why the band decides from `matchMedia` whether the element exists
|
||||
* rather than hiding it with CSS.
|
||||
*/
|
||||
test('do not leave a second panel behind on a desktop', async ({
|
||||
app,
|
||||
testctl,
|
||||
}) => {
|
||||
await app.setViewportSize(DESKTOP);
|
||||
await testctl.emit('JobsChanged', JOBS);
|
||||
|
||||
await expect(app.locator('job-indicator')).toBeVisible();
|
||||
await expect(bandPanel(app)).toHaveCount(0);
|
||||
});
|
||||
});
|
||||
@@ -226,26 +226,9 @@ test.describe('the shell on a phone', () => {
|
||||
await expect(app.locator('now-playing')).toBeVisible();
|
||||
|
||||
// Volume is the hardware keys' job on a phone, and a 4px seek bar
|
||||
// is not a thumb target -- both belong to the full-screen
|
||||
// now-playing view.
|
||||
//
|
||||
// `.bottom-bar volume-control`, not `audio-player volume-control`:
|
||||
// #42 moved the control out of that component and into the bar, and
|
||||
// **the old locator would have kept passing** — `toBeHidden()` is
|
||||
// satisfied by an element that does not exist, so this assertion
|
||||
// would have gone on reporting success about nothing. Its partner
|
||||
// below is what makes this one mean something.
|
||||
await expect(app.locator('.bottom-bar volume-control')).toBeHidden();
|
||||
|
||||
// The element is there and hidden, rather than absent: the check
|
||||
// above cannot tell those apart on its own.
|
||||
await expect(app.locator('.bottom-bar volume-control')).toHaveCount(1);
|
||||
|
||||
// And the seek bar is still inside the transport, where it stands
|
||||
// down by its own media query.
|
||||
await expect(
|
||||
app.locator('audio-player').locator('seek-bar'),
|
||||
).toBeHidden();
|
||||
// is not a thumb target -- both belong to a later phase's
|
||||
// full-screen now-playing view.
|
||||
await expect(app.locator('audio-player volume-control')).toBeHidden();
|
||||
});
|
||||
});
|
||||
|
||||
|
||||
@@ -108,23 +108,7 @@ test.describe('the top bar fits the window', () => {
|
||||
|
||||
// The indicator has to actually be up, or this test passes by
|
||||
// measuring the idle case under another name.
|
||||
//
|
||||
// Below 600px there is deliberately no indicator to measure:
|
||||
// #62 stands it down and puts the rows in `<job-band>` instead,
|
||||
// in the layout under the bar. So at 390 the assertion is that
|
||||
// it *is* away and the bar still fits -- which is the same
|
||||
// property (the bar has nothing hanging out of it) reached by the
|
||||
// other branch of the same rule, rather than a width quietly
|
||||
// dropped from the list.
|
||||
const phone = width < 600;
|
||||
|
||||
await expect(app.locator('job-indicator'))[
|
||||
phone ? 'toBeHidden' : 'toBeVisible'
|
||||
]();
|
||||
|
||||
if (phone) {
|
||||
await expect(app.locator('job-band').locator('job-row')).toHaveCount(1);
|
||||
}
|
||||
await expect(app.locator('job-indicator')).toBeVisible();
|
||||
|
||||
await expect.poll(() => overflowingChildren(app)).toEqual([]);
|
||||
});
|
||||
|
||||
@@ -69,14 +69,6 @@ export function GetPinDefaultPlaylist(): $CancellablePromise<boolean> {
|
||||
return $Call.ByID(3818283301);
|
||||
}
|
||||
|
||||
/**
|
||||
* GetPopupVolume reports whether the bottom bar's volume control is a
|
||||
* click-to-open popup rather than an inline slider (#42).
|
||||
*/
|
||||
export function GetPopupVolume(): $CancellablePromise<boolean> {
|
||||
return $Call.ByID(2885777);
|
||||
}
|
||||
|
||||
/**
|
||||
* GetQueueFallback returns what plays, if anything, once the queue
|
||||
* runs out.
|
||||
@@ -215,18 +207,6 @@ export function SetPinDefaultPlaylist(pin: boolean): $CancellablePromise<void> {
|
||||
return $Call.ByID(372446849, pin);
|
||||
}
|
||||
|
||||
/**
|
||||
* SetPopupVolume saves the volume control's presentation.
|
||||
*
|
||||
* Nothing to validate: both values are legal at every width, and the
|
||||
* frontend additionally stands the inline slider down below the phone
|
||||
* breakpoint whatever this says, because that is about room rather than
|
||||
* about preference.
|
||||
*/
|
||||
export function SetPopupVolume(popup: boolean): $CancellablePromise<void> {
|
||||
return $Call.ByID(1430308453, popup);
|
||||
}
|
||||
|
||||
/**
|
||||
* SetQueueFallback validates and saves a new queue-fallback mode.
|
||||
*/
|
||||
|
||||
+5
-121
@@ -211,39 +211,7 @@ body div.sidebar {
|
||||
padding: 0.25em;
|
||||
background-color: var(--yj-bg-elevated, #343a40);
|
||||
display: grid;
|
||||
/* Three columns whose outer two are the *same* width, which is what
|
||||
centres the middle one (#23). It was `var(--now-playing-width) 1fr
|
||||
auto`, so the transport's centre sat at `W/2 + 140px` — in the
|
||||
middle of the space left over, which is not the same thing and
|
||||
reads as an alignment mistake at every window size.
|
||||
|
||||
The outer width is still `--now-playing-width`, so **the metadata
|
||||
panel's drag handle keeps meaning something**: widening it takes
|
||||
room from the transport on both sides at once, symmetrically. An
|
||||
`1fr … 1fr` pair would have centred the transport just as well and
|
||||
silently made that handle a no-op.
|
||||
|
||||
**The cap is what stops that being a regression**, and it was
|
||||
measured as one first. Reserving the full metadata width on both
|
||||
sides costs the transport twice: at 800px the outer pair wanted
|
||||
640 of 800, and the seek bar's track went from 257px to 61px
|
||||
(and to 0 at 200% text) — the control you drag, squeezed out to
|
||||
centre the buttons above it. So the side tracks are the metadata
|
||||
width *or a quarter of the bar*, whichever is smaller, which
|
||||
leaves the drag handle meaningful everywhere it has room to be
|
||||
and hands the difference to the transport where it does not.
|
||||
|
||||
`minmax(0, …)` on the outer tracks and `min-content` on the middle
|
||||
decide who yields when even that is not enough: the metadata and
|
||||
the end group shrink (both truncate; neither loses an action), and
|
||||
the transport keeps at least its buttons. Without the `min-content`
|
||||
floor the middle collapses first, because a `1fr` track's minimum
|
||||
is `auto` only until something else insists. */
|
||||
--bar-side: min(var(--now-playing-width, 320px), 25%);
|
||||
grid-template-columns:
|
||||
minmax(0, var(--bar-side))
|
||||
minmax(min-content, 1fr)
|
||||
minmax(0, var(--bar-side));
|
||||
grid-template-columns: var(--now-playing-width, 320px) 1fr auto;
|
||||
align-items: center;
|
||||
contain: layout style;
|
||||
|
||||
@@ -271,44 +239,23 @@ body div.sidebar {
|
||||
text-wrap-mode: nowrap;
|
||||
overflow: hidden;
|
||||
|
||||
/* `& p`, not `p`. **A nested rule that begins with a bare
|
||||
element selector is silently dropped before Chrome 120**
|
||||
(relaxed nesting), and the phone this app runs on renders
|
||||
in Chrome 113 -- so this ellipsis, and the two rules
|
||||
below, have never applied on the device. Nothing fails;
|
||||
the text simply overflows there. The `&` form is valid in
|
||||
both, which is why it is used for every element selector
|
||||
in this file's nested blocks. */
|
||||
& p {
|
||||
p {
|
||||
overflow: hidden;
|
||||
text-overflow: ellipsis;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
& now-playing {
|
||||
now-playing {
|
||||
overflow: hidden;
|
||||
}
|
||||
|
||||
& audio-player {
|
||||
audio-player {
|
||||
margin: 0.5em 1em;
|
||||
min-width: 0;
|
||||
}
|
||||
|
||||
/* The right-hand group, and the thing the left column is matched
|
||||
against. It is one grid cell rather than two columns because the
|
||||
centring rule above compares *columns*: volume and the queue
|
||||
button in separate tracks would make the outer pair unequal by
|
||||
whatever the volume happens to measure. */
|
||||
.bar-end {
|
||||
justify-self: end;
|
||||
display: flex;
|
||||
align-items: center;
|
||||
gap: 0.25em;
|
||||
min-width: 0;
|
||||
}
|
||||
|
||||
#queue-button {
|
||||
justify-self: end;
|
||||
background: none;
|
||||
border: none;
|
||||
color: inherit;
|
||||
@@ -414,7 +361,6 @@ body div.sidebar {
|
||||
body {
|
||||
grid-template:
|
||||
"top-bar" 3.25em
|
||||
"jobs-band" auto
|
||||
"main-panel" 1fr
|
||||
"bottom-bar" auto
|
||||
"bottom-nav" auto
|
||||
@@ -494,11 +440,6 @@ body div.sidebar {
|
||||
}
|
||||
|
||||
@media (max-width: 599px) {
|
||||
/* The phone keeps the two-part bar it had: metadata, then the
|
||||
transport and the queue button. There is no third column to
|
||||
balance because the centring the desktop does is a luxury of
|
||||
having room — at 360px the metadata needs all of the space the
|
||||
controls do not. */
|
||||
.bottom-bar {
|
||||
grid-template-columns: minmax(0, 1fr) auto auto;
|
||||
gap: 0.25em;
|
||||
@@ -507,61 +448,4 @@ body div.sidebar {
|
||||
.bottom-bar audio-player {
|
||||
margin: 0.25em;
|
||||
}
|
||||
|
||||
/* Volume stands down here whatever the setting says, because this
|
||||
is about room and about the platform rather than about
|
||||
preference: the hardware keys own volume on a phone, which is
|
||||
also why mediacontrols' Android handler implements no volume
|
||||
callback. It moved from `audio-player`'s own media query when
|
||||
#42 moved the control into the bar — same rule, and now stated
|
||||
where the element actually is.
|
||||
|
||||
`.bottom-bar volume-control`, not the one in
|
||||
`now-playing-view`: that view is the phone's transport and is
|
||||
where a slider does belong. */
|
||||
.bottom-bar volume-control {
|
||||
display: none;
|
||||
}
|
||||
}
|
||||
|
||||
/* Out of the desktop grid entirely. `job-band` renders nothing above
|
||||
600px anyway, but an in-flow grid child with no named area is
|
||||
auto-placed into a row of the shell -- the same trap the skip link is
|
||||
absolutely positioned to avoid. */
|
||||
body job-band {
|
||||
display: none;
|
||||
}
|
||||
|
||||
/* #62. The job indicator stands down on the phone, and its work is
|
||||
shown in the notification band instead (notification-host).
|
||||
|
||||
Three reasons, and the first is the report: its popover is anchored
|
||||
to the top bar, which is 3.25em here on a viewport 439 CSS px tall,
|
||||
and it was reported as unreadable behind other UI. The second is
|
||||
that a popover is a disclosure, and background work is the one thing
|
||||
a phone should not make you disclose. The third is #57, which
|
||||
deletes this bar entirely and is blocked on the indicator having
|
||||
somewhere else to live -- this is that somewhere.
|
||||
|
||||
`display: none` rather than a fit step: `services/top-bar-fit.ts`
|
||||
already skips children whose computed display is none, so the bar's
|
||||
measurement simply sees one fewer child, and `[compact]` toggling on
|
||||
a hidden element costs nothing. */
|
||||
@media (max-width: 599px) {
|
||||
.top-bar job-indicator {
|
||||
display: none;
|
||||
}
|
||||
|
||||
/* ...and its rows appear here, in the grid row above the content.
|
||||
In flow rather than over it: a fixed band reads fine in a
|
||||
screenshot and is unusable, because at 424x439 a compact panel
|
||||
is ~200px of a 439px screen and it *covers* what is under it.
|
||||
Measured, not assumed -- four e2e specs failed on that version,
|
||||
two phone-shell journeys and the header's action menu, because
|
||||
the panel was intercepting the taps. */
|
||||
body job-band {
|
||||
display: block;
|
||||
grid-area: jobs-band;
|
||||
background-color: var(--yj-bg-elevated, #343a40);
|
||||
}
|
||||
}
|
||||
|
||||
+7
-30
@@ -30,14 +30,6 @@
|
||||
<search-bar></search-bar>
|
||||
<job-indicator></job-indicator>
|
||||
</header>
|
||||
<!-- The phone's view of background work (#62): below 600px the
|
||||
indicator above stands down and its rows appear here instead,
|
||||
in the layout rather than over it. `display: none` above that
|
||||
width in index.css, which is also what keeps it out of the
|
||||
desktop grid -- an in-flow child with no named area is
|
||||
auto-placed into one of the shell's rows, which is the trap the
|
||||
skip link is absolutely positioned to avoid. -->
|
||||
<job-band></job-band>
|
||||
<div class="sidebar">
|
||||
<app-sidebar></app-sidebar>
|
||||
</div>
|
||||
@@ -48,31 +40,16 @@
|
||||
</main>
|
||||
<queue-panel id="queue-panel"></queue-panel>
|
||||
</div>
|
||||
<!-- Three columns, and the outer two are the same width, which is
|
||||
what makes the middle one *centred* rather than merely in the
|
||||
middle of what is left (#23). The transport used to sit in a
|
||||
`320px 1fr auto` grid, so its centre was ~140px right of the
|
||||
window's.
|
||||
|
||||
That is also why the volume moved out of `audio-player` and
|
||||
into the bar (#42): the transport column has to contain the
|
||||
transport and nothing else, or "centred" means centred with a
|
||||
slider bolted to one side. It joins the queue button in
|
||||
`.bar-end`, whose width is what the left column is matched
|
||||
against. -->
|
||||
<footer class="bottom-bar">
|
||||
<now-playing></now-playing>
|
||||
<audio-player></audio-player>
|
||||
<div class="bar-end">
|
||||
<volume-control></volume-control>
|
||||
<button aria-label="Toggle queue" aria-controls="queue-panel" aria-expanded="false"
|
||||
id="queue-button">
|
||||
<!-- ICON_QUEUE in src/utils/icon-language.ts, written out
|
||||
because this file has no module scope. It was `list`,
|
||||
which is the Playlists destination's icon. -->
|
||||
<wa-icon name="bars-staggered"></wa-icon>
|
||||
</button>
|
||||
</div>
|
||||
<button aria-label="Toggle queue" aria-controls="queue-panel" aria-expanded="false"
|
||||
id="queue-button">
|
||||
<!-- ICON_QUEUE in src/utils/icon-language.ts, written out
|
||||
because this file has no module scope. It was `list`,
|
||||
which is the Playlists destination's icon. -->
|
||||
<wa-icon name="bars-staggered"></wa-icon>
|
||||
</button>
|
||||
</footer>
|
||||
<!-- The phone's primary navigation, hidden above 600px by
|
||||
index.css. Eager rather than a chunk, for the reason
|
||||
|
||||
@@ -18,9 +18,6 @@
|
||||
// track-list — index.html renders one, so it is the first paint.
|
||||
// ---------------------------------------------------------------------------
|
||||
import '@components/audio-player/audio-player.ts';
|
||||
// In the bar rather than inside `audio-player` since #42, so the shell
|
||||
// is what has to register it.
|
||||
import '@components/audio-player/volume-control/volume-control.ts';
|
||||
import '@components/track-list/track-list.ts';
|
||||
import '@components/now-playing/now-playing.ts';
|
||||
import '@components/sidebar/app-sidebar.ts';
|
||||
@@ -38,11 +35,6 @@ import '@components/confirm-dialog/confirm-dialog.ts';
|
||||
// not know what is going on. It costs a dialog and a table.
|
||||
import '@components/shortcuts-overlay/shortcuts-overlay.ts';
|
||||
import '@components/jobs/job-indicator.ts';
|
||||
// The phone's half of the same thing (#62). Eager because it is part
|
||||
// of the shell's first paint below 600px, and because a band that has
|
||||
// to fetch a chunk before it can say the app is busy is late by
|
||||
// exactly the interval it exists to explain.
|
||||
import '@components/jobs/job-band.ts';
|
||||
import '@awesome.me/webawesome/dist/styles/themes/default.css';
|
||||
import '@awesome.me/webawesome/dist/components/icon/icon.js';
|
||||
import { setBasePath } from '@awesome.me/webawesome/dist/webawesome.js';
|
||||
|
||||
@@ -3,6 +3,7 @@ import { customElement } from 'lit/decorators.js';
|
||||
import '@awesome.me/webawesome/dist/components/icon/icon.js';
|
||||
import './controls/player-controls';
|
||||
import './seekbar/seek-bar';
|
||||
import './volume-control/volume-control';
|
||||
import '../notifications/inline-notice';
|
||||
import { PlayerRegion } from '@store/player-store';
|
||||
import { designTokens } from '../../styles/tokens.css';
|
||||
@@ -29,7 +30,6 @@ export class AudioPlayer extends LitElement {
|
||||
|
||||
.player-main {
|
||||
flex: 1;
|
||||
min-width: 0;
|
||||
}
|
||||
|
||||
/* The phone transport (plan 016 B2): the buttons, and nothing
|
||||
@@ -37,17 +37,14 @@ export class AudioPlayer extends LitElement {
|
||||
viewport, not by the host, so this is the component saying what
|
||||
it drops at phone width rather than the shell reaching in.
|
||||
|
||||
Volume goes because the hardware keys own it on a phone --
|
||||
Android routes them to the media stream, which is also why
|
||||
mediacontrols' Android handler implements no volume callback.
|
||||
The seek bar goes because a 4px-tall target dragged with a thumb
|
||||
is not a seek control; seeking belongs to the full-screen
|
||||
now-playing view.
|
||||
|
||||
Volume used to go from here too, and now goes from index.css
|
||||
instead: #42 moved the control out of this component and into
|
||||
the bar, so the shell is what can hide it. The reason is
|
||||
unchanged -- the hardware keys own volume on a phone, which is
|
||||
also why mediacontrols' Android handler implements no volume
|
||||
callback. */
|
||||
now-playing view, which is the next phase. */
|
||||
@media (max-width: 599px) {
|
||||
volume-control,
|
||||
seek-bar {
|
||||
display: none;
|
||||
}
|
||||
@@ -68,6 +65,7 @@ export class AudioPlayer extends LitElement {
|
||||
<seek-bar></seek-bar>
|
||||
</div>
|
||||
</div>
|
||||
<volume-control></volume-control>
|
||||
</div>
|
||||
`;
|
||||
}
|
||||
|
||||
@@ -22,24 +22,6 @@ export class SeekBar extends LitElement {
|
||||
@state()
|
||||
private seekValue: number = 0;
|
||||
|
||||
/**
|
||||
* Whether the user is dragging the thumb right now.
|
||||
*
|
||||
* It is `@state` rather than a plain field because `updated()` owns
|
||||
* the interval and only reactive state brings `updated()` round. A
|
||||
* bare `stopProgress()` in the input handler mutated nothing, so
|
||||
* nothing re-rendered, so the tail of `updated()` that restarts the
|
||||
* interval never ran — and the only things that could restart it
|
||||
* were a `change` event or the next backend report. Any `input`
|
||||
* without a committed `change` therefore froze the interpolation:
|
||||
* a drag cancelled outside the element, a pointer taken by a scroll,
|
||||
* or a touch on the track treated as a scrub, which on a phone are
|
||||
* ordinary gestures. While playing, the 1 Hz report papered over it
|
||||
* within a second; with reports not arriving it was permanent.
|
||||
*/
|
||||
@state()
|
||||
private dragging: boolean = false;
|
||||
|
||||
/** Whether the right-hand clock shows time remaining or total. */
|
||||
@state()
|
||||
private showRemaining: boolean = true;
|
||||
@@ -151,7 +133,6 @@ export class SeekBar extends LitElement {
|
||||
override disconnectedCallback() {
|
||||
super.disconnectedCallback();
|
||||
this.stopProgress();
|
||||
this.endDrag();
|
||||
}
|
||||
|
||||
override updated() {
|
||||
@@ -173,33 +154,18 @@ export class SeekBar extends LitElement {
|
||||
// A report for a track that is no longer loaded is stale by
|
||||
// definition: the change id is the only thing that distinguishes
|
||||
// it, since the same file can play twice in a row.
|
||||
//
|
||||
// A report arriving mid-drag is deliberately *not* applied: the
|
||||
// thumb belongs to the finger on it, and adopting a report once a
|
||||
// second pulls it back out from under them. The seq is left
|
||||
// unrecorded too, so the first report after the drag still counts
|
||||
// as fresh.
|
||||
const position = this.player.position;
|
||||
const forThisTrack =
|
||||
position !== null && position.trackChangeId === currentChangeId;
|
||||
|
||||
if (
|
||||
position &&
|
||||
forThisTrack &&
|
||||
!this.dragging &&
|
||||
position.seq !== this.previousPositionSeq
|
||||
) {
|
||||
if (position && forThisTrack && position.seq !== this.previousPositionSeq) {
|
||||
this.previousPositionSeq = position.seq;
|
||||
this.seekValue = position.positionSeconds;
|
||||
this.stopProgress();
|
||||
}
|
||||
|
||||
// One owner for the interval, and this is it. Every other place
|
||||
// that wants it started or stopped says so by changing state that
|
||||
// brings us back here, so the timer cannot be left running by a
|
||||
// path that forgot to stop it or stopped by a path that forgot to
|
||||
// start it again.
|
||||
if (this.isPlaying && this.hasTrack && !this.dragging) {
|
||||
// Start/stop progress interval based on playback state
|
||||
if (this.isPlaying && this.hasTrack) {
|
||||
this.startProgress();
|
||||
} else {
|
||||
this.stopProgress();
|
||||
@@ -244,48 +210,18 @@ export class SeekBar extends LitElement {
|
||||
|
||||
private handleChange(e: Event) {
|
||||
const newSeekVal = (e.target as WaSlider).value;
|
||||
this.endDrag();
|
||||
this.setSeekValue(newSeekVal);
|
||||
this.player.seek(newSeekVal);
|
||||
}
|
||||
|
||||
/**
|
||||
* The user is moving the thumb.
|
||||
*
|
||||
* This only records that fact; `updated()` decides what it means for
|
||||
* the interval. `seekValue` follows the slider so the clocks track
|
||||
* the thumb during the drag rather than jumping when it is released.
|
||||
*/
|
||||
private handleInput(e: Event) {
|
||||
this.setSeekValue((e.target as WaSlider).value);
|
||||
|
||||
if (this.dragging) {
|
||||
return;
|
||||
if (this.isPlaying) {
|
||||
this.startProgress();
|
||||
}
|
||||
|
||||
this.dragging = true;
|
||||
|
||||
// A drag that never commits must not strand the flag, or this fix
|
||||
// turns a stall of up to one second into a permanent one -- which
|
||||
// is the failure it exists to remove. `change` is the ordinary
|
||||
// end; these are the ones that are not, and they are on the
|
||||
// document because the pointer is routinely released outside the
|
||||
// element it started in. A drag's listeners belong to the drag,
|
||||
// so they go on with it and come off with it.
|
||||
document.addEventListener('pointerup', this.endDrag);
|
||||
document.addEventListener('pointercancel', this.endDrag);
|
||||
document.addEventListener('touchend', this.endDrag);
|
||||
document.addEventListener('touchcancel', this.endDrag);
|
||||
}
|
||||
|
||||
private endDrag = () => {
|
||||
document.removeEventListener('pointerup', this.endDrag);
|
||||
document.removeEventListener('pointercancel', this.endDrag);
|
||||
document.removeEventListener('touchend', this.endDrag);
|
||||
document.removeEventListener('touchcancel', this.endDrag);
|
||||
|
||||
this.dragging = false;
|
||||
};
|
||||
// Stops progress while user is dragging the thumb
|
||||
private handleInput() {
|
||||
this.stopProgress();
|
||||
}
|
||||
|
||||
private setSeekValue(val: number) {
|
||||
if (val < 0) val = 0;
|
||||
|
||||
@@ -4,7 +4,6 @@ import '@awesome.me/webawesome/dist/components/icon/icon.js';
|
||||
import '@awesome.me/webawesome/dist/components/slider/slider.js';
|
||||
import type WaSlider from '@awesome.me/webawesome/dist/components/slider/slider.js';
|
||||
import { PlayerController } from '@store/controllers/player-controller';
|
||||
import { volumeStyleStore } from '@store/volume-style-store';
|
||||
import { designTokens } from '../../../styles/tokens.css';
|
||||
import { waSliderLabel } from '../../../styles/wa-slider-label.css';
|
||||
|
||||
@@ -23,12 +22,6 @@ export class VolumeControl extends LitElement {
|
||||
@state()
|
||||
private showSlider = false;
|
||||
|
||||
/** Whether this is the click-to-open popup rather than a slider. */
|
||||
@state()
|
||||
private popup = volumeStyleStore.popup;
|
||||
|
||||
private unsubscribeStyle?: () => void;
|
||||
|
||||
// Locally-tracked volume while the user is actively dragging or scrolling.
|
||||
// The store's volume only updates once the backend echoes VolumeChanged
|
||||
// (which we debounce), so we track intent here for responsive UI and to let
|
||||
@@ -93,31 +86,11 @@ export class VolumeControl extends LitElement {
|
||||
--thumb-height: 16px;
|
||||
}
|
||||
|
||||
.volume-popup wa-slider::part(track) {
|
||||
wa-slider::part(track) {
|
||||
background: var(--yj-text-primary, white);
|
||||
height: 120px;
|
||||
}
|
||||
|
||||
/* The inline slider (#42). It is the default now, so the width is
|
||||
a real layout decision rather than a detail: 5em is wide enough
|
||||
to aim at and narrow enough that the bottom bar's *outer*
|
||||
columns stay equal without squeezing the transport — which is
|
||||
the arrangement #23 depends on.
|
||||
|
||||
flex-shrink: 0 for the reason the top bar's children have it
|
||||
(#143): a control that quietly gets narrower under pressure
|
||||
hides the fact that the bar has run out of room. This one stands
|
||||
down at phone width instead, in index.css, where the shell can
|
||||
see the viewport. */
|
||||
.inline-slider {
|
||||
width: 5em;
|
||||
flex-shrink: 0;
|
||||
}
|
||||
|
||||
.inline-slider::part(track) {
|
||||
background: var(--yj-text-primary, white);
|
||||
}
|
||||
|
||||
wa-slider::part(indicator) {
|
||||
background: var(--yj-accent, yellow);
|
||||
}
|
||||
@@ -149,23 +122,8 @@ export class VolumeControl extends LitElement {
|
||||
// LIFECYCLE
|
||||
// ===================================================================
|
||||
|
||||
override connectedCallback() {
|
||||
super.connectedCallback();
|
||||
|
||||
this.unsubscribeStyle = volumeStyleStore.subscribe(() => {
|
||||
this.popup = volumeStyleStore.popup;
|
||||
|
||||
// Switching to the slider while the popup is open would leave the
|
||||
// document listener installed for a popup that no longer renders.
|
||||
if (!this.popup) this.closeSlider();
|
||||
});
|
||||
|
||||
void volumeStyleStore.init();
|
||||
}
|
||||
|
||||
override disconnectedCallback() {
|
||||
super.disconnectedCallback();
|
||||
this.unsubscribeStyle?.();
|
||||
document.removeEventListener('click', this.boundHandleOutsideClick);
|
||||
clearTimeout(this.volumeDebounceTimer);
|
||||
}
|
||||
@@ -196,12 +154,10 @@ export class VolumeControl extends LitElement {
|
||||
private handleOutsideClick(e: Event) {
|
||||
const path = e.composedPath();
|
||||
|
||||
if (!path.includes(this)) this.closeSlider();
|
||||
}
|
||||
|
||||
private closeSlider() {
|
||||
this.showSlider = false;
|
||||
document.removeEventListener('click', this.boundHandleOutsideClick);
|
||||
if (!path.includes(this)) {
|
||||
this.showSlider = false;
|
||||
document.removeEventListener('click', this.boundHandleOutsideClick);
|
||||
}
|
||||
}
|
||||
|
||||
private handleInput(e: Event) {
|
||||
@@ -236,46 +192,18 @@ export class VolumeControl extends LitElement {
|
||||
override render() {
|
||||
const muted = this.player.muted;
|
||||
|
||||
// Inline, the icon is the mute toggle rather than a disclosure:
|
||||
// there is nothing left to disclose, and a button that opens a
|
||||
// popup containing the slider already beside it would be a control
|
||||
// whose only effect is to duplicate its neighbour.
|
||||
const iconAction = this.popup
|
||||
? this.toggleSlider
|
||||
: () => this.player.toggleMute();
|
||||
const iconLabel = this.popup
|
||||
? muted
|
||||
? 'Muted'
|
||||
: `Volume ${this.currentVolume}%`
|
||||
: muted
|
||||
? 'Unmute'
|
||||
: 'Mute';
|
||||
|
||||
return html`
|
||||
<button
|
||||
class=${muted ? 'muted' : ''}
|
||||
title=${muted ? 'Muted — click for volume' : 'Volume'}
|
||||
aria-label=${iconLabel}
|
||||
aria-label=${muted ? 'Muted' : `Volume ${this.currentVolume}%`}
|
||||
data-muted=${muted ? 'true' : 'false'}
|
||||
@click="${iconAction}"
|
||||
@click="${this.toggleSlider}"
|
||||
@wheel="${this.handleWheel}"
|
||||
>
|
||||
<wa-icon name=${this.volumeIcon}></wa-icon>
|
||||
</button>
|
||||
${!this.popup
|
||||
? html`
|
||||
<wa-slider
|
||||
class="inline-slider ${muted ? 'muted' : ''}"
|
||||
label="Volume"
|
||||
min="0"
|
||||
max="100"
|
||||
.value="${this.currentVolume}"
|
||||
@input="${this.handleInput}"
|
||||
@wheel="${this.handleWheel}"
|
||||
></wa-slider>
|
||||
`
|
||||
: ''}
|
||||
${this.popup && this.showSlider
|
||||
${this.showSlider
|
||||
? html`
|
||||
<div
|
||||
class="volume-popup ${muted ? 'muted' : ''}"
|
||||
|
||||
@@ -25,8 +25,6 @@ import {
|
||||
SetQueueFallback,
|
||||
GetAllowMeteredCatalogDownload,
|
||||
SetAllowMeteredCatalogDownload,
|
||||
GetPopupVolume,
|
||||
SetPopupVolume,
|
||||
} from '@go/config/config.js';
|
||||
import { GetIndexStatus } from '@go/explore/service.js';
|
||||
import { notificationStore } from '@store/notification-store';
|
||||
@@ -127,8 +125,6 @@ export class ConfigPage extends ViewLifecycleMixin(LitElement) {
|
||||
@state() private concurrencyMode = 'auto';
|
||||
@state() private defaultPage = 'home';
|
||||
@state() private queueFallback = 'favorites';
|
||||
|
||||
@state() private popupVolume = false;
|
||||
@state() private indexStatus: explore.IndexStatus | null = null;
|
||||
/** Three states, not one: the panel used to say "Loading status…"
|
||||
* for the entire session, because the only thing that ever set
|
||||
@@ -942,28 +938,20 @@ export class ConfigPage extends ViewLifecycleMixin(LitElement) {
|
||||
|
||||
private async loadLibraries(): Promise<void> {
|
||||
try {
|
||||
const [
|
||||
libs,
|
||||
mode,
|
||||
defaultPage,
|
||||
queueFallback,
|
||||
allowMetered,
|
||||
popupVolume,
|
||||
] = await Promise.all([
|
||||
GetAllLibrariesWithTrackCounts(),
|
||||
GetScanConcurrency(),
|
||||
GetDefaultPage(),
|
||||
GetQueueFallback(),
|
||||
GetAllowMeteredCatalogDownload(),
|
||||
GetPopupVolume(),
|
||||
]);
|
||||
const [libs, mode, defaultPage, queueFallback, allowMetered] =
|
||||
await Promise.all([
|
||||
GetAllLibrariesWithTrackCounts(),
|
||||
GetScanConcurrency(),
|
||||
GetDefaultPage(),
|
||||
GetQueueFallback(),
|
||||
GetAllowMeteredCatalogDownload(),
|
||||
]);
|
||||
|
||||
this.libraries = libs ?? [];
|
||||
this.concurrencyMode = mode;
|
||||
this.defaultPage = defaultPage;
|
||||
this.queueFallback = queueFallback;
|
||||
this.allowMeteredCatalogDownload = allowMetered;
|
||||
this.popupVolume = popupVolume;
|
||||
|
||||
} catch (err) {
|
||||
console.error(
|
||||
@@ -1870,51 +1858,10 @@ export class ConfigPage extends ViewLifecycleMixin(LitElement) {
|
||||
.value=${this.queueFallback}
|
||||
@config-change=${this.handleQueueFallbackChange}
|
||||
></config-field>
|
||||
<config-field
|
||||
.schema=${{
|
||||
key: 'popupVolume',
|
||||
label: 'Volume opens in a popup',
|
||||
description:
|
||||
'Off, the volume slider is always visible in the '
|
||||
+ 'player bar. On, it hides behind the speaker '
|
||||
+ 'icon. The slider stands down on a phone either '
|
||||
+ 'way, where the hardware keys own volume.',
|
||||
type: 'toggle' as const,
|
||||
}}
|
||||
.value=${this.popupVolume}
|
||||
@config-change=${this.handlePopupVolumeChange}
|
||||
></config-field>
|
||||
</config-section>
|
||||
`;
|
||||
}
|
||||
|
||||
/**
|
||||
* The volume control's presentation (#42).
|
||||
*
|
||||
* In General rather than beside the theme because it is about the
|
||||
* transport's behaviour rather than its colours, and next to "When
|
||||
* the Queue Ends" because both are answers to "how should the
|
||||
* player behave".
|
||||
*/
|
||||
private handlePopupVolumeChange = (
|
||||
e: CustomEvent<ConfigFieldChangeEvent>,
|
||||
): void => {
|
||||
const popup = Boolean(e.detail.value);
|
||||
const previous = this.popupVolume;
|
||||
|
||||
this.popupVolume = popup;
|
||||
|
||||
void SetPopupVolume(popup).catch((err: unknown) => {
|
||||
console.error('failed to save the volume control setting', err);
|
||||
this.popupVolume = previous;
|
||||
notificationStore.transient({
|
||||
key: 'popup-volume-setting',
|
||||
title: 'Setting not saved',
|
||||
text: describeError(err, 'That setting could not be saved.'),
|
||||
});
|
||||
});
|
||||
};
|
||||
|
||||
// --- Navigation section ---
|
||||
|
||||
/**
|
||||
|
||||
@@ -1,132 +0,0 @@
|
||||
/**
|
||||
* The phone's view of background work (#62).
|
||||
*
|
||||
* The header `job-indicator` is a *popover*, anchored to a bar 3.25em
|
||||
* tall on a screen 439 CSS px tall, and it was reported as unreadable
|
||||
* behind other UI. Two things are wrong with it there regardless of
|
||||
* that symptom: a popover is a **disclosure**, and background work is
|
||||
* the one thing a phone should not make you open something to see; and
|
||||
* #57 deletes the bar it is anchored to, and is blocked on this issue
|
||||
* precisely because the indicator needs somewhere else to live first.
|
||||
*
|
||||
* This is that somewhere. Below 600px the indicator stands down
|
||||
* (`index.css`) and its work appears here instead.
|
||||
*
|
||||
* Four things about it are load-bearing.
|
||||
*
|
||||
* **It is the existing `job-panel`, not a second job UI.** Pause,
|
||||
* cancel, Details and the log all come along — and, more to the point,
|
||||
* so does `applyJobControl`, which is what carries the "you will
|
||||
* discard hours of downloading" confirmation for an index build. A
|
||||
* host drawing its own buttons drops that silently, which is the trap
|
||||
* #27 already named.
|
||||
*
|
||||
* **It is in the layout, not over it**, and that was measured rather
|
||||
* than assumed. The first version of this put the panel in
|
||||
* `notification-host`'s fixed band, which reads fine in a screenshot
|
||||
* and is unusable: at 424x439 a compact panel is ~200px of a 439px
|
||||
* screen, and it *covers* what is under it. Four e2e specs failed —
|
||||
* two phone-shell journeys and the header's action menu — because the
|
||||
* panel was intercepting the taps. A band that hides the app to tell
|
||||
* you the app is busy is worse than the popover it replaced. In flow
|
||||
* it pushes instead, so nothing is covered and nothing is unreachable,
|
||||
* which is #24's one sentence across all three bands.
|
||||
*
|
||||
* **It shows active work only.** A finished row that lingers is a
|
||||
* banner that stays after the work is done, which is the opposite of
|
||||
* what #62 asks for ("dismissed automatically on completion") and, in
|
||||
* flow, is furniture that keeps the content pushed down. Finished jobs
|
||||
* are still shown where the work was started, which is #27's rule and
|
||||
* unaffected.
|
||||
*
|
||||
* **It renders nothing at all above 600px**, from `matchMedia` rather
|
||||
* than a media query, because this decides whether the element
|
||||
* *exists*. `bottom-nav` learned that the expensive way: rendering its
|
||||
* duplicate `<app-sidebar>` unconditionally put a second copy of every
|
||||
* `nav-*` testid in the DOM and broke 30 specs on a viewport where it
|
||||
* was not even visible. Settings already holds four `job-panel`s, so a
|
||||
* fifth answering for *every* kind is the same trap.
|
||||
*/
|
||||
import { LitElement, html, css, nothing } from 'lit';
|
||||
import { customElement, state } from 'lit/decorators.js';
|
||||
|
||||
import { jobStore } from '@store/job-store';
|
||||
import { isTerminal } from '@store/job-store';
|
||||
import { designTokens } from '../../styles/tokens.css';
|
||||
import { PHONE_QUERY } from '../../utils/breakpoints';
|
||||
import './job-panel';
|
||||
|
||||
@customElement('job-band')
|
||||
export class JobBand extends LitElement {
|
||||
@state() private phone = false;
|
||||
|
||||
@state() private active = 0;
|
||||
|
||||
private media?: MediaQueryList;
|
||||
|
||||
private unsubscribe?: () => void;
|
||||
|
||||
static override styles = [
|
||||
designTokens,
|
||||
css`
|
||||
:host {
|
||||
display: block;
|
||||
min-width: 0;
|
||||
}
|
||||
|
||||
/* The panel's own margin is for a settings section; here the
|
||||
band owns the spacing. */
|
||||
job-panel {
|
||||
margin-top: 0;
|
||||
padding: 0 0.5em 0.5em;
|
||||
}
|
||||
`,
|
||||
];
|
||||
|
||||
private onMedia = (e: MediaQueryListEvent | MediaQueryList) => {
|
||||
this.phone = e.matches;
|
||||
};
|
||||
|
||||
private onJobs = () => {
|
||||
this.active = jobStore.jobs.filter((job) => !isTerminal(job)).length;
|
||||
};
|
||||
|
||||
override connectedCallback(): void {
|
||||
super.connectedCallback();
|
||||
|
||||
this.media = window.matchMedia(PHONE_QUERY);
|
||||
this.phone = this.media.matches;
|
||||
this.media.addEventListener('change', this.onMedia);
|
||||
|
||||
// The band decides whether to render *at all*, and a panel that
|
||||
// hides itself cannot tell its host that.
|
||||
this.unsubscribe = jobStore.subscribe(this.onJobs);
|
||||
this.onJobs();
|
||||
void jobStore.init();
|
||||
}
|
||||
|
||||
override disconnectedCallback(): void {
|
||||
super.disconnectedCallback();
|
||||
this.unsubscribe?.();
|
||||
this.media?.removeEventListener('change', this.onMedia);
|
||||
}
|
||||
|
||||
override render() {
|
||||
// `hidden` rather than an empty render, so the grid row this
|
||||
// sits in costs nothing at all while there is no work -- the
|
||||
// rule `job-panel` already follows one layer down.
|
||||
this.hidden = !(this.phone && this.active > 0);
|
||||
|
||||
if (this.hidden) return nothing;
|
||||
|
||||
return html`
|
||||
<job-panel kinds="*" density="compact" active-only></job-panel>
|
||||
`;
|
||||
}
|
||||
}
|
||||
|
||||
declare global {
|
||||
interface HTMLElementTagNameMap {
|
||||
'job-band': JobBand;
|
||||
}
|
||||
}
|
||||
@@ -51,14 +51,6 @@ export class JobPanel extends LitElement {
|
||||
* literal in a template, and one of them is inside an HTMX-adjacent
|
||||
* settings page where a property binding would be one more thing to
|
||||
* remember.
|
||||
*
|
||||
* **`*` means every kind**, which is the phone's band (#62) and
|
||||
* nothing else: there, this panel is standing in for the header
|
||||
* indicator, whose whole job was to be the one view of everything
|
||||
* at once. It is spelled `*` rather than taken as the meaning of an
|
||||
* empty attribute, because empty is what a typo and a missing
|
||||
* binding both produce and "show everything" is the wrong thing to
|
||||
* do by accident. Empty still shows nothing.
|
||||
*/
|
||||
@property({ type: String })
|
||||
kinds = '';
|
||||
@@ -67,31 +59,6 @@ export class JobPanel extends LitElement {
|
||||
@property({ type: String })
|
||||
heading = '';
|
||||
|
||||
/**
|
||||
* Row density, passed to `job-row`.
|
||||
*
|
||||
* `full` adds elapsed time and per-job statistics and is what a
|
||||
* settings section wants, so it stays the default and the four
|
||||
* existing call sites are unchanged. `compact` is what `job-row`
|
||||
* itself calls "the popover density", and it is what the phone's
|
||||
* band uses (#62) — there this panel *is* the popover, on a screen
|
||||
* 439 CSS px tall, and the full density spent 259 of them.
|
||||
*/
|
||||
@property({ type: String })
|
||||
density: 'compact' | 'full' = 'full';
|
||||
|
||||
/**
|
||||
* Drop finished rows.
|
||||
*
|
||||
* For the phone's band (#62), which is *in the layout*: a finished
|
||||
* row there is a banner that stays after the work is done and keeps
|
||||
* the content pushed down. Settings keeps them, because that is
|
||||
* where "did the last scan work" is asked, and a finished row there
|
||||
* dismisses itself.
|
||||
*/
|
||||
@property({ type: Boolean, attribute: 'active-only' })
|
||||
activeOnly = false;
|
||||
|
||||
@state()
|
||||
private jobs: Job[] = [];
|
||||
|
||||
@@ -195,14 +162,9 @@ export class JobPanel extends LitElement {
|
||||
}
|
||||
|
||||
private get mine(): Job[] {
|
||||
const ofKind =
|
||||
this.kinds.trim() === '*'
|
||||
? this.jobs
|
||||
: this.jobs.filter((job) =>
|
||||
this.wanted.has(job.kind as JobKind),
|
||||
);
|
||||
const wanted = this.wanted;
|
||||
|
||||
return this.activeOnly ? ofKind.filter((job) => !isTerminal(job)) : ofKind;
|
||||
return this.jobs.filter((job) => wanted.has(job.kind as JobKind));
|
||||
}
|
||||
|
||||
private openDetails(id: string) {
|
||||
@@ -234,7 +196,7 @@ export class JobPanel extends LitElement {
|
||||
<div class="job-entry">
|
||||
<job-row
|
||||
.job=${job}
|
||||
variant=${this.density}
|
||||
variant="full"
|
||||
@job-control=${applyJobControl}
|
||||
></job-row>
|
||||
<button
|
||||
|
||||
@@ -1,85 +0,0 @@
|
||||
import { EventsOn } from '@runtime/runtime';
|
||||
import { GetPopupVolume } from '@go/config/config.js';
|
||||
import { Events } from '../events';
|
||||
|
||||
type Subscriber = () => void;
|
||||
|
||||
/**
|
||||
* Whether the volume control is a click-to-open popup (#42).
|
||||
*
|
||||
* The popup was the only option, and "click open, drag, click closed"
|
||||
* is three gestures for a control a bottom bar has room to just show.
|
||||
* So an inline slider is the default and the popup is a setting.
|
||||
*
|
||||
* **The stored flag names the popup, not the slider**, which is the
|
||||
* polarity rule `backend/config` states for every option it has: the
|
||||
* zero value has to be the intended answer. An `InlineVolume bool`
|
||||
* would default to false, hand the popup to every existing install, and
|
||||
* need a migration to say what the default already says.
|
||||
*
|
||||
* It is a store rather than a field on the component because two
|
||||
* components render `<volume-control>` — the bottom bar and the phone's
|
||||
* full-screen now-playing view — and a setting that only reached
|
||||
* whichever one happened to mount after it changed is the fault
|
||||
* `active-view-store` exists to prevent, one surface over.
|
||||
*
|
||||
* The initial value is the *default* rather than a pending answer, so
|
||||
* the first paint is the inline slider and not an empty gap that
|
||||
* becomes one. An install that has chosen the popup sees it swap once
|
||||
* on load, which is the cheaper of the two wrong first frames: the
|
||||
* inline slider occupies the space the popup's button would have.
|
||||
*/
|
||||
class VolumeStyleStore {
|
||||
private value = false;
|
||||
|
||||
private loaded = false;
|
||||
|
||||
private subscribers = new Set<Subscriber>();
|
||||
|
||||
constructor() {
|
||||
EventsOn(Events.GeneralConfigChanged, () => {
|
||||
void this.refresh();
|
||||
});
|
||||
}
|
||||
|
||||
/** Whether to draw the popup. Safe to read before `init()`. */
|
||||
get popup(): boolean {
|
||||
return this.value;
|
||||
}
|
||||
|
||||
/** Reads the setting once. Safe to call from every mount. */
|
||||
async init(): Promise<void> {
|
||||
if (this.loaded) return;
|
||||
|
||||
this.loaded = true;
|
||||
|
||||
await this.refresh();
|
||||
}
|
||||
|
||||
subscribe(fn: Subscriber): () => void {
|
||||
this.subscribers.add(fn);
|
||||
|
||||
return () => this.subscribers.delete(fn);
|
||||
}
|
||||
|
||||
private async refresh(): Promise<void> {
|
||||
try {
|
||||
const popup = await GetPopupVolume();
|
||||
|
||||
if (popup === this.value) return;
|
||||
|
||||
this.value = popup;
|
||||
this.notify();
|
||||
} catch (err) {
|
||||
// Nothing to tell the user: the control renders in its
|
||||
// default presentation, which is a working volume control.
|
||||
console.error('failed to read the volume control setting', err);
|
||||
}
|
||||
}
|
||||
|
||||
private notify(): void {
|
||||
for (const fn of this.subscribers) fn();
|
||||
}
|
||||
}
|
||||
|
||||
export const volumeStyleStore = new VolumeStyleStore();
|
||||
@@ -76,68 +76,6 @@ describe('<job-panel>', () => {
|
||||
expect(titles(el)).toEqual(['Building the index', 'Filling in artists']);
|
||||
});
|
||||
|
||||
/**
|
||||
* #62. The phone's band has no kinds to name: it is standing in for
|
||||
* the header indicator, whose whole job was to be the one view of
|
||||
* everything at once.
|
||||
*/
|
||||
it('answers for every kind when asked with a star', async () => {
|
||||
const el = await fixture<LitElement>('job-panel', { kinds: '*' });
|
||||
|
||||
await snapshot([
|
||||
job({ id: 'scan:1', kind: 'library-scan', title: 'Scanning Music' }),
|
||||
job({ id: 'idx', kind: 'index-build', title: 'Building the index' }),
|
||||
job({ id: 'dl:1', kind: 'download', title: 'Downloading Glass Harbour' }),
|
||||
]);
|
||||
await el.updateComplete;
|
||||
|
||||
expect(titles(el)).toEqual([
|
||||
'Scanning Music',
|
||||
'Building the index',
|
||||
'Downloading Glass Harbour',
|
||||
]);
|
||||
});
|
||||
|
||||
/**
|
||||
* The other half of that, and the reason it is a star rather than the
|
||||
* meaning of an empty attribute: empty is what a typo and a dropped
|
||||
* binding both produce, and "show everything" is the wrong thing to
|
||||
* do by accident.
|
||||
*/
|
||||
it('still shows nothing when asked for nothing', async () => {
|
||||
const el = await fixture<LitElement>('job-panel', { kinds: '' });
|
||||
|
||||
await snapshot([job({ id: 'scan:1', kind: 'library-scan' })]);
|
||||
await el.updateComplete;
|
||||
|
||||
expect([el.hidden, rows(el)].map(String)).toEqual(['true', '']);
|
||||
});
|
||||
|
||||
/**
|
||||
* `full` stays the default so the four settings call sites are
|
||||
* untouched; the band asks for the density `job-row` calls "the
|
||||
* popover density", because on the phone this panel *is* the popover.
|
||||
*/
|
||||
it('passes its density to the rows, defaulting to full', async () => {
|
||||
const settings = await fixture<LitElement>('job-panel', { kinds: '*' });
|
||||
|
||||
await snapshot([job()]);
|
||||
await settings.updateComplete;
|
||||
|
||||
const band = await fixture<LitElement>('job-panel', {
|
||||
kinds: '*',
|
||||
density: 'compact',
|
||||
});
|
||||
|
||||
await snapshot([job()]);
|
||||
await band.updateComplete;
|
||||
|
||||
expect([
|
||||
rows(settings)[0]?.getAttribute('variant'),
|
||||
rows(band)[0]?.getAttribute('variant'),
|
||||
]).toEqual(['full', 'compact']);
|
||||
});
|
||||
|
||||
/**
|
||||
* An idle panel in four places is four pieces of furniture describing
|
||||
* an absence — and `hidden` rather than an empty render, because the
|
||||
|
||||
@@ -11,7 +11,7 @@ import '@components/audio-player/controls/player-controls';
|
||||
import '@components/audio-player/seekbar/seek-bar';
|
||||
import '@components/audio-player/volume-control/volume-control';
|
||||
import { Events } from '../../src/events';
|
||||
import { emit, calls, lastArgs, flush, stub } from '@test/support/harness';
|
||||
import { emit, calls, lastArgs, flush } from '@test/support/harness';
|
||||
import {
|
||||
fixture,
|
||||
shadow,
|
||||
@@ -397,111 +397,6 @@ describe('<seek-bar>', () => {
|
||||
expect(lastArgs('player.Player.Seek')).toEqual([42]);
|
||||
});
|
||||
|
||||
// #164. `handleInput` used to call `stopProgress()` and mutate no
|
||||
// reactive state, so Lit scheduled no update, `updated()` never ran,
|
||||
// and the tail of `updated()` that restarts the interval never
|
||||
// executed. Only a `change` or the next backend report could bring
|
||||
// it back -- so an `input` that never commits froze the clock, which
|
||||
// on a touch device is an ordinary cancelled gesture. With no
|
||||
// reports arriving, that is permanent.
|
||||
it('keeps ticking after a drag that never commits', async () => {
|
||||
vi.useFakeTimers();
|
||||
|
||||
const el = await fixture('seek-bar');
|
||||
|
||||
emit(Events.TrackChanged, TRACK);
|
||||
emit(Events.PlaybackStateChanged, { state: 'playing' });
|
||||
await vi.advanceTimersByTimeAsync(2000);
|
||||
await el.updateComplete;
|
||||
|
||||
// A touch lands on the track and is then cancelled: `input`, and
|
||||
// no `change` ever follows.
|
||||
const slider = shadow<HTMLElement & { value: number }>(el, 'wa-slider');
|
||||
|
||||
if (slider) slider.value = 20;
|
||||
|
||||
slider?.dispatchEvent(new Event('input'));
|
||||
await el.updateComplete;
|
||||
|
||||
document.dispatchEvent(new Event('pointerup'));
|
||||
await vi.advanceTimersByTimeAsync(0);
|
||||
await el.updateComplete;
|
||||
|
||||
await vi.advanceTimersByTimeAsync(3000);
|
||||
await el.updateComplete;
|
||||
|
||||
expect(text(el, '[data-testid="elapsed-time"]')).toBe('00:23');
|
||||
});
|
||||
|
||||
// The other half of the same fix: while the thumb is held, a report
|
||||
// arriving once a second used to overwrite `seekValue` and pull it
|
||||
// back out from under the finger.
|
||||
it('leaves the thumb where the finger is while a drag is live', async () => {
|
||||
vi.useFakeTimers();
|
||||
|
||||
const el = await fixture('seek-bar');
|
||||
|
||||
emit(Events.TrackChanged, { ...TRACK, trackChangeId: 20 });
|
||||
emit(Events.PlaybackStateChanged, { state: 'playing' });
|
||||
await vi.advanceTimersByTimeAsync(0);
|
||||
await el.updateComplete;
|
||||
|
||||
const slider = shadow<HTMLElement & { value: number }>(el, 'wa-slider');
|
||||
|
||||
if (slider) slider.value = 60;
|
||||
|
||||
slider?.dispatchEvent(new Event('input'));
|
||||
await el.updateComplete;
|
||||
|
||||
emit(Events.PlaybackPositionChanged, {
|
||||
positionSeconds: 4,
|
||||
trackLength: 90,
|
||||
trackChangeId: 20,
|
||||
seq: 7,
|
||||
playing: true,
|
||||
});
|
||||
await vi.advanceTimersByTimeAsync(0);
|
||||
await el.updateComplete;
|
||||
|
||||
expect(text(el, '[data-testid="elapsed-time"]')).toBe('01:00');
|
||||
});
|
||||
|
||||
// And the drag must not hold the interval hostage once it ends: the
|
||||
// report that was skipped mid-drag is not recorded as seen, so the
|
||||
// next one is still fresh and is applied.
|
||||
it('takes the backend back as the authority once the drag commits', async () => {
|
||||
vi.useFakeTimers();
|
||||
|
||||
const el = await fixture('seek-bar');
|
||||
|
||||
emit(Events.TrackChanged, { ...TRACK, trackChangeId: 21 });
|
||||
emit(Events.PlaybackStateChanged, { state: 'playing' });
|
||||
await vi.advanceTimersByTimeAsync(0);
|
||||
await el.updateComplete;
|
||||
|
||||
const slider = shadow<HTMLElement & { value: number }>(el, 'wa-slider');
|
||||
|
||||
if (slider) slider.value = 60;
|
||||
|
||||
slider?.dispatchEvent(new Event('input'));
|
||||
await el.updateComplete;
|
||||
|
||||
slider?.dispatchEvent(new Event('change'));
|
||||
await el.updateComplete;
|
||||
|
||||
emit(Events.PlaybackPositionChanged, {
|
||||
positionSeconds: 61,
|
||||
trackLength: 90,
|
||||
trackChangeId: 21,
|
||||
seq: 9,
|
||||
playing: true,
|
||||
});
|
||||
await vi.advanceTimersByTimeAsync(0);
|
||||
await el.updateComplete;
|
||||
|
||||
expect(text(el, '[data-testid="elapsed-time"]')).toBe('01:01');
|
||||
});
|
||||
|
||||
it('bounds the slider by the track length', async () => {
|
||||
const el = await fixture('seek-bar');
|
||||
|
||||
@@ -539,40 +434,13 @@ describe('<seek-bar>', () => {
|
||||
* be driven by its own event — watching the volume number, as it used
|
||||
* to, meant pressing M visibly did nothing.
|
||||
*/
|
||||
/**
|
||||
* The volume control has two presentations (#42), and the icon button
|
||||
* means a different thing in each — so both are exercised rather than
|
||||
* whichever one happens to be the default.
|
||||
*
|
||||
* Inline is the default: the slider is simply there, which leaves the
|
||||
* icon with nothing to disclose, so it is the mute toggle and is named
|
||||
* after that action. In the popup it is a disclosure, so it is named
|
||||
* after the *state* it is showing.
|
||||
*/
|
||||
describe('volume control: mute', () => {
|
||||
/**
|
||||
* Put the presentation back to the default between tests.
|
||||
*
|
||||
* `volumeStyleStore` is a singleton whose `init()` reads the setting
|
||||
* once, so stubbing the binding inside a test is too late — a
|
||||
* previous test has already loaded it. `GeneralConfigChanged` is the
|
||||
* store's own refresh trigger and the same one the Settings page
|
||||
* fires, so driving it that way exercises the real path instead of
|
||||
* reaching for a test-only reset.
|
||||
*/
|
||||
const setPresentation = async (popup: boolean) => {
|
||||
stub('config.Config.GetPopupVolume', popup);
|
||||
emit(Events.GeneralConfigChanged, {});
|
||||
await flush();
|
||||
};
|
||||
|
||||
beforeEach(async () => {
|
||||
await setPresentation(false);
|
||||
beforeEach(() => {
|
||||
emit(Events.VolumeChanged, 40);
|
||||
emit(Events.MuteChanged, false);
|
||||
});
|
||||
|
||||
it('shows a muted glyph once the backend reports mute', async () => {
|
||||
it('shows a muted glyph and label once the backend reports mute', async () => {
|
||||
const el = await fixture('volume-control');
|
||||
|
||||
expect(shadow(el, 'button')?.getAttribute('data-muted')).toBe('false');
|
||||
@@ -585,53 +453,14 @@ describe('volume control: mute', () => {
|
||||
expect(shadow(el, 'button wa-icon')?.getAttribute('name')).toBe(
|
||||
'volume-xmark',
|
||||
);
|
||||
});
|
||||
|
||||
it('names the inline icon after the action it performs', async () => {
|
||||
const el = await fixture('volume-control');
|
||||
|
||||
expect(shadow(el, 'button')?.getAttribute('aria-label')).toBe('Mute');
|
||||
|
||||
emit(Events.MuteChanged, true);
|
||||
await flush();
|
||||
await el.updateComplete;
|
||||
|
||||
expect(shadow(el, 'button')?.getAttribute('aria-label')).toBe('Unmute');
|
||||
});
|
||||
|
||||
it('names the popup icon after the state it discloses', async () => {
|
||||
await setPresentation(true);
|
||||
|
||||
const el = await fixture('volume-control');
|
||||
|
||||
await el.updateComplete;
|
||||
|
||||
expect(shadow(el, 'button')?.getAttribute('aria-label')).toBe(
|
||||
'Volume 40%',
|
||||
);
|
||||
|
||||
emit(Events.MuteChanged, true);
|
||||
await flush();
|
||||
await el.updateComplete;
|
||||
|
||||
expect(shadow(el, 'button')?.getAttribute('aria-label')).toBe('Muted');
|
||||
});
|
||||
|
||||
it('shows the slider without a click when it is inline', async () => {
|
||||
const el = await fixture('volume-control');
|
||||
|
||||
// The whole point of the issue: no disclosure to operate first.
|
||||
expect(shadow<HTMLInputElement>(el, 'wa-slider')?.value).toBe(40);
|
||||
});
|
||||
|
||||
it('keeps showing the volume level while muted, because it is unchanged', async () => {
|
||||
await setPresentation(true);
|
||||
emit(Events.MuteChanged, true);
|
||||
await flush();
|
||||
|
||||
const el = await fixture('volume-control');
|
||||
|
||||
await el.updateComplete;
|
||||
await click(el, 'button');
|
||||
|
||||
expect(shadow<HTMLInputElement>(el, 'wa-slider')?.value).toBe(40);
|
||||
@@ -639,24 +468,11 @@ describe('volume control: mute', () => {
|
||||
|
||||
it('toggles mute through the backend rather than locally', async () => {
|
||||
const el = await fixture('volume-control');
|
||||
|
||||
await click(el, 'button');
|
||||
|
||||
expect(calls('player.Player.MuteToggle').length).toBe(1);
|
||||
// Nothing optimistic: the icon follows the backend's event.
|
||||
expect(shadow(el, 'button')?.getAttribute('data-muted')).toBe('false');
|
||||
});
|
||||
|
||||
it('toggles mute from inside the popup, where the icon is a disclosure', async () => {
|
||||
await setPresentation(true);
|
||||
|
||||
const el = await fixture('volume-control');
|
||||
|
||||
await el.updateComplete;
|
||||
await click(el, 'button');
|
||||
await click(el, '.mute-toggle');
|
||||
|
||||
expect(calls('player.Player.MuteToggle').length).toBe(1);
|
||||
// Nothing optimistic: the icon follows the backend's event.
|
||||
expect(shadow(el, 'button')?.getAttribute('data-muted')).toBe('false');
|
||||
});
|
||||
});
|
||||
|
||||
@@ -6,7 +6,6 @@ import (
|
||||
"log/slog"
|
||||
"os"
|
||||
"strings"
|
||||
"sync/atomic"
|
||||
|
||||
"github.com/golang-cz/devslog"
|
||||
"github.com/wailsapp/wails/v3/pkg/application"
|
||||
@@ -29,61 +28,7 @@ var (
|
||||
//go:embed all:frontend/dist
|
||||
var frontendDistAssets embed.FS
|
||||
|
||||
// mainStarted latches the first entry into main().
|
||||
//
|
||||
// **On Android main() is called once per *activity*, and the process
|
||||
// outlives the activity.** Wails' JNI entry point is
|
||||
// `nativeInit`, which does two things: it re-points the native
|
||||
// library's global reference at the calling `WailsBridge`, and it runs
|
||||
// `go mainFunc()`. `MainActivity.onCreate` calls it, and Android
|
||||
// recreates the activity — for a configuration change it does not
|
||||
// declare, under memory pressure, or on every single background when
|
||||
// the user has "Don't keep activities" switched on — **without
|
||||
// restarting the process**.
|
||||
//
|
||||
// So main() ran again, on a live app, and every path out of that is
|
||||
// fatal:
|
||||
//
|
||||
// - `application.New` returns the *existing* `globalApplication` when
|
||||
// there is one, silently discarding the second set of Services.
|
||||
// - `app.Run()` then refuses, by design: `a.starting` is still true,
|
||||
// because Android's `platformRun` is `select{}` and never returns.
|
||||
// It answers "application is running or a previous run has failed".
|
||||
// - which lands on `os.Exit(1)` at the foot of this function, and
|
||||
// that takes down the **first**, perfectly healthy app with it —
|
||||
// its database, its queue, and the audio that a foreground service
|
||||
// is holding the process alive to play.
|
||||
//
|
||||
// ActivityManager then restarts the app, which is the report: "crashes
|
||||
// or restarts when reopened after running in the background". It never
|
||||
// left a tombstone because `os.Exit` is not a crash, and it never left
|
||||
// a log line because an Android app's fd 1 goes to /dev/null.
|
||||
//
|
||||
// The latch is the whole fix, and it has to be **first**: everything
|
||||
// below it — `NewYellowJacketApp` above all, which opens the SQLite
|
||||
// database — is work that must not happen twice in one process.
|
||||
// Returning early is not a degraded mode: `nativeInit` has already
|
||||
// re-attached the bridge, so the recreated activity's WebView talks to
|
||||
// the app that is still running, with its queue and its playback
|
||||
// position intact. See CLAUDE.md, "An activity is a view onto the
|
||||
// process".
|
||||
//
|
||||
// It is inert off Android, where a process has exactly one main().
|
||||
var mainStarted atomic.Bool
|
||||
|
||||
// claimMainOnce reports whether this is the first call to main() in
|
||||
// this process. See mainStarted.
|
||||
func claimMainOnce() bool {
|
||||
return mainStarted.CompareAndSwap(false, true)
|
||||
}
|
||||
|
||||
func main() {
|
||||
// Android calls main() once per activity, and the process outlives
|
||||
// the activity. Nothing below this line may run twice.
|
||||
if !claimMainOnce() {
|
||||
return
|
||||
}
|
||||
|
||||
// **Mobile has no home directory, and this must run before anything
|
||||
// asks for a path.** backend/system resolves config and data from
|
||||
// $HOME or the OS equivalent, and on Android there is neither: its
|
||||
|
||||
-104
@@ -1,104 +0,0 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"go/ast"
|
||||
"go/parser"
|
||||
"go/token"
|
||||
"testing"
|
||||
)
|
||||
|
||||
// TestMainRunsOncePerProcess pins the latch itself.
|
||||
func TestMainRunsOncePerProcess(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
mainStarted.Store(false)
|
||||
|
||||
if !claimMainOnce() {
|
||||
t.Fatal("the first call to claimMainOnce must claim it")
|
||||
}
|
||||
|
||||
if claimMainOnce() {
|
||||
t.Fatal("a second call to claimMainOnce must not claim it: " +
|
||||
"on Android that second call is a second main() in a live " +
|
||||
"process, and every path out of it ends in os.Exit(1)")
|
||||
}
|
||||
}
|
||||
|
||||
// TestMainClaimsBeforeItDoesAnything is the assertion that actually
|
||||
// guards #52, and it is a source sweep for the reason
|
||||
// TestNoDirectRuntimeEmits is: no tier here runs main() on Android, so
|
||||
// nothing else can see work creeping in above the latch.
|
||||
//
|
||||
// The failure it exists for is not the latch being deleted — that is
|
||||
// loud. It is a line being added above it: a second
|
||||
// NewYellowJacketApp opens the SQLite database a second time in one
|
||||
// process, and it would do so on every activity recreation, silently,
|
||||
// on a build that otherwise looks entirely healthy.
|
||||
func TestMainClaimsBeforeItDoesAnything(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
fset := token.NewFileSet()
|
||||
|
||||
file, err := parser.ParseFile(fset, "main.go", nil, 0)
|
||||
if err != nil {
|
||||
t.Fatalf("parse main.go: %v", err)
|
||||
}
|
||||
|
||||
var fn *ast.FuncDecl
|
||||
|
||||
for _, decl := range file.Decls {
|
||||
d, ok := decl.(*ast.FuncDecl)
|
||||
if ok && d.Name.Name == "main" && d.Recv == nil {
|
||||
fn = d
|
||||
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
if fn == nil {
|
||||
t.Fatal("no func main in main.go — this test read the wrong file")
|
||||
}
|
||||
|
||||
if len(fn.Body.List) == 0 {
|
||||
t.Fatal("func main is empty")
|
||||
}
|
||||
|
||||
if !claimsMainOnce(fn.Body.List[0]) {
|
||||
t.Fatalf("the first statement of main() must be the "+
|
||||
"`if !claimMainOnce() { return }` guard, got %T — see #52: "+
|
||||
"Android calls main() once per activity, in a process that "+
|
||||
"outlives the activity, so anything above the guard runs "+
|
||||
"again on every recreation", fn.Body.List[0])
|
||||
}
|
||||
}
|
||||
|
||||
// claimsMainOnce reports whether stmt is `if !claimMainOnce() { return }`.
|
||||
func claimsMainOnce(stmt ast.Stmt) bool {
|
||||
ifStmt, ok := stmt.(*ast.IfStmt)
|
||||
if !ok {
|
||||
return false
|
||||
}
|
||||
|
||||
unary, ok := ifStmt.Cond.(*ast.UnaryExpr)
|
||||
if !ok || unary.Op != token.NOT {
|
||||
return false
|
||||
}
|
||||
|
||||
call, ok := unary.X.(*ast.CallExpr)
|
||||
if !ok {
|
||||
return false
|
||||
}
|
||||
|
||||
ident, ok := call.Fun.(*ast.Ident)
|
||||
if !ok || ident.Name != "claimMainOnce" {
|
||||
return false
|
||||
}
|
||||
|
||||
if len(ifStmt.Body.List) != 1 {
|
||||
return false
|
||||
}
|
||||
|
||||
_, ok = ifStmt.Body.List[0].(*ast.ReturnStmt)
|
||||
|
||||
return ok
|
||||
}
|
||||
@@ -1,196 +0,0 @@
|
||||
#!/usr/bin/env bash
|
||||
#
|
||||
# Install a built APK onto an Android target and launch it, under the
|
||||
# package id the APK itself declares.
|
||||
#
|
||||
# This is the whole body of build/android/Taskfile.yml's four adb-driven
|
||||
# tasks — deploy-emulator, run, run:device, deploy-device — which were
|
||||
# three lines each, written out four times, and wrong in two ways in all
|
||||
# four (#159):
|
||||
#
|
||||
# adb uninstall app.yellowjacket # the RELEASE id, unconditionally
|
||||
# adb install bin/yellowjacket.apk
|
||||
# adb shell am start -n app.yellowjacket/com.wails.app.MainActivity
|
||||
#
|
||||
# **The uninstall is not here and does not come back.** It was there to
|
||||
# make the bare `install` on the next line work at all — without -r,
|
||||
# Android refuses an install over an existing package — so `install -r`
|
||||
# removes the reason for it rather than merely removing it. What is
|
||||
# left is the one case an uninstall really is the remedy, a changed
|
||||
# signing certificate, and that is exactly the case where performing it
|
||||
# silently costs the user their library. So it is *named* and not done:
|
||||
# an error message carrying the command is a decision the person at the
|
||||
# keyboard gets to make, which is the same answer scripts/android-
|
||||
# emulator.sh already reached for `make android-install`.
|
||||
#
|
||||
# **The id is read back from the artifact**, never defaulted, so the
|
||||
# thing installed and the thing launched cannot disagree — see
|
||||
# scripts/android-pkgid.sh for why that is by construction rather than
|
||||
# by discipline.
|
||||
#
|
||||
# **The target is checked against the task's own name.** The emulator
|
||||
# tasks used a bare `adb`, which with one device attached picks that
|
||||
# device whatever it is — so `wails3 task android:run`, whose summary
|
||||
# says "in the Android Emulator", installed on the phone when a phone
|
||||
# was the only thing plugged in. A task addressing something other than
|
||||
# what it says is the same fault as the package id, one level up.
|
||||
#
|
||||
# Usage:
|
||||
# android-deploy.sh --apk <path> --target emulator|device|any \
|
||||
# [--expect <id>] [--serial <s>] [--no-launch]
|
||||
set -euo pipefail
|
||||
|
||||
cd "$(dirname "$0")/.."
|
||||
|
||||
SDK="${ANDROID_HOME:-${ANDROID_SDK_ROOT:-$HOME/Android/Sdk}}"
|
||||
ADB="$(command -v adb || echo "$SDK/platform-tools/adb")"
|
||||
|
||||
# **Not "$PKG/.MainActivity".** A leading-dot activity is resolved
|
||||
# against the applicationId, and the scaffold's activity lives in the
|
||||
# Java package com.wails.app, which is deliberately not it. The short
|
||||
# form fails with a class-not-found that reads like a broken build.
|
||||
ACTIVITY="${YJ_ANDROID_ACTIVITY:-com.wails.app.MainActivity}"
|
||||
|
||||
APK=""
|
||||
TARGET="any"
|
||||
EXPECT=""
|
||||
SERIAL="${ANDROID_SERIAL:-${DEVICE_ID:-}}"
|
||||
LAUNCH=1
|
||||
|
||||
die() { echo "android-deploy: $*" >&2; exit 1; }
|
||||
|
||||
while [ $# -gt 0 ]; do
|
||||
case "$1" in
|
||||
--apk) APK="${2:-}"; shift 2 ;;
|
||||
--target) TARGET="${2:-}"; shift 2 ;;
|
||||
--expect) EXPECT="${2:-}"; shift 2 ;;
|
||||
--serial) SERIAL="${2:-}"; shift 2 ;;
|
||||
--no-launch) LAUNCH=0; shift ;;
|
||||
*) die "unknown option $1" ;;
|
||||
esac
|
||||
done
|
||||
|
||||
[ -n "$APK" ] || die "--apk is required"
|
||||
[ -f "$APK" ] || die "no such APK: $APK
|
||||
Build one first: wails3 task android:assemble:apk (debug)
|
||||
wails3 task android:package (release)"
|
||||
[ -x "$ADB" ] || command -v adb >/dev/null ||
|
||||
die "adb not found. Install the Android SDK platform-tools (or set ANDROID_HOME)"
|
||||
|
||||
case "$TARGET" in
|
||||
emulator | device | any) ;;
|
||||
*) die "--target must be emulator, device or any (got '$TARGET')" ;;
|
||||
esac
|
||||
|
||||
# ---------------------------------------------------------------- #
|
||||
# Which package
|
||||
# ---------------------------------------------------------------- #
|
||||
|
||||
# This runs *before* a target is chosen, deliberately: the guard is a
|
||||
# question about the artifact, so it can be answered — and exercised —
|
||||
# with nothing plugged in, and a build whose id is wrong should be
|
||||
# refused whether or not there is anything to install it onto.
|
||||
#
|
||||
# An unreadable APK, or an id that is not the one the caller named, is a
|
||||
# hard stop before anything is installed or launched. Spelled as two
|
||||
# calls rather than one with a conditional argument: an empty array under
|
||||
# `set -u` is an unbound variable in bash 3.2, which is what macOS ships.
|
||||
if [ -n "$EXPECT" ]; then
|
||||
PKG="$(./scripts/android-pkgid.sh "$APK" --expect "$EXPECT")"
|
||||
else
|
||||
PKG="$(./scripts/android-pkgid.sh "$APK")"
|
||||
fi
|
||||
|
||||
# ---------------------------------------------------------------- #
|
||||
# Which target
|
||||
# ---------------------------------------------------------------- #
|
||||
|
||||
# An emulator serial is "emulator-<port>"; anything else online is a
|
||||
# physical device. That is the same test the device tasks already made,
|
||||
# and the emulator tasks did not make at all.
|
||||
online_matching() {
|
||||
case "$TARGET" in
|
||||
emulator) "$ADB" devices | awk 'NR > 1 && $2 == "device" && $1 ~ /^emulator-/ { print $1 }' ;;
|
||||
device) "$ADB" devices | awk 'NR > 1 && $2 == "device" && $1 !~ /^emulator-/ { print $1 }' ;;
|
||||
any) "$ADB" devices | awk 'NR > 1 && $2 == "device" { print $1 }' ;;
|
||||
esac
|
||||
}
|
||||
|
||||
if [ -z "$SERIAL" ]; then
|
||||
matches="$(online_matching)"
|
||||
count="$(printf '%s' "$matches" | grep -c . || true)"
|
||||
|
||||
if [ "$count" -eq 0 ]; then
|
||||
echo "android-deploy: no ${TARGET/any/attached} target is online." >&2
|
||||
"$ADB" devices | sed '1d;/^$/d;s/^/ /' >&2 || true
|
||||
if [ "$TARGET" = "emulator" ]; then
|
||||
echo " Start one with: make android-emulator" >&2
|
||||
elif [ "$TARGET" = "device" ]; then
|
||||
echo " Plug a phone in and authorise the adb key." >&2
|
||||
fi
|
||||
exit 1
|
||||
fi
|
||||
|
||||
# Several is ambiguous, and picking the first silently is how a
|
||||
# build lands on a target nobody named. The old run:device did
|
||||
# exactly that.
|
||||
if [ "$count" -gt 1 ]; then
|
||||
echo "android-deploy: several $TARGET targets are online — name one." >&2
|
||||
printf '%s\n' "$matches" | sed 's/^/ /' >&2
|
||||
echo " Pass DEVICE_ID=<serial>, or set ANDROID_SERIAL." >&2
|
||||
exit 1
|
||||
fi
|
||||
|
||||
SERIAL="$matches"
|
||||
fi
|
||||
|
||||
# ---------------------------------------------------------------- #
|
||||
# Install
|
||||
# ---------------------------------------------------------------- #
|
||||
|
||||
echo "android-deploy: $APK ($PKG) -> $SERIAL"
|
||||
|
||||
if ! out="$("$ADB" -s "$SERIAL" install -r "$APK" 2>&1)"; then
|
||||
printf '%s\n' "$out"
|
||||
case "$out" in
|
||||
*INSTALL_FAILED_UPDATE_INCOMPATIBLE* | *"signatures do not match"*)
|
||||
cat >&2 <<EOF
|
||||
|
||||
The copy of $PKG already installed was signed with a different key, and
|
||||
Android never allows that as an update.
|
||||
|
||||
The only way forward is an uninstall — **which deletes that app's data**,
|
||||
and for this app that is the user's library, irreversibly. So it is not
|
||||
done for you. If the installed copy is disposable:
|
||||
|
||||
$ADB -s $SERIAL uninstall $PKG
|
||||
|
||||
If it is not — if this is a released build with a real library on it —
|
||||
install the debug variant instead, which carries applicationIdSuffix
|
||||
".dev" and so sits beside it rather than replacing it:
|
||||
|
||||
wails3 task android:assemble:apk
|
||||
EOF
|
||||
;;
|
||||
*INSTALL_FAILED_VERSION_DOWNGRADE*)
|
||||
cat >&2 <<EOF
|
||||
|
||||
The installed copy of $PKG has a higher versionCode than this build.
|
||||
A bare 'make android' builds versionCode 1; a versioned one builds e.g.
|
||||
10301. Either build with a version:
|
||||
|
||||
YJ_VERSION=1.3.1 YJ_VERSION_CODE=10301 make android
|
||||
|
||||
or, if the installed copy is disposable, remove it:
|
||||
|
||||
$ADB -s $SERIAL uninstall $PKG
|
||||
EOF
|
||||
;;
|
||||
esac
|
||||
exit 1
|
||||
fi
|
||||
printf '%s\n' "$out"
|
||||
|
||||
[ "$LAUNCH" -eq 1 ] || exit 0
|
||||
|
||||
"$ADB" -s "$SERIAL" shell am start -n "$PKG/$ACTIVITY"
|
||||
@@ -34,21 +34,7 @@ cd "$(dirname "$0")/.."
|
||||
|
||||
AVD="${YJ_AVD:-yj-test}"
|
||||
SDK="${ANDROID_SDK_ROOT:-${ANDROID_HOME:-$HOME/Android/Sdk}}"
|
||||
# The third declaration of the app's identity, and the one #159 did not
|
||||
# cash out in -- but the same hazard, so it is derived rather than
|
||||
# written down too. The APK in bin/ is what `make android-install` is
|
||||
# about to install and what `android-launch`, `logs` and `smoke` are
|
||||
# about to address, so it is the authority; whatever Gradle resolved the
|
||||
# applicationId to, suffix included, is in the file.
|
||||
#
|
||||
# The literal survives only as the answer for a tree with no APK built
|
||||
# yet, where these commands are asking about whatever is already on the
|
||||
# device and there is nothing to read. YJ_ANDROID_PKG still overrides.
|
||||
PKG="${YJ_ANDROID_PKG:-}"
|
||||
if [ -z "$PKG" ] && [ -f bin/yellowjacket.apk ]; then
|
||||
PKG="$(./scripts/android-pkgid.sh bin/yellowjacket.apk 2>/dev/null || true)"
|
||||
fi
|
||||
PKG="${PKG:-app.yellowjacket}"
|
||||
PKG="${YJ_ANDROID_PKG:-app.yellowjacket}"
|
||||
# Where `make android-inspect` forwards the WebView's devtools socket.
|
||||
CDP_PORT="${YJ_ANDROID_CDP_PORT:-9222}"
|
||||
# **Not "$PKG/.MainActivity".** A leading-dot activity is resolved
|
||||
@@ -295,24 +281,15 @@ cmd_inspect() {
|
||||
need_sdk
|
||||
pick_device || die "no device -- plug a phone in (USB debugging on) or run 'make android-emulator'"
|
||||
|
||||
local pkg pid candidates
|
||||
local pkg pid
|
||||
pid=""
|
||||
|
||||
# Debug sibling first, release second, whichever way round $PKG was
|
||||
# resolved -- it is read from the built APK now, so it is already the
|
||||
# .dev id whenever a debug build is what is in bin/, and appending a
|
||||
# second ".dev" to it would probe a package that cannot exist.
|
||||
case "$PKG" in
|
||||
*.dev) candidates="$PKG ${PKG%.dev}" ;;
|
||||
*) candidates="$PKG.dev $PKG" ;;
|
||||
esac
|
||||
|
||||
for pkg in $candidates; do
|
||||
for pkg in "$PKG.dev" "$PKG"; do
|
||||
pid=$("$ADB" shell pidof "$pkg" 2>/dev/null | tr -d '\r' | awk '{print $1}')
|
||||
[ -n "$pid" ] && break
|
||||
done
|
||||
|
||||
[ -n "$pid" ] || die "none of: $candidates is running; launch it first"
|
||||
[ -n "$pid" ] || die "neither $PKG.dev nor $PKG is running; launch it first"
|
||||
|
||||
"$ADB" forward --remove-all >/dev/null 2>&1 || true
|
||||
"$ADB" forward "tcp:$CDP_PORT" "localabstract:webview_devtools_remote_$pid" >/dev/null \
|
||||
|
||||
@@ -1,97 +0,0 @@
|
||||
#!/usr/bin/env bash
|
||||
#
|
||||
# Print the package id an APK actually declares — and, given --expect,
|
||||
# refuse when that is not the id the caller was about to act on.
|
||||
#
|
||||
# This exists because the identity is declared twice and nothing made
|
||||
# the two agree. `applicationId` in build/android/app/build.gradle is
|
||||
# what Gradle installs; `APP_ID` in build/android/Taskfile.yml was what
|
||||
# every adb-driven task uninstalled, launched and filtered. They differ
|
||||
# for a reason nobody has to get wrong: the debug buildType carries
|
||||
# `applicationIdSuffix ".dev"`, so a debug build is app.yellowjacket.dev
|
||||
# while the default was app.yellowjacket — the *release* id, and on a
|
||||
# real phone the released app with the user's library on it (#159).
|
||||
#
|
||||
# So the id is read back from the artifact rather than written down a
|
||||
# third time. The APK is the authority because the task that installs
|
||||
# it has just built it: whatever Gradle resolved the applicationId to,
|
||||
# suffixes and flavours included, is in the file, and no default can
|
||||
# disagree with it.
|
||||
#
|
||||
# Usage:
|
||||
# android-pkgid.sh <apk> [--expect <id>]
|
||||
#
|
||||
# Exit codes: 0 printed the id; 1 could not read it; 2 --expect failed.
|
||||
set -euo pipefail
|
||||
|
||||
die() { echo "android-pkgid: $*" >&2; exit 1; }
|
||||
|
||||
APK=""
|
||||
EXPECT=""
|
||||
while [ $# -gt 0 ]; do
|
||||
case "$1" in
|
||||
--expect) EXPECT="${2:-}"; shift 2 ;;
|
||||
-*) die "unknown option $1" ;;
|
||||
*) APK="$1"; shift ;;
|
||||
esac
|
||||
done
|
||||
|
||||
[ -n "$APK" ] || die "usage: android-pkgid.sh <apk> [--expect <id>]"
|
||||
[ -f "$APK" ] || die "no such APK: $APK"
|
||||
|
||||
# aapt2 lives under build-tools/<version>/, which is versioned, so it is
|
||||
# resolved rather than pinned. PATH first, so a system aapt2 (Arch ships
|
||||
# one) works without an SDK layout at all.
|
||||
find_aapt() {
|
||||
local sdk name
|
||||
for name in "$@"; do
|
||||
command -v "$name" 2>/dev/null && return 0
|
||||
done
|
||||
sdk="${ANDROID_HOME:-${ANDROID_SDK_ROOT:-$HOME/Android/Sdk}}"
|
||||
for name in "$@"; do
|
||||
ls "$sdk"/build-tools/*/"$name" 2>/dev/null | sort -V | tail -1 | grep . && return 0
|
||||
done
|
||||
return 1
|
||||
}
|
||||
|
||||
pkg=""
|
||||
|
||||
# `aapt2 dump packagename` answers in one word and is the cheapest of
|
||||
# the three. aapt1 is the fallback because it is what older build-tools
|
||||
# carry and what the issue's own measurement used.
|
||||
if AAPT2="$(find_aapt aapt2)"; then
|
||||
pkg="$("$AAPT2" dump packagename "$APK" 2>/dev/null | head -1 | tr -d '\r')" || true
|
||||
fi
|
||||
|
||||
if [ -z "$pkg" ] && AAPT="$(find_aapt aapt)"; then
|
||||
pkg="$("$AAPT" dump badging "$APK" 2>/dev/null |
|
||||
sed -n "s/^package: name='\([^']*\)'.*/\1/p" | head -1)" || true
|
||||
fi
|
||||
|
||||
# Guessing here is the bug this file exists to prevent, so an unreadable
|
||||
# APK is a hard failure and never a fallback to a written-down default.
|
||||
if [ -z "$pkg" ]; then
|
||||
die "could not read a package name from $APK.
|
||||
Install the SDK build-tools (aapt2), or set ANDROID_HOME to an SDK
|
||||
that carries them: sdkmanager 'build-tools;34.0.0'"
|
||||
fi
|
||||
|
||||
if [ -n "$EXPECT" ] && [ "$EXPECT" != "$pkg" ]; then
|
||||
cat >&2 <<EOF
|
||||
android-pkgid: refusing to act on a package this APK does not declare.
|
||||
|
||||
the APK declares: $pkg
|
||||
the task expects: $EXPECT
|
||||
APK: $APK
|
||||
|
||||
These must agree, and when they do not it is the *expectation* that is
|
||||
wrong: the APK is what Gradle built. A debug build carries
|
||||
applicationIdSuffix ".dev" (app/build.gradle), so a task that assembles
|
||||
a debug APK and then addresses the unsuffixed id is addressing the
|
||||
released app — which on a real device is the user's install, with their
|
||||
library in it (#159).
|
||||
EOF
|
||||
exit 2
|
||||
fi
|
||||
|
||||
printf '%s\n' "$pkg"
|
||||
Reference in New Issue
Block a user