Skip to content

v0.6.0

Choose a tag to compare

@github-actions github-actions released this 02 Sep 21:06
3ff6aef

Added

  • CI now builds and smokes a release-configuration Android player. The two
    things a shipping build does that a development build does not — R8
    minification and Managed Stripping Level High — were the last build
    configuration nothing here had ever run, and both bear on this package
    specifically: the C# runtime finds the Java class
    com.emindeniz99.quickactions.QuickActionsBridge by name over JNI, which
    a minifier is free to rename or strip, and the package ships no link.xml for
    the managed linker to read. A fourth android-build matrix leg,
    2022.3-release, builds Testbed2022 through the new
    TestbedBuilder.BuildAndroidPhoneRelease — non-development player, stripping
    High, minifyRelease on — against the keep rule README.md tells consumers
    to add: -keep class com.emindeniz99.quickactions.** { *; } in
    Assets/Plugins/Android/proguard-user.txt, now checked into all three
    testbeds and switched on through useCustomProguardFile, because the
    documented recipe is the supported configuration and so is the thing worth
    testing. The minified APK takes the same aapt2/manifest/dex assertions as
    every other leg (its dex class names are exactly what R8 could have renamed)
    and then the same API 30 emulator smoke, where a shortcut must register and a
    warm and a cold tap must each arrive as Performed. Nothing in the package
    itself changed. Its first run (2026-09-02, PR #19 run 64) was green:
    UnityLinker ran the High rule set (global-metadata.dat 1.70 → 1.18 MB), R8
    collapsed four dex files into one and left one-and-two-letter class names
    around the three package classes it had been told to keep, the APK came out
    at 14.2 MB against the development build's 23.7 MB, and the smoke registered
    three shortcuts and got a warm and a cold tap back as Performed — the
    documented recipe holds, and stripping High needed no link.xml.

  • The built-in Android icons now ship an API 26+ adaptive variant. On API 26+
    AOSP does not draw a legacy shortcut drawable as authored — it wraps it onto a
    white plate at 0.70 of the viewport, so the built-ins rendered as a small
    indigo disc inside a white ring, out of place beside their neighbours. Every
    Android build now also writes
    res/drawable-anydpi-v26/ic_quickaction_builtin_<name>.xml, an
    <adaptive-icon> under the same resource name, over two layers of its own
    (ic_quickaction_builtin_<name>_background, full-bleed indigo, and
    …_foreground, the same glyph scaled into the 66-of-108 safe zone so no
    launcher mask clips it). The plain vector stays for API 25 and the resource
    qualifier picks between them, so nothing that names an icon changes: the Java
    lookup, the static android:icon="@drawable/ic_quickaction_builtin_<name>"
    bake, the ic_quickaction_* keep rule, the settings opt-out and the define-off
    sweep all cover the new files unchanged. About 6 KB of XML for all four icons.
    Not yet seen on a launcher — neither variant.

  • The android-smoke legs now photograph the launcher's long-press sheet.
    dumpsys shortcut proves each shortcut registered with an icon resource;
    nothing has ever seen that art drawn by a launcher. With CAPTURE_LONGPRESS=1,
    tools~/device-smoke/android_device_smoke.sh ends — after its PASS:
    verdict — by going home, opening the app drawer, locating the app's icon by
    its launcher label in a uiautomator dump, long-pressing it, and keeping
    longpress.png plus both hierarchy dumps; CI uploads them per leg as
    longpress-<leg>. It asserts nothing and can fail nothing: the gesture and
    the sheet belong to whatever launcher the system image ships, so the capture
    runs with errexit off, bounds every adb call with timeout, prints one
    grep-able shortcut sheet visible: yes/no, and leaves the verdict to the
    eight steps above it. Its first run (both images ship the Pixel launcher)
    found the API 30 swipe opening no drawer and the API 35 swipe-hold opening
    no sheet, so the capture now escalates through KEYCODE_ALL_APPS, the
    launcher's own "Apps list" handle and the ALL_APPS intent when the icon
    is not found, and presses with input motionevent DOWN / hold / UP, taking
    the screenshot and the hierarchy while the finger is still down. That
    second attempt (run 56) photographed the Pixel launcher's "App suggestions"
    sheet on API 35: the icon it pressed was the hotseat's prediction of the
    app, which never opens the shortcut popup, and on API 30 no opener moved
    the launcher off the home screen. A predicted-app match now counts as a
    miss, so the drawer escalation runs and tries to find, and then press, a
    real icon. Its first run recognised the prediction and escalated, and no
    opener moved the API 35 launcher off its home screen either. On the run
    after that (61) the API 30 swipe opened the drawer for the first time, the
    press landed on the real icon, and longpress-2022.3 holds the first
    photograph of the popup: the three static entries and the runtime-added
    daily, with the built-in add and favorite art drawn on two of the rows.
    The verdict line said no on that run — it matched the titles while
    Launcher3 draws the long label (the Subtitle) when it fits — so
    CAPTURE_TITLES entries are now Title=Subtitle pairs, either form counts,
    and when nothing was pressed the line says so instead of blaming the
    hierarchy. The API 35 drawer opened once the swipe stopped starting on the
    hotseat's search bar: the dumps of both images put the old 90% start on a
    search widget, so the capture now swipes from 65% of the height first — the
    API 35 drawer opened on the first run of that (PR #19 run 64), the press
    landed on the real icon and the verdict line read yes with all three long
    labels — and from the bottom edge second, the start API 30 had answered
    once. Both images' sheets are on file; the capture stays best-effort and is
    never a check.

  • The settings page says what an Icon does on Android, next to the field.
    A property drawer for IconType adds one line under the popup: "built-in
    drawable" for Add / Compose / Favorite / Play, or the exact
    ic_quickaction_<name> the project must ship for the other 25 — which used
    to surface first as a build-log warning. The four names come from a second
    generated file, Editor/QuickActionsBuiltInIconSet.cs, written by the same
    generator from the same list (the Android assembly holding the art is
    UNITY_ANDROID-only, so the always-present Editor assembly needed its own
    copy), held to the art by --check and by harness tests that also pin the
    drawer's name derivation to the Java ICON_NAMES table member by member,
    that the note stops promising a drawable when Write built-in Android
    icons
    is off, and that in the static list it says what the baker needs:
    a static shortcut bakes no icon for a non-built-in choice unless
    AndroidDrawable names one. The note wraps at narrow inspector widths.

  • AGENTS.md — the shortest correct integration path for an AI coding
    agent (or a hurried human): install, define, asmdef reference, the guarded
    snippet, the checks that prove it worked, and the don'ts. The README gains a
    60-second quickstart with the same guarded snippet, a contents list, and an
    embedded-package (vendoring) install option.

  • CI runs the iOS native hooks under a mock coexistence host. Two new
    legs, ios-export-coex and ios-simulator-coex, re-export Testbed2022 and
    Testbed6 with four sources from Examples~/Coexistence/iOS/ copied into
    Assets/Plugins/iOS, so one app is at once an IMPL_APP_CONTROLLER_SUBCLASS
    host, a category +load swizzle of the two app-delegate selectors, and a
    GoogleUtilities-style isa proxy — the three shapes a project's own
    UnityAppController subclass, AppsFlyer / OneSignal-style categories and
    Firebase take. The Simulator launch must print every QA-COEX: PASS line by
    name plus the package's own install line; the category +load records
    whether it ran before or after the package's class +load and composes
    either way, because the first run showed both — category first on the
    2022.3.62f3 export, class first on 6000.3.21f1, every file in
    UnityFramework both times — where the README had asserted a class
    +load always runs first. On the scene testbed a second launch shadows
    application:configurationForConnectingSceneSession:options: without
    calling super and requires the install line to flip from "via
    configuration" to "via notification". Until now the ios-simulator leg
    only required the process to still exist, which an app with no hooks
    installed satisfies too. The lifecycle each leg exercises is asserted, not
    described. First run (2026-09-02): on Testbed6 (6000.3.21f1, scene
    manifest, iOS 26 Simulator) every check passed on both launches — the
    UIScene path's first exercise anywhere: hooks on UnityScene via the
    configuration wrapper, via the notification fallback when the host shadows
    the selector, the cold launch item queued once with NO returned, the
    warm tap once with one completion, the host's discarded NO not
    double-delivering. On Testbed2022 the mock host itself was wrong twice: its
    category +load demanded an order objc4 does not promise, and its
    scene-configuration override opted the manifest-less app into the scene
    lifecycle — UIKit calls that selector on any delegate that implements it,
    manifest or not, and the app then never became active. Both corrected: the
    order is recorded, and the override exists only under a manifest.

  • One NSLog per launch names the branch each iOS hook took.
    [QuickActions] iOS hooks: didFinishLaunching=… performAction=… sceneConfig=… manifest=… at the end of +load, and
    [QuickActions] iOS scene hooks installed on <class> via configuration (or
    via notification) when the scene hooks land — the only way an adopter, or
    CI, can tell a working install from an inert one.

  • Samples~/AndroidIcons — a working .androidlib icon example. The
    custom-Android-icon recipe as an importable plug-in rather than five written
    steps: Package Manager ▸ Samples ▸ Import copies a bare
    QuickActionIcons.androidlib — AndroidManifest.xml and res/ at its root,
    the shape CI measures on the 2022.3 testbed — with ic_quickaction_search
    and ic_quickaction_home drawn like the built-ins, under Assets/, where
    Unity picks it up on the next Android build. Its README says how a runtime
    Add and a static item each reach the drawable, how to confirm it in the
    APK with aapt2, the Unity 6 (AGP 8) namespace change, and that the
    .unitypackage install cannot carry an .androidlib. The folder ships with
    its Android-only PluginImporter .meta; tools~/gen_meta.py now treats a
    *.androidlib as one plug-in (a .meta for the folder, none for its
    contents) in both its generate and --check passes.

Changed

  • The Android emulator smoke relaunches an app whose player never came up.
    Twice on 2026-09-02 (runs 52 and 65, both on the API 30 image, both on APKs
    that passed unchanged the next time) the smoke's launch reached the
    foreground and then nothing happened: no VkInstance, not one line under
    logcat's Unity tag, and after the full budget dumpsys shortcut still
    showed zero calls. That is the emulator's ARM translation stalling the
    player, not the package. Step 5 now spends half its budget, and if nothing
    has been published and the player has not logged at all, force-stops and
    launches once more before spending the other half — loudly, so a run that
    needed the second launch says so. A player that did come up and published
    nothing is not relaunched: that would be the package's failure to report.

  • The Unity 6000.6 canary retries an editor that died before the suite
    ran.
    tests (unity6-latest) has twice (main run 41, PR #16 run 53) ended
    with exit 137 at "Begin MonoManager ReloadAssembly" — the editor killed
    during its own start-up, no test executed — and started fine on the runs
    between. The job now starts the editor once more when, and only when, the
    first attempt left no editmode-results.xml; an attempt that produced
    results is final, so a real test failure is never retried, and a verdict
    step turns the job red unless the last attempt passed.

  • The iOS status claims are scoped to the path that was actually run. The
    Simulator run every doc cited was logged as "Unity 6.3" with no patch number
    and its exported Info.plist was never inspected, so which of the two iOS
    delivery paths carried that tap is unknown — 6000.3.8f1 is where Unity
    starts emitting UIApplicationSceneManifest and Apple stops calling the
    app-delegate selector. README Status, PRODUCTION_READINESS.md (the one
    iOS row becomes two, and the older Simulator run is credited to neither —
    what each row claims now comes from the coexistence leg), CLAUDE.md
    and ROADMAP.md now say so, and the ROADMAP's scene items start with
    "confirm the app still starts": the package adds
    application:configurationForConnectingSceneSession:options: where Unity
    has none, so a wrong return value there would mean no engine at all. The
    README gains Coexisting with other native iOS plugins: the five
    selectors the package touches, why it hooks the root class from a class
    +load, and what each surveyed SDK family does — Firebase / GoogleUtilities
    isa-swizzling inherits the package's IMPs because it adds no ivars, Firebase
    C++ / OneSignal / AppsFlyer category swizzles chain after it, the listener
    SDKs (Facebook, Helpshift, Unity IAP) cannot collide, Singular's scene
    swizzle composes, and Unity as a Library and the Swift project type are
    unsupported. It is a source audit, and says so.

  • The custom-asmdef integration shape is compiled by CI in both
    configurations.
    README tells a project whose scripts live in their own
    assembly definition to reference EminDeniz99.QuickActions; with the define
    off that assembly is not compiled, so whether the referencing assembly still
    builds was an assertion about Unity, not a measurement. Testbed2022 now
    carries Assets/Integration/Testbed.Integration.asmdef, which references the
    package and holds the guarded quickstart component; the define-on legs and
    the define-off gate-off build compile it on every push, and the README
    also describes the gated-glue-asmdef alternative.

  • The .androidlib icon recipe is measured on a real APK — and the
    measurement corrected it.
    README's recipe for a consumer's own Android
    shortcut icons rested on Unity's documentation and on reading Unity's
    com.unity.mobile.notifications, never on a build. Testbed2022 now carries
    an .androidlib under Assets/ and one inside an embedded UPM package
    (Packages/com.quickactions.testlib/), and the 2022.3 leg of
    android-build requires their drawables in the APK resource table on every
    push. The first run proved the documented layout wrong: a bare .androidlib
    (no build.gradle of its own) takes AndroidManifest.xml and res/ at its
    root — the src/main/ layout the README prescribed, Unity's own package's
    layout only because that package ships a build.gradle, was silently
    ignored. The recipe, its first "trap" and the keep-file example now say so,
    and a decoy planted under src/main/res/ must stay absent from the APK on
    every push, so the trap is asserted rather than assumed.

  • The Unity 6 Android leg now builds twice and asserts the second APK. CI
    had only ever built a clean Gradle project on a fresh runner, so nothing knew
    whether the icons, res/raw/quickactions_keep.xml, the baked shortcut
    resources and the trampoline <activity> survive an INCREMENTAL build, where
    Unity reuses the project it staged under Library/. The leg runs
    unity-builder a second time over the same project directory
    (TestbedBuilder.BuildAndroidPhoneSecond, same configuration to
    Builds/QuickActionsDemo-phone-2.apk), uploads that APK as
    quickactions-demo-apk-unity6-incremental, and runs the same aapt2
    assertions against it — one function over the leg's APKs rather than a copy
    per APK. The job summary names which of the two was the incremental one.

  • The .unitypackage carries the docs the README links to. The classic
    install now includes GETTING_STARTED.md, SECURITY.md,
    PRODUCTION_READINESS.md and AGENTS.md next to the four root docs it
    already shipped, so a reader of the packed README no longer hits dangling
    links. The README's usage example is #if QUICKACTIONS_ENABLED-guarded,
    says where the settings asset lives, and the API table states that a null
    item throws — the one way any call throws.

  • CI proves the gate and measures the footprint on every push. A new
    gate-off job builds the 2022.3 testbed with QUICKACTIONS_ENABLED off —
    an IL2CPP APK in android-build's exact configuration and an iOS Simulator
    export — and asserts the package left nothing behind: no trampoline
    <activity> or shortcuts meta-data in the manifest, no quickactions_* /
    qa_* / ic_quickaction_builtin_* resources, nothing of the package's
    assembly in the IL2CPP metadata, no QUICKACTIONS_ENABLED macro in the .pbxproj, no
    marked UIApplicationShortcutItems. Every negative is paired with a positive
    control — the define-on artifacts from the same run must trip the same
    probes, or the check declares itself blind instead of green. The two APKs
    are then diffed entry by entry, plus the whole-file size: that difference is the package's footprint,
    printed in the job summary and held under 1 MiB, so an asset or code path
    that starts shipping turns the job red. PRODUCTION_READINESS.md's two gate
    rows move from "build-proven once, 2026-07-17" to CI. TestbedBuilder gains
    BuildAndroidPhoneNoDefine / BuildiOSSimulatorNoDefine, and its
    DisableDefine / EnableDefine now flip both mobile targets.

    The first measurement (run 51) read 1,077,821 bytes and failed the ceiling —
    and the entry-by-entry diff said why: libunity.so alone accounted for
    1.4 MiB uncompressed, because the define-off build had dropped the IMGUI,
    TextRendering, InputLegacy and both TextCore engine modules. Nothing in the
    package uses them (its runtime reaches AndroidJNI and JSONSerialize, present
    in both APKs); the Demo sample does, and the Demo wrapped its whole file
    in #if QUICKACTIONS_ENABLED, so with the define off its MonoBehaviour
    vanished from Assembly-CSharp, engine-code stripping removed the modules
    only it used, and their weight was billed to the package. The Demo now keeps
    its component and IMGUI shell compiled in both configurations and guards
    only the package calls — the README's own guidance, and what the
    Testbed.Integration component already did — so the same engine modules
    stay on both sides of the diff. A new harness config, SampleOff, compiles
    that #else branch the way a define-off device build does (no define, no
    Runtime), which no config did before. The Demo's own namespace,
    EminDeniz99.QuickActions.DemoSample, therefore stays in a define-off
    build's IL2CPP metadata — as any consumer namespace would — and run 52
    flagged exactly that as a leak, because the metadata probe grepped for the
    namespace prefix. It now names what only the assembly leaves behind: the
    image name EminDeniz99.QuickActions.dll, the Internal namespace and the
    root namespace's namespace|Type strings — 12 lines on the define-on APK,
    none on the define-off one — and a leak report prints every metadata line
    mentioning the namespace, probe-matching or not. With the Demo on both
    sides, run 52's APK pair diffed through the job's own script measures
    144,061 bytes (140.7 KiB) compressed: libil2cpp.so +149.7 KiB (arm64)
    and +122.0 KiB (armv7) uncompressed, global-metadata.dat +31.4 KiB,
    libunity.so +27.0 / +19.9 KiB, and about 10 KB of resources — the
    eighteen files the package writes.

  • The Demo sample survives a define-off build as a real component. With
    QUICKACTIONS_ENABLED off, Samples~/Demo/QuickActionsDemo.cs used to
    compile to nothing, so a define-off build of its scene carried a "missing
    script". The component and its on-screen shell now compile either way; with
    the define off the buttons report that the package is not compiled instead
    of calling it. Define-on behaviour is unchanged — the same catalog, log lines
    and autotest hook the device smoke drives.

Fixed

  • Both scene-discovery routes bind only to Unity's own scene delegate. The
    UISceneWillConnectNotification fallback learned the UnityScene-ancestry
    rule in this release; the configuration wrapper still installed the scene
    hooks on whatever class the first connecting session declared. A manifest
    may declare more than one role — CarPlay, an external display — and when
    such a session connects before Unity's window, that install burned the
    process-wide one-shot on the host's class (Unity's scene never hooked) and
    added windowScene:performActionForShortcutItem:completionHandler: to a
    class that lacked it, with the owner still recorded as confirmed. One
    shared rule now sits in front of both routes: bind only to UnityScene or
    a subclass when this process has that class (a non-Unity class is logged and
    left alone, one-shot intact), and bind to the first declared class with the
    owner recorded as unconfirmed when it does not. Found by review; no CI leg
    drives a multi-role manifest yet.
  • A hostile local app can no longer crash the game through the trampoline.
    QuickActionsTrampolineActivity is exported (the launcher has to start it),
    so any app can start it with arbitrary extras — and reading the action id
    unparcels the whole bundle, so a Parcelable this app cannot load threw
    BadParcelableException out of onCreate: a process crash attributed to the
    game. The read is now contained — a bundle that cannot be read is logged and
    treated as no tap — and the launch-intent lookup sits inside the existing
    catch too. A new Java smoke scenario drives the hostile bundle (111 checks).
  • A failed native read is never mistaken for an empty shortcut set.
    QuickActionList.Parse returns null for a payload the real JsonUtility
    rejects; it used to return an empty list, which the facade treats as
    authoritative and prunes against, so a serializer failure would have removed
    the user's real shortcuts on the next write. The Android bridge's
    SetShortcuts propagates that null as a failed write, and the iOS
    QABuildShortcutsJson returns NULL instead of {"items":[]} when
    NSJSONSerialization fails. A Unity-only test pins the Parse contract
    (the Test Runner suite is 77).
  • The Android SDK-level read can neither throw out of the facade nor pose
    as "API < 25".
    The Build.VERSION JNI read is guarded like every other
    JNI path in the bridge, read once and cached; a read that fails is kept
    distinct from an unsupported device — the bridge's read and write members
    return their failed-read signal (null) for it, so the facade retries instead
    of adopting an empty set and pruning the user's real shortcuts against it.
  • The UISceneWillConnectNotification fallback binds only to Unity's own
    scene delegate.
    It used to bind to the first scene that connected,
    whatever it was, and burn its one-shot doing so; on a host that owns the
    scene manifest — Unity as a Library, a SwiftUI @main app, a second iPad
    window, an external-display or CarPlay scene — the real Unity scene was
    never hooked, and because the package adds
    windowScene:performActionForShortcutItem:completionHandler: to a class
    that lacks it, it then looked terminal for the host's own quick actions:
    adopted into a queue nothing on their side drains, completed YES. The
    fallback now reads the declared class from the connecting session's
    UISceneConfiguration (never a GUL_ / NSKVONotifying_ proxy; set before
    the delegate exists) and binds only to UnityScene or a subclass when this
    process has one. With no UnityScene class — a host-authored manifest on an
    older trampoline — it keeps the first-connecting behaviour but marks the
    owner unconfirmed: there it never adopts an unmarked item and completes
    NO, which is what UIKit would have seen had the selector never been added.
    The configuration-wrapper path is unchanged.
  • The defensive class_addMethod type encoding is built from
    @encode(BOOL)
    rather than the hardcoded armv7-era c (BOOL is bool,
    encoding B, on arm64).