admin
cacf871ddd
ltk only ran on a Wayland compositor: the runtime, the input handlers and the draw paths named smithay-client-toolkit's types throughout, so no other windowing system could be added without touching all of them. Prompt, the Eydos terminal, has to run on an Android phone, with its sessions and its sharing, and needs a toolkit that runs there. The platform layer. Input reaches the runtime as platform-neutral events: `input/event.rs` defines `KeyInput`, `PointerInput` and `TouchInput`, and the pointer, touch and keyboard handlers take them through a few entry points (`pointer_input`, `touch_input`, `key_press`, `key_release`, `key_repeated`, `modifiers_changed`, `keyboard_enter`, `keyboard_leave`, `set_repeat_info`). The sctk handler implementations moved to `platform/wayland/input.rs`, which records the serials later requests need, resolves surfaces and translates. What the runtime asks of the windowing system (moving, resizing, minimising and fullscreening the window, a bare frame request, the cursor's shape, the input method, publishing the clipboard and the primary selection, preparing a canvas, presenting it and its damage) forms the `platform::Platform` trait, with its surface type as `Platform::Surface`. The protocol state moved from `AppData` into `platform::wayland::WaylandPlatform`, held as `AppData::platform`, and each surface's Wayland half (its kind, SHM pool, EGL window surface and what the compositor was last told) from `SurfaceState` into `WaylandSurfaceState`, held as `SurfaceState::platform`. The compositor, shell, seat and output handlers, the data device, the primary selection, the run loop, overlay and subsurface reconciliation, session management, output probing and window fitting moved from `event_loop/` to `platform/wayland/`. Drawing is split from presenting: `draw/paint.rs` paints a surface in full or under its dirty rects, the same for the software and GPU canvases, in place of the four near-identical paths of `draw/software.rs` and `draw/gles.rs`, and the backend presents it (`platform/wayland/present.rs`, which also took the opaque and input regions and `pick_shm_format`). The runtime is generic over the platform, `AppData<A, P: Platform = NativePlatform<A>>` and `SurfaceState<Msg, S = NativeSurface>`, resolved at compile time. The backend-neutral half of a loop iteration is `event_loop/step.rs` (`process_messages`, `draw_due`, `next_wakeup`, `before_draw`, `after_draw`), and `event_loop/setup.rs` builds the state and the event sources every backend has; the accessibility tree and its actions moved to `event_loop/a11y.rs`. `platform/mock.rs` is a platform that logs what is asked of it, and `event_loop/tests.rs` drives the runtime on it through input, update, painting and presentation. The behaviour on Wayland is unchanged, except that a frame whose presentation fails leaves the next one to repaint in full. `ltk::Keysym` now comes from `xkeysym`, the crate sctk re-exported it from, so it is the same type. Features. `wayland`, on by default, brings the Wayland backend and its dependencies, now optional, AT-SPI2 accessibility among them. `android` brings android-activity 0.6, ndk 0.9 and jni 0.21. A new `build.rs` refuses both at once and sets `cfg( backend )` when one is on, which builds the runtime behind `run` and `try_run`. Without a backend only the runtime-free core builds: `UiSurface`, widgets, layout, theming and rendering. The Android backend. `ltk::run` runs inside a NativeActivity once `android_main` has handed its `AndroidApp`, re-exported as `ltk::AndroidApp`, to the new `ltk::set_android_app`; without it `run` fails with `RunError::NoAndroidApp`. The first call in the process sends standard output and error, panics included, to logcat, sets `HOME` to the app's internal storage and, unless set, `SSL_CERT_DIR` to Android's CA certificates and `LANG` to the device's language, and unpacks the bundled resources; every call keeps the latest activity, since Android starts the next one in the same process. The backend draws through EGL on the activity's window, or in software into a locked window buffer, and sizes the main surface at the display's density in whole multiples of 160 dpi. Fingers and styluses become touches, a mouse the pointer, and key events keysyms and text through the device's character map. calloop's descriptor rides on the activity's `ALooper`, so the app's channel and timers keep working. Text is typed on ltk's own keyboard, since a NativeActivity gets only key events from the system's. Through JNI on the activity (`platform/android/java.rs`): copies go to `ClipboardManager` and its text is read back whenever the app gains the focus; back with nothing left to go back to minimises the app with `moveTaskToBack` or closes it, as `App::back_at_root` says, which the new `Platform::back_leaves` decides per backend; and the window's insets come from `getRootWindowInsets()` on Android 11 and later, the status bar and any cutout on top and only bars that take taps on the other edges, so there is no gap above the view nor below it in gesture navigation, and a bar of buttons still keeps its room; earlier releases fall back to the content rect. When the app's last surface closes, ltk calls `finishAndRemoveTask` and waits for the activity to be destroyed, since a second activity started in a process whose `android_main` has returned never came up; an app should end the process after `run` returns. `ltk::keep_running( Some( text ) )` starts a foreground service with `text` on an ongoing notification, so Android does not freeze the app once it leaves the screen, and `None` stops it. Surface insets. `SurfaceState::insets` holds the logical pixels the system covers along each edge; the view is laid out inside them while the background fills the whole surface, and positions stay absolute, so hit testing is unchanged. The built-in keyboard is placed inside them too, above a bar of navigation buttons. On Wayland they stay zero. Resources in a package. `ltk::set_resource_dir( dir )` names an app's own copy of ltk's resources and `ltk::resource_dir()` returns it, so an app also finds its own bundled files there. Its `themes/` is searched after the user's themes and before `/usr/share/ltk/themes`, its `keyboards/` before `/usr/share`, and a font a theme names by an absolute path that does not exist is read from its `fonts/` by file name, so a theme written against Debian's paths works unchanged. On Android `set_android_app` unpacks `assets/ltk/` into the internal storage and uses it as the resource directory; `assets/ltk/MANIFEST` lists the tree, since the asset manager cannot list subdirectories, and its first line, a hash of the contents, decides whether to unpack again. On Android the per-script fallback fonts come from `/system/fonts` and the primary face is the embedded Sora. APKs. `scripts/android-assets.sh` builds that tree from installed themes, without their cursors, with the fonts each `theme.json` names and ltk's keyboard layouts. `scripts/android-apk.sh OUT.apk LIB.so PACKAGE LABEL [ASSETS_DIR]` packages an app built as a `cdylib` with Debian's aapt, zipalign and apksigner, with no Gradle and no SDK download: it writes the manifest, with the library loaded as `libmain.so`, optional permissions and a theme without an action bar, which the content rect would otherwise leave room for; links it against `android-framework-res`; adds the assets and the library; aligns and signs, creating a debug keystore when there is none. `ICON` takes an SVG, rasterised with `rsvg-convert` for every density, or a PNG. `KEEP_ALIVE=1` compiles `java/net/liberux/ltk/KeepAlive.java` with javac and `dx` from art-standalone against the platform 34 `android.jar`, against which aapt then links too, since Debian's framework-res predates the `specialUse` service type, and declares the service with `KEEP_ALIVE_USE` as its reason and the permissions it needs. `examples/android_hello.rs` is the smoke test: `make android-check` typechecks the backend with Debian's rustc, `rust-src` and NDK through `-Zbuild-std`, `make android-apk` and `make android-install` package and install the example, `make deps` and `make android-deps` install what the targets need, and `make install` now copies `examples`, `scripts`, `java` and `build.rs` into the registry. The built-in keyboard for an app's own text input. While `App::external_text_input` asks for text and no ltk text field has the focus, the built-in keyboard shows with `App::external_text_purpose`, so a terminal gets its row of Escape, Tab, Ctrl, Alt and arrows, comes back when the serial changes and hides when the request ends. Its keys reach the app as physical ones, pressed and released through `App::on_raw_key_event` with the panel's Ctrl and Alt held for them. Before, it only served ltk's text fields, so such an app had no keyboard where the compositor offers no input method. Clippy. `make clippy` is clean again: derived `Default`s replace the hand-written ones, `div_ceil`, `then_some`, struct update syntax for strokes, the map entry API in the text renderer, function paths in place of closures in the examples and tests, and fewer casts and explicit lifetimes. `README.md`, `docs/architecture.md` and `CHANGELOG.md` describe the features, the backend, the events and their units, and what stays with a backend. Not done. On Android there are no overlays, secondary surfaces or subsurfaces, no dead keys from a physical keyboard and no saved state for the activity. Why a second activity in the same process never comes up was not found. The keep-alive service does not ask for the notification permission, so on Android 13 and later its notification may not show until it is granted in the app's settings.
119 lines
5.2 KiB
Makefile
119 lines
5.2 KiB
Makefile
REGISTRY ?= /usr/share/cargo/registry/ltk
|
|
DOCDIR ?= /usr/share/doc/libltk-doc/html
|
|
|
|
# The Android build uses Debian's own packages: rustc and rust-src of the
|
|
# same version, whose std `-Zbuild-std` compiles for the target, and the NDK
|
|
# that google-android-ndk-r27c-installer (non-free) unpacks.
|
|
NDK ?= /usr/lib/android-sdk/ndk/27.2.12479018
|
|
ANDROID_API ?= 26
|
|
ANDROID_TARGET ?= aarch64-linux-android
|
|
NDK_BIN = $(NDK)/toolchains/llvm/prebuilt/linux-x86_64/bin
|
|
NDK_CC = $(NDK_BIN)/$(ANDROID_TARGET)$(ANDROID_API)-clang
|
|
ANDROID_ENV = RUSTC_BOOTSTRAP=1 \
|
|
CC_$(subst -,_,$(ANDROID_TARGET))=$(NDK_CC) \
|
|
CXX_$(subst -,_,$(ANDROID_TARGET))=$(NDK_CC)++ \
|
|
AR_$(subst -,_,$(ANDROID_TARGET))=$(NDK_BIN)/llvm-ar \
|
|
CARGO_TARGET_$(shell echo $(ANDROID_TARGET) | tr a-z- A-Z_)_LINKER=$(NDK_CC)
|
|
ANDROID_CARGO = -Zbuild-std=std,panic_abort --target $(ANDROID_TARGET) --no-default-features --features android
|
|
# Where `android-assets` writes the `ltk/` tree an APK carries under `assets/`.
|
|
ANDROID_ASSETS ?= target/android/assets
|
|
# The example APK, packaged with aapt, zipalign, apksigner and
|
|
# android-framework-res, and installed with adb (android-sdk-platform-tools).
|
|
ANDROID_ABI ?= arm64-v8a
|
|
ANDROID_APK ?= target/android/ltk-hello.apk
|
|
|
|
# Targets are recipes, not files. Listing them as PHONY tells make to
|
|
# ignore filesystem entries with the same name — without this `examples`
|
|
# silently no-ops because the `examples/` directory exists, and `doc`
|
|
# would do the same once `target/doc` is around.
|
|
.PHONY: all deps android-deps test doctest-md stylecheck clippy audit doc install examples clean distclean android-check android-assets android-apk android-install
|
|
|
|
all:
|
|
cargo build --release
|
|
|
|
# What building, testing and linting need, from Debian.
|
|
deps:
|
|
sudo apt-get install -y cargo rustc rust-clippy pkg-config libwayland-dev libegl-dev libxkbcommon-dev
|
|
|
|
# What the android-* targets need, from Debian: std's sources for -Zbuild-std,
|
|
# the NDK installer (non-free), the APK tools, rsvg-convert for SVG icons, javac, dx and
|
|
# android.jar (non-free) for the keep-alive service, and adb.
|
|
android-deps:
|
|
sudo apt-get install -y rust-src google-android-ndk-r27c-installer aapt zipalign apksigner android-framework-res librsvg2-bin default-jdk-headless art-standalone google-android-platform-34-installer android-sdk-platform-tools
|
|
|
|
test:
|
|
cargo test --features test-support
|
|
|
|
# Typecheck the `no_run` snippets in docs/*.md by feeding each markdown
|
|
# file to `rustdoc --test`. Catches API drift in cookbook + widget
|
|
# reference: drops a renamed builder, removed function, etc. surface
|
|
# here just like `cargo test --doc` does for in-source doctests.
|
|
doctest-md:
|
|
./scripts/doctest-md.sh
|
|
|
|
# Mechanical style checks (tabs, attribute-bracket spacing) — the
|
|
# grep-verifiable subset of code_style_guide.md.
|
|
stylecheck:
|
|
./scripts/style-check.sh
|
|
|
|
# Semantic lints, mirroring the CI invocation. Warnings are errors so a
|
|
# local run predicts the CI verdict.
|
|
clippy:
|
|
cargo clippy --workspace --all-targets --features test-support -- -D warnings
|
|
|
|
# Typecheck the Android backend. Needs rust-src and the NDK (see NDK above).
|
|
android-check:
|
|
@test -x $(NDK_CC) || { echo "No NDK compiler at $(NDK_CC); install google-android-ndk-r27c-installer or set NDK="; exit 1; }
|
|
$(ANDROID_ENV) cargo check $(ANDROID_CARGO)
|
|
|
|
# The in-tree default theme and the fonts it names, as an APK carries them.
|
|
android-assets:
|
|
./scripts/android-assets.sh $(ANDROID_ASSETS) themes default
|
|
|
|
# examples/android_hello.rs as an APK, with the in-tree default theme.
|
|
android-apk: android-assets
|
|
@test -x $(NDK_CC) || { echo "No NDK compiler at $(NDK_CC); install google-android-ndk-r27c-installer or set NDK="; exit 1; }
|
|
$(ANDROID_ENV) cargo build --release --example android_hello $(ANDROID_CARGO)
|
|
ANDROID_ABI=$(ANDROID_ABI) MIN_SDK=$(ANDROID_API) ./scripts/android-apk.sh $(ANDROID_APK) \
|
|
target/$(ANDROID_TARGET)/release/examples/libandroid_hello.so net.liberux.ltk.Hello "ltk hello" $(ANDROID_ASSETS)
|
|
|
|
android-install: android-apk
|
|
adb install -r $(ANDROID_APK)
|
|
|
|
audit:
|
|
@command -v cargo-audit >/dev/null 2>&1 || cargo install cargo-audit --locked
|
|
cargo audit
|
|
|
|
doc:
|
|
cargo doc --no-deps
|
|
|
|
install: doc
|
|
install -d $(REGISTRY)
|
|
cp -r src benches examples locales protocols keyboards scripts java build.rs Cargo.toml liberux.toml $(REGISTRY)/
|
|
cp debian/cargo-checksum.json $(REGISTRY)/.cargo-checksum.json
|
|
install -d $(DOCDIR)
|
|
cp -r target/doc/* $(DOCDIR)/
|
|
|
|
examples:
|
|
LTK_THEMES_DIR=themes cargo run --release --example showcase
|
|
LTK_THEMES_DIR=themes cargo run --release --example responsive
|
|
LTK_THEMES_DIR=themes cargo run --release --example inputs
|
|
LTK_THEMES_DIR=themes cargo run --release --example scroll
|
|
LTK_THEMES_DIR=themes cargo run --release --example sliders
|
|
LTK_THEMES_DIR=themes cargo run --release --example combo
|
|
LTK_THEMES_DIR=themes cargo run --release --example mini_shell
|
|
LTK_THEMES_DIR=themes cargo run --release --example widgets
|
|
LTK_THEMES_DIR=themes cargo run --release --example pickers
|
|
LTK_THEMES_DIR=themes cargo run --release --example dialog
|
|
LTK_THEMES_DIR=themes cargo run --release --example carousel
|
|
LTK_THEMES_DIR=themes cargo run --release --example clip_path
|
|
LTK_THEMES_DIR=themes cargo run --release --example tab_strip
|
|
|
|
clean:
|
|
dh_clean
|
|
cargo clean
|
|
rm -rf target
|
|
|
|
distclean: clean
|
|
rm -f Cargo.lock
|