dist-apk: a NativeActivity that runs to completion on both real rows

`tests/apk-consumer/src/main.cpp` now defines `ANativeActivity_onCreate`
under `__ANDROID__`, exported and linked against `libandroid.so`/
`liblog.so` (`[target.'cfg(env = "android")'.runtime] libraries =
["android", "log"]`): it writes the fixture's marker through
`std::puts` (redirected to logcat by `adb-run`'s own
`log.redirect-stdio`) and, unconditionally, through
`__android_log_print`, then calls `ANativeActivity_finish`. `int main`
keeps serving the host row from the same translation unit.

Run end to end (2026-09-12, mcpp PR #624 head, `mcpp run --format apk
--target <triple>`) against two real rows:

  x86_64-linux-android, xim:android-emulator@37.1.11 +
  xim:android-system-image@24-default-x86_64, KVM-accelerated, booted
  through a two-symlink ANDROID_SDK_ROOT (emulator/, platform-tools/ as
  siblings -- the emulator SIGSEGVs otherwise, see the android-emulator
  fix in the index repository): exit 0, logcat carries
  "I apk-consumer: 1-2-3".

  aarch64-linux-android, a physical arm64-v8a phone over adb (a second
  device this session found attached beside the emulator): exit 0,
  same marker, `log.redirect-stdio` itself refused by the device
  ("Failed to set property") -- which is exactly the case
  `__android_log_print` covers. Verified installed with `pm list
  packages`, then uninstalled to leave the phone clean.

Both runs surfaced a real adb-run defect, fixed in the index
repository (xim-pkgindex, pkgs/a/android-platform-tools.lua,
37.0.1-3): `am start -W` never returns for an activity that finishes
from `onCreate` (two independent invocations still alive after 691s
and 354s, killed by hand), and `finish()` ends the activity, not the
process, so a `pidof`-only wait loop never ends either. adb-run now
starts without `-W` and waits for `dumpsys activity activities` to
drop the record in addition to `pidof`, then force-stops the app.

`.github/workflows/ci.yml`'s dist-apk step still asserts packaging
only (build + pack + aapt2/apksigner/jar checks) -- this runner has no
emulator and no device, so a `run` step here could only ever report
"no device/emulator found", never the marker. Said explicitly in the
step's own comment now, rather than left implicit.

Author: Sunrisepeak

.github/workflows/ci.yml

@@ -1094,6 +1094,19 @@ jobs:
       # this step needs the release that carries them (see this repository's
       # README, `dist-apk`'s own row) -- raising the pin is P5's own change,
       # together with the rest of this collection's release.
+      #
+      # THIS STEP ASSERTS PACKAGING ONLY, DELIBERATELY, NOT `mcpp run
+      # --format apk`. This fixture's own `main.cpp` and `mcpp.toml` DO wire
+      # up a real device row (`ANativeActivity_onCreate`, `runner =
+      # ["adb-run"]`) and it was run end to end (2026-09-12) against both a
+      # KVM-accelerated x86_64 emulator (`xim:android-emulator` +
+      # `xim:android-system-image`) and a physical arm64-v8a phone over adb,
+      # both exiting 0 with `1-2-3` in the logcat output -- but this GitHub-
+      # hosted runner has neither an emulator image nor a device attached,
+      # so a `run` step here would only ever report "no device/emulator
+      # found" and never `1-2-3`. That measurement stays a local/self-hosted
+      # concern until a runner class with a real device or a KVM-capable
+      # emulator is wired into this workflow.
       - name: dist-apk produces a signed APK, level 0 and level 1
         working-directory: tests/apk-consumer
         run: |

tests/apk-consumer/mcpp.toml

@@ -25,10 +25,27 @@ plugins = { path = "../..", features = ["dist-apk"], host-module = true }
 kind = "app"
 main = "src/main.cpp"
 
+# `ANativeActivity_onCreate` (src/main.cpp) calls `ANativeActivity_finish`
+# and `__android_log_print`, both declared in `libandroid.so`/`liblog.so` --
+# the NDK's own stable stub libraries for the platform's native-activity and
+# logging ABIs, present in every system image `dist-apk` targets. Neither is
+# pulled in by anything already linked, so the closure needs them stated,
+# not inferred.
+[target.'cfg(env = "android")'.runtime]
+libraries = ["android", "log"]
+
 # #622 A11: `minSdkVersion` reads `mcpp::min_platform_version()`, so the
 # criterion below (`aapt2 dump badging` reporting `sdkVersion:'24'`) is a
 # property of THIS declaration and not of a default this fixture never
 # stated.
 [target.x86_64-linux-android]
 min_api_level = 24
 runner = ["adb-run"]
+
+# Same runner, the emulator's own guest abi. `adb-run` passes no `-s`
+# (device selection is `adb`'s own -- ANDROID_SERIAL is the caller's
+# configuration), so the identical declaration serves both the emulated
+# x86_64 row and a physical arm64-v8a device.
+[target.aarch64-linux-android]
+min_api_level = 24
+runner = ["adb-run"]

tests/apk-consumer/src/main.cpp

@@ -1,23 +1,54 @@
 #include <cstdio>
 #include <string>
 
-// This fixture asserts PACKAGING (and, when the emulator lane runs, a real
-// launch); nothing else here runs on a device by default -- see dist/
-// apk.cppm's header and this fixture's own mcpp.toml for what is measured
-// about the row instead. The engine compiles this file as a translation
-// unit of `lib<name>.so`, exactly as it does for any other member of the
-// shared object -- an `app` target's `main` keeps its ordinary meaning as a
-// compiled entry point; the platform's own entry into the library is
-// `android.app.NativeActivity`, named in the manifest this build's
-// `dist-apk` step generates, and is not this function.
+#if defined(__ANDROID__)
+#include <android/log.h>
+#include <android/native_activity.h>
+#endif
+
+// This fixture asserts PACKAGING, and, on the row `adb-run` serves, a real
+// launch through `mcpp run --format apk` -- see dist/apk.cppm's header and
+// this fixture's own mcpp.toml for what is measured about the row. The
+// engine compiles this file as a translation unit of `lib<name>.so`,
+// exactly as it does for any other member of the shared object -- an
+// `app` target's `main` keeps its ordinary meaning as a compiled entry
+// point for the HOST row, where this program is linked and run directly.
+// On Android, the platform never calls `main`: it loads the library and
+// calls `android.app.NativeActivity`'s own native entry point,
+// `ANativeActivity_onCreate`, named in the manifest `dist-apk` generates.
+// Both are defined here so the one source file works on both rows.
 //
 // `std::to_string` FORCES THE libc++ DEPENDENCY THIS FIXTURE MEASURES.
 // `dist-apk` bundles `libc++_shared.so` only when the closure NEEDs it
-// (`needs_libcxx_shared`, read from the dynamic section); a `main` that
+// (`needs_libcxx_shared`, read from the dynamic section); a program that
 // touched nothing but `<cstdio>` would not exercise that path honestly, so
-// this one builds its marker through `std::string`.
+// this one builds its marker through `std::string`, on both rows.
+namespace {
+std::string marker() {
+    return "1-2-3, count=" + std::to_string(3);
+}
+}  // namespace
+
 int main() {
-    std::string marker = "1-2-3, count=" + std::to_string(3);
-    std::puts(marker.c_str());
+    std::puts(marker().c_str());
     return 0;
 }
+
+#if defined(__ANDROID__)
+// `adb-run` sets `log.redirect-stdio`, so this process's own stdout reaches
+// logcat the same way it would on the host row -- `std::puts` here is not
+// decorative, though a locked-down device can still refuse the property
+// (measured on a real arm64-v8a phone: "Failed to set property
+// 'log.redirect-stdio'"), which is exactly why `__android_log_print` is
+// also called, unconditionally, as the channel that does not depend on it.
+// `ANativeActivity_finish` ends the ACTIVITY; MEASURED 2026-09-12: it does
+// not end the PROCESS (ActivityManager keeps it as a cached, reusable
+// process instead), so `adb-run` itself does not wait on `pidof` alone --
+// it also watches for this activity's own record to disappear from
+// `dumpsys activity activities`, and force-stops the process once it does.
+extern "C" void ANativeActivity_onCreate(ANativeActivity* activity, void*, size_t) {
+    std::puts(marker().c_str());
+    __android_log_print(ANDROID_LOG_INFO, "apk-consumer", "1-2-3");
+    ANativeActivity_finish(activity);
+}
+#endif