Repository navigation
Added
-
QuickActions.IsRateLimitingActive— why a write was refused. A refused
Add/AddList/Updatereturned the samefalsefor all three of its
causes: Android's background write throttle, an exhausted shortcut budget, and
an id another publisher owns. Only the first one clears by itself, and only
the log line said which had happened. The new read-only property surfaces
Android'sisRateLimitingActive, so a game that writes its "continue playing"
shortcut on backgrounding can tell "retry once foregrounded" from "retrying
will never work". It is advisory: the flag is racy by nature — the OS can
apply or lift the throttle between the read and the next write — so nothing
in this package gates on it, and the write's own return value stays
authoritative. False on iOS (no throttle exists) and in the Editor, like
MaxShortcutCountis 0 there. -
The demo shows a build-time placeholder, and CI gates on the resolved
value.{version}/{build}and friends landed in 0.4.6 with headless
tests only: no build CI produced, and no device or Simulator anyone ran, had
ever carried one, so what a resolvedv1.4.0 (37)looks like on a real home
screen was unconfirmed. Every testbed now bakesContinue's subtitle as
Resume v{version} ({build})and pinsbundleVersion 1.4.0with
build number37on both platforms, so it resolves to the exact literal the
docs already cite. It rides an existing static rather than adding a fourth:
iOS shows at most four quick actions and the demo's three statics plus the
seeded runtime item already fill them.Three checks read the resolved value back, so interpolation silently ceasing
to run turns a leg red instead of shipping the raw token — which on a launcher
looks like a label, not a bug.ios-exportparses the exportedInfo.plist
(ubuntu, every push, all three Unity lines including 2021.3, which has no
Simulator coverage at all) and also rejects a stray{in any baked label;
android-buildreads the string out of the APK resource table withaapt2,
on all four legs including the minified release one; andios-springboard
now requires it among the labels of the menu SpringBoard actually opens, which
is the only one of the three that proves it rendered.Run 99 also measured something worth knowing when you author Android labels: a
launcher draws one label per row and falls back to the short one when the
long one does not fit, so an over-long version subtitle does not truncate — it
disappears. WithResume your save - v1.4.0 (37)the emulator's popup drew
Continue, while its neighbours at 16 and 18 characters drew their subtitles.
The demo's subtitle is the shorterResume v{version} ({build})for that
reason, and README's placeholders section now warns about it.Run 100 (2026-09-17) is the verdict on all of it. The three checks passed
on every leg, and both platforms render the resolved value: the Android
emulator's popup drewResume v1.4.0 (37)on 2021.3, 2022.3 and Unity 6, and
SpringBoard's own menu listedContinue, Resume v1.4.0 (37)on iOS 26.2 and
26.5, with both taps on each leg still passing. Emulator and Simulator only —
no handset and no iPhone has shown it. -
CI taps a quick action on an app that is already running. Both real
SpringBoard taps this repo asserts — the static row, and since run 94 the
runtime-added one — cold-start the app, so every id CI has ever watched arrive
travelled the launch options. The warm path, a tap handed to a live process
through the lifecycle's ownperformActionForShortcutItem, was exercised only
byios-simulator-coex's synthetic sends, which prove what the package does
with a payload and never that UIKit would route one to it.ios-springboard
now runs a third pass per leg:run_springboard_tap.shlaunches the app,
lets the Unity runtime boot, records the pid, and the XCUITest — inQA_WARM
mode — only sends it behind SpringBoard and taps, without terminating it.The pid is the evidence, and finding that out cost a run. The first
attempt asked XCUITest whether the app had backgrounded. Run 109 answered
.runningForegroundon both legs, fifteen seconds after the Home press,
with SpringBoard's own home screen up and covering the app — so its
app.statefor an app reached by bundle id simply does not follow a Home
press, and both legs skipped with a message that read as if the app had died.
What the warm claim actually needs is "this is the same process", which only
simctlcan see: the pass compares the pid before the launch-and-settle with
the pid after the tap. Unchanged means re-entered, not relaunched. A mismatch
warns and retracts the claim rather than failing the leg — as does XCUITest
reporting the process gone at tap time — because a tap on a dead app is the
cold pass, which two other passes already cover.What run 110 saw:
PASSon both supported legs — 2022.3.62f3 / iOS 18.6
(app-delegate lifecycle) and 6000.3.21f1 / iOS 26.5 (scene manifest) — with
daily_rewardreachingPerformed1 second after the tap, against the
35–54 s a cold launch takes, and the pid identical either side of it (28398
and 32706). All four rows were in the one menu SpringBoard opened, the
Continuerow still reading its resolvedResume v1.4.0 (37). Warm delivery
is now established on the Simulator; it remains unobserved on a device. -
The iOS coexistence probe pins queue order across several taps. Taps
arriving back to back before C# drains were unasserted on every platform: the
probe sent one id at a time. It now sendsa,b,aon one runloop turn
and requires the queue to hand back exactly that — which pins both properties
at once, FIFO order and no collapsing of a repeat (only a COLD source arms the
dedup marker, and it is spent by the time the probe runs). Each of the three
completion handlers must also run exactly once.multi-id-queue-orderand
multi-id-completion-eachjoin the PASS names the workflow requires by name,
and passed on their first run (109) on both coex legs, in the default launch
and in the shadowed-configuration one. -
A sentinel watches whether any real iOS SDK starts competing for the
quick-action selectors.Examples~/Coexistence/proves this package composes
with a swizzler shaped like the real ones, but a mock host cannot say whether a
real SDK has begun hooking
application:performActionForShortcutItem:completionHandler:itself. An audit
said none does — Firebase/GoogleUtilities, AppsFlyer, Branch, OneSignal,
Adjust, Singular and Braze all swizzle for URL opening, universal links and
remote notifications instead — and that answer was true of one version on one
day.tools~/check_sdk_swizzlers.pynow re-reads GoogleUtilities'
GULAppDelegateSwizzler.mandGULSceneDelegateSwizzler.mat pinned tag
8.1.0on every CI run (the newsdk-swizzler-sentineljob — Linux, seconds,
no Unity), fails the day either file mentions a shortcut, and prints the
selectors each one does hook so a narrower change is visible too. It reads
upstream and vendors nothing; an unreachable network warns and passes, because
that is the automation missing, not a finding. Linking a real SDK into a CI
build was considered and rejected: the audit says there is nothing to catch
there, andExamples~/Coexistence/README.mdnow carries the citation for that
claim instead of leaving it as prose. -
The Android string-resource escaper has tests.
EscapeResValueruns over
every static shortcut's label on every build that configures one, and had no
coverage at all: XML metacharacters, Android's own span delimiters, a leading
@/?, edge whitespace and dropped control characters were each one edit away
from a regression nothing would catch until aapt2 failed a real Gradle build or
a device rendered a truncated label. Seven tests now pin the exact written form,
driven throughAppendLocalized(the real emission path) rather than the
private escaper. All seven pass against the current implementation — a guard,
not a fix.
Changed
-
CI fans out instead of running in series. The seven Unity jobs were
chained withneeds:—tests→android-build→ios-export→
ios-export-coex→tests-unity6-latest→android-shrink-verify→
gate-off— so that exactly one editor ever activated at a time. The chain
cost 29–38 minutes of wall clock against 13 unchained, and runner minutes are
free on a public repo, so it bought nothing else. What it insured against has
never happened: across 30 runs nogame-cistep has conclusionfailure, and
run 25 activated eleven legs at once with every one logging
Successfully returned ULF license— and GameCI's own documentation says the
concurrency limit "is not an issue for free licenses", which is what a
Personal.ulfwith noUNITY_SERIALis. Every job now waits on the licence
gate alone, exceptgate-off, which waits on its real producers: it
downloads the demo APK fromandroid-buildand the Xcode project from
ios-export, so the licence gate alone would have raced them.max-parallel
stays at 2 so this is the only variable that moved; the workflow header
records how to put the chain back.Measured, and not what was predicted. Run 103, the first unchained run,
took 36m01s — inside the chained 29–38 range, not the ~13 the old comment's
unchained figure suggested (that figure predates the macOS matrix growing to
ten jobs). What the un-chain did fix is the Linux half, which now finishes at
16 minutes with ten jobs running three minutes in; the macOS half runs to 35
and owns the critical path, entering in waves behind GitHub's concurrent-macOS
cap. The largest single cost turns out to be a canary that gates nothing —
ios springboard tap (unity6-xcode27), 23 minutes of a macOS slot on every
PR. The chain still had to go (it constrained the Linux side for nothing, and
gate-offhad no real dependencies at all), but the next change is the one
that moves wall clock. -
The Xcode 27 experiment runs weekly instead of on every PR. Six macOS
jobs existed only to test a toolchain no Unity line supports yet: the four
xcode-27canary legs (continue-on-error, never required) and both legs of
ios-crossrun, which are xcode-27-bound as well — one downloads the canary's
.app, the other runs on thexcode-27runner, so it could not stay behind
while they moved. Run 103 measured what they cost: the macOS half of the run
owns the critical path, its jobs enter in waves behind GitHub's
concurrent-macOS cap, andios springboard tap (unity6-xcode27)alone held a
slot for 23 of the run's 35 minutes. They now run on the weekly cron and on
workflow_dispatch; a push or PR gets the core legs. The trade is stated
rather than hidden: an iOS-27 regression surfaces within a week instead of in
the same PR. Every per-leg comment moved with the legs — the conditional
matrices carry the same documentation the lists did.What governs the wall clock is runner availability, not the job graph.
Four runs: 36m01s and 46m37s with twelve macOS jobs, then 41m27s and 25m37s
with six. The cleanest measurement is the last pair — runs 105 and 106 ran the
same six-macOS-job workflow, one docs-only commit apart, and their total
macOS runner queue wait was 1h20m16s against 5m09s: a sixteenfold
swing with nothing in the workflow changed. Linux queue wait stayed 13-15
minutes throughout. Two attempts at shortening this pipeline by reshaping the
job graph — un-chaining, then halving the macOS matrix — both came back inside
noise that large, so the remaining graph-level ideas (folding
ios-springboardintoios-simulator, pre-booting the simulator) are not
worth their risk either.An earlier revision of this entry said flatly that the change "did not make
the pipeline faster", written when runs 103-105 were all there was. Run 106's
25m37s — the fastest recorded, and the only one under the chained 29-38 range
— does not support that as stated: six macOS jobs average 33 minutes against
twelve jobs' 41. Four points cannot separate that from the queue swing above,
so the claim is narrowed to the one the evidence carries: the job graph is not
the lever, and no total measured here settles what this change bought on its
own.
What this change is actually worth: half the macOS demand, six fewer jobs, and
— because the canaries were the only permanently-red checks — a run where a
red check means something again.
Fixed
-
Runtime bitmap icons are downscaled to the Android icon budget.
resolveIconhanded whateverAndroidBitmapFiledecoded to straight to
Icon.createWithBitmap/createWithAdaptiveBitmap— no dimension check.
The documented way to build one istex.EncodeToPNG(), and a Unity
Texture2Dis commonly 512 or 1024 px square, so the full bitmap crossed a
binder transaction on every publish and the launcher rescaled it afterwards
anyway. The bitmap is now measured againstgetIconMaxWidth/Heightand, only
when it exceeds them, scaled down with the aspect ratio preserved. An
adaptive bitmap gets 1.5× that box —1 + 2 * AdaptiveIconDrawable.getExtraInsetFraction(), the platform's own formula for
the mask inset — so a correctly authored safe zone survives the downscale.
Best-effort throughout: an unreadable budget (0), a missingShortcutManager
or any throw leaves the bitmap untouched, because an oversized icon is still
a valid icon while a thrown exception would cost the whole write. Seven new
Java smoke checks pin the ratio, the adaptive allowance, the in-budget
pass-through and the unreadable-budget case. -
A define-off iOS build no longer ships the template images of a define-on
one.QuickActionsGateCleanupiOSremoved theQUICKACTIONS_ENABLEDmacro and
the markedInfo.plistentries, but nothing removed theQuickActionsIcons/
folder, the PBX file references that registered it in Copy Bundle Resources, or
the manifest recording what was copied — that logic lives only in
SyncTemplateImagesCore, inside theQUICKACTIONS_ENABLED-gatedEditor/iOS
assembly, which does not compile when the define is off. On an Append build
over an Xcode project a previous enabled build wrote — the exact case this
file's header says it exists for — the icons kept shipping in a bundle with no
quick actions in it. The cleanup is ownership-scoped like the plist removal: it
deletes what our manifest names, leaves a file a host dropped beside them alone,
and removes the folder only once it is empty.The folder and manifest names are now duplicated across two assemblies that
cannot reference each other (the gated one writes them, the ungated one has to
find them), sotools~/check_frozen_strings.pypins both copies — the same
mechanism that keeps the ownership marker in step across Java, Objective-C and
C#.CI does not assert this, and cannot as the workflow stands — the
gate-off
job exports both projects fresh (Replace), where the folder never existed, and
the testbeds configure noIosTemplateImages, so the control such a check needs
does not exist either and it would pass by vacuum. Five unit tests cover the
disk half instead, which is the half that decides what reaches the bundle. -
The icon note in Project Settings no longer clips.
IconType's property
drawer reserved the note's height by measuring it against the whole view width
less 40 px, then drew it into the real property rect — which, for the
IconTypeinside the static-shortcut list, is narrower by the foldout indent,
the drag handle and the list padding. Narrower wraps into more lines, so the
reserved height fell short and the last line was cut off: the opposite of the
error the code's own comment intended ("a line too many, never a clipped
one"). The drawer now remembers the width it actually drew at and measures the
next pass against that; the first pass uses a deliberately narrow fallback,
which over-reserves instead. -
EnsureLoadedno longer states a guarantee the code does not make. Its
documented return contract said a failed localization re-push "changes only the
rendered language, not which ids are installed".Pushalready documented the
opposite: it sends the whole set, and on Android the stale-removal phase runs
before the add that was refused, so a newly appeared manifest or pinned
collision can have dropped one of our ids on the device while the managed list
keeps claiming it. The behaviour is unchanged and still the right trade —
dropping_loadedthere would turn every later read into an OS write, and
AddListrelies on a true return meaning loaded — but the cost is now recorded
at both sites:GetAll/IsAddedcan over-report one id until the next
successful push. No shortcut is lost either way. -
A shortcut tap arrives as
Performedon real Android hardware. Every tap
this package had ever observed was an emulator's or the iOS Simulator's. On
2026-09-17 the owner long-pressed the demo icon on a Moto G Play 2024
(Android 14, thequickactions-demo-apk-2022.3artifact) and tapped the
runtime-addeddailyrow — "Claim today", the long label Android renders —
and the id reachedPerformed. Recorded with the limit it has: the run did
not note whether the app had been force-stopped first, so cold and warm
delivery are still not distinguished on hardware. No code changed; the docs
that listed hardware tap delivery as unverified no longer do. -
Two documentation claims that the previous two changes left behind.
GETTING_STARTED.mdstill told readers that no hardware tap had been
confirmed asPerformedon either platform — the Moto G Play run on
2026-09-17 confirmed the Android one, andCHANGELOG.md,CLAUDE.md,
README.mdandPRODUCTION_READINESS.mdwere all updated then while this file
was missed.CONTRIBUTING.mdsaidverify.shcompiles the C# in ten build
configurations; there are eleven, which.verify/README.mdandCLAUDE.md
already said.