A pull request is checked out at its own head and merged onto main by the job itself: clean,
and the merged result is what gets built; conflicting, and the files and every conflicting hunk
go into the run summary and the comment, and nothing is built. The Gradle log is kept, and a
failed build's compiler errors (paths shortened) and Gradle's own 'What went wrong' are quoted
back. One comment per pull request, rewritten on every push; fork pull requests, whose token is
read-only, get the same text in the run summary.
Every push to the pull request rebuilds it and cancels the build it replaces (the concurrency
group is already per ref, and a pull request's ref is its own); a draft waits until it is
marked ready. The apk comes back as the run's artifact.
A left and a right stick (a base and a knob that follows the finger, clamped) write the pad's
thumb axes the way a physical stick does, and only while they own them, so a physical pad's
sticks are not zeroed by a tap on A. The layout follows where the compositor letterboxes the
picture: on a wide panel showing 16:9 the clusters go in the side bars, on a squarer panel
showing a wide picture they go in the bottom band, and only when neither bar is wide enough do
they overlay the picture as before. The activity hands the picture rectangle over whenever the
surface or the output size changes.
- libpci: an empty file bound over /proc/bus/pci/devices, created at session start, so
Chromium's GPU process stops dying on its way up and CEF stops falling back to SwiftShader
(WinNative deff1ac6 via Bannerlator 8fb668d1: 44 -> 85 fps in the Big Picture library on a
OnePlus 15; not measured here yet).
- Client interface, as toggles on the Performance page and lines in the device report:
mesa_glthread, ZINK_DESCRIPTORS=lazy (now on by default) and MESA_NO_ERROR on; Steam Deck
mode (-steamdeck -steamos3, the script builds the line) off.
- A non-Adreno device is told before the runtime download that a session would be sound over a
black screen, and may still go ahead.
Not carried: Bannerlator's proot fixes live in its proot source, which this repo does not
build (the runtime tarball ships its own); its apk-proot -i guard is moot here (the apk carries
no proot); its session-log head keep is moot (Steam's logs are copied whole).
The drawer Back opens over a session slides in from the right and uses the same rows and
anchored menus as the settings pages: Now (HUD, frame generation, touch, the virtual pad,
keyboard, the client's menu) and Next session (display shape, FEX preset, compatibility tools),
with Send to background and Stop at the end. Steam-only rows show only in a Steam session.
FEXCore presets, Bannerlator's table carried over (core/FexPreset): a Games row in the Steam
settings page and the drawer; the chosen preset's FEX_* variables go into the Steam session's
environment so the games the client launches inherit them. Default = FEX's own defaults, which
is what every session ran on before.
The file manager and the picker stay in landscape like the rest of the app.
The cog's settings window and the Performance dialog become pages in the front end's pane:
one row per setting, its value in a chip, and a small faded menu that opens under the chip
(SettingsWidgets: AnchoredMenu on a Popup with its own position provider, MenuItem, ValueChip,
Choice/Toggle/Multi/Action rows). One menu at a time; the page dims while it is open; the back
key, the rail and the page's Back all leave it. Steam and Desktop each get a Settings entry in
the rail that lights while its page shows, as does Performance under Setup. Frame generation,
Session logs and Start offline open their menu right on their rail row; the frame-generation
dialog is gone.
The manifest now declares the app a game (appCategory, isGame) with a game_mode_config that
welcomes Performance mode and refuses the OS-side FPS cap and resolution downgrade — the
interventions that make a regular flagship's Big Picture crawl while a gaming phone's does not.
The session window asks for sustained performance mode and the panel's fastest mode at its size,
tells GameManager it is in gameplay, and opens a PerformanceHintManager session over the
compositor thread fed with each presented frame's interval against the panel's period. All
version-guarded (6/7/12/13); the session log carries one 'perf:' line saying what took.
The app's own libraries link with 16 KB-aligned LOAD segments (loads unchanged on 4 KB kernels).
Six prebuilt PulseAudio libraries under jniLibs are still 4 KB-only and need a rebuild.
The rail's selection is one pill that springs between rows; sub-lists unfold with
their children staggering in. A page change sinks the old page out and cascades the
new one in row by row over a blurred wash of the selection's own art. Tiles lift,
ring and shine when the pad lands on them and pop a play badge; the launch button
sweeps a sheen on focus and squashes on press. The session activity rises over the
front end and sinks back on finish. Every duration follows the system animator
scale, so 'no animations' in developer options snaps everything.
The activity forwarded mode, program and the Steam extras to the service and dropped
EXTRA_PROGRAM_ARGS, so RPCS3 opened with no game. device.txt names run mode too.
The activity forwarded mode, program and the Steam extras to the service and dropped
EXTRA_PROGRAM_ARGS, so RPCS3 opened with no game. device.txt names run mode too.
The scan goes one folder deeper (a dump comes as a folder named for the game with the image
inside), treats a folder with PS3_GAME as a disc, drops the ".dec" suffix, and lists what RPCS3
has installed on its own HDD (dev_hdd0/game/<ID> with a PARAM.SFO title, ICON0 art and an EBOOT
to boot) - a PSN package installed through RPCS3 is not in the ROMs folder at all.
The emulators' icons are bundled (the runtime keeps them as Papirus SVGs the app cannot draw):
the projects' own from their repositories, PPSSPP's from the runtime, RetroArch's flat icon
from libretro's assets. ROM tiles carry their emulator's icon.
FrontEndScreen replaces the main screen on this branch. Steam's installed games come from the
client's own appmanifests (both libraries, with the library-cache art) and launch straight
into a Steam session with steam://rungameid; the emulators list their games from the ROMs
folder (a system folder as a hint, by extension) and launch under gamescope with the game on
the command line (EXTRA_PROGRAM_ARGS). A session running in the background is the first thing
on the rail and tapping it goes back to it. Landscape: rail beside content; narrow: above.
Every dialog and setting from the main screen is reachable from the rail's lower list.
Handing off from the desktop, the new session claimed the folder the desktop was still
finishing, and the desktop's collector then stopped the new session's app.log capture. The
folder is taken from the shared slot as the session stops and handed to its collector; the
next session's beginOrCurrent finds the slot empty and makes a new folder.
The replaced desktop's proot exits on SIGTERM within a tenth of a second - before the new
session's start thread had numbered itself - so its exit still matched the current number and
ended the new session (4 s on the ended card, then the main menu, with the client audible in
the background). The number is taken in onStartCommand now, ahead of any thread.
Hand-off from the desktop: the new session started, and a second later the old proot - killed
by its own teardown - reported its exit, which the service took as the current session ending
("The session ended 137"). Exits are matched to the session that started the process. The same
race took the new session's log capture and its folder (stopFor / release by folder), and a
finishing activity unhooked the replacement's end listener (compared by identity now).
Hand-off from the desktop to a Steam session: the new activity attached its Surface, then the
old one's surfaceDestroyed detached it - the compositor presented nothing while gamescope sent
frames by the thousand (black screen, sound only). detach() now takes the Surface being destroyed
and ignores one that is not attached. BL_LIBRARY_LABEL was added to the guest list after the
script's mode and reached the Steam client as an argument; it is an environment variable now.
The client already writes one menu entry per installed game (steam steam://rungameid/<id>, with
the game's icon); they were dead for want of a steam command, and r45 added a second entry per
game beside them. Now: steam on the desktop is a shim that hands off to bannerlator-steam-launch
(and is the client itself anywhere else), and bannerlator-desktop-games writes an entry only for
a game the client wrote none for.
bannerlator-desktop-games writes one menu entry per installed game (both libraries, the
client's own artwork) and links Steam Games / SD Games in the home folder. The entries, and the
menu's Steam / Big Picture ones, run bannerlator-steam-launch: the client cannot draw on the
desktop (labwc, no dma-buf), so it leaves a request in the session directory; the service
watches it (FileObserver), ends the desktop session and hands the activity a Steam session to
start - desktop UI (BL_STEAM_UI=desktop drops -gamepadui) with the game's rungameid URL.
The choice belongs inside the client - the drive drop-down on Install, Settings > Storage - so
the app no longer needs a setting for the common case. Default = automatic (the first SD card
present); the cog keeps Internal only and a chosen folder.
The runtime already knew how to register /mnt/bannerlator-sd with the client; the app never
bound anything there, so the client only ever saw internal storage. The Steam cog's Game storage
section offers every removable volume (through the app's own folder on it, the one place a card
lets a targetSdk-28 app write) and any folder from the File Manager, proven writable first. The
session binds the choice and names it (BL_LIBRARY_LABEL); bannerlator-steam-library registers it,
or forgets it when nothing is bound. The client does the rest: asks where to install, shows both
on Storage, moves games between them. device.txt records the choice.
Two field bundles: an S25 running with Turnip sysmem on (it turns tiled rendering off - a
corruption fix, not a speed setting, and the text did not say so), and a Fold 5 ending, again,
in dozens of 'Function not implemented' lines from proot's seccomp acceleration failing Steam's
xalia helper. The ended-session message now reads the log's tail off the main thread and, when
it finds that storch, names 'Run proot without seccomp' / 'Skip xalia' in Performance.
github-actions[bot]