@livx.cc/appwrap 0.39.9 → 0.39.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@livx.cc/appwrap",
-  "version": "0.39.9",
+  "version": "0.39.10",
   "description": "Wrap any PWA into a native app with native capabilities (appwrap runtime + @livx.cc/native-kit).",
   "license": "MIT",
   "author": "Elya Livshitz",

package/runtime/App_Resources/Android/src/main/AndroidManifest.xml

@@ -33,7 +33,7 @@
 
 		<activity
 			android:name="com.tns.NativeScriptActivity"
-			android:label="@string/title_activity_kimera"
+			android:label="@string/app_name"
 			android:configChanges="keyboard|keyboardHidden|orientation|screenSize|smallestScreenSize|screenLayout|locale|uiMode"
 			android:theme="@style/LaunchScreenTheme"
 			android:hardwareAccelerated="true"

package/runtime/app/shell/handlers-media.ts

@@ -1,5 +1,11 @@
-import { Utils, isIOS } from '@nativescript/core';
+import { Utils, isIOS, isAndroid } from '@nativescript/core';
 import { bridge } from './bridge';
+import { MUTE_PROBE_WAV_B64 } from './mute-probe-sound';
+
+// AudioToolbox isn't in the bundled iOS typings (AVFoundation is), so declare the few SystemSound
+// symbols we use. They exist at runtime — NativeScript exposes every linked framework global.
+declare const AudioServicesCreateSystemSoundID: (url: NSURL, outId: interop.Reference<number>) => number;
+declare const AudioServicesPlaySystemSoundWithCompletion: (id: number, completion: () => void) => void;
 
 let routeObserverArmed = false;
 
@@ -43,6 +49,153 @@ function observeAudioRouteForSpeaker(): void {
   );
 }
 
+// ── Silent / output-volume detection ────────────────────────────────────────
+// Drives a "will sound actually be heard?" UI signal (e.g. a disabled speaker button). Apple does NOT
+// expose the hardware mute switch, so on iOS we combine TWO signals: the media volume (AVAudioSession
+// .outputVolume) AND the de-facto mute-switch probe — play a ~0.3s SILENT system sound and time its
+// completion; a muted device finishes near-instantly. VOLUME is event-driven (KVO on outputVolume) so
+// it's instant; only the switch is polled (~1s) since it has no event. On Android there's no switch:
+// the media-stream (STREAM_MUSIC) volume is the signal, observed REACTIVELY via a ContentObserver (no
+// polling either platform except the unavoidable iOS switch probe). Emit `media.audioState` on change.
+const AUDIO_POLL_MS = 1000;   // ~1–2s worst-case latency to reflect a switch/volume toggle; the probe sound is silent so a 1s cadence is inaudible (matches the akram/Mute default)
+const MUTE_PROBE_THRESHOLD = 0.1;   // s — a silent clip that completes faster than this means muted output
+
+let audioTimer: ReturnType<typeof setInterval> | null = null;
+let lastSilent: boolean | null = null;
+let lastVolume = -1;
+let muteSoundID = 0;          // iOS SystemSoundID for the silent probe (0 = not yet created)
+// Retain the in-flight completion closure: NativeScript may GC a JS block passed to a C API once the
+// local goes out of scope, so without a strong ref the completion can silently never fire — which is
+// exactly what froze the watcher after the first probe. A module ref keeps it alive until it runs.
+let probeCompletion: (() => void) | null = null;
+let probeStartedAt = 0;
+let switchMuted = false;        // last hardware-mute-switch reading from the probe (iOS only)
+let volObserver: NSObject | null = null;          // iOS KVO observer on AVAudioSession.outputVolume
+// eslint-disable-next-line @typescript-eslint/no-explicit-any -- NSObject.extend is a runtime augmentation, not in the strict iOS typings
+let VolumeObserverClass: any = null;              // registered once (re-extending a name crashes)
+let volContentObserver: android.database.ContentObserver | null = null;   // Android volume observer
+
+function emitAudioState(silent: boolean, volume: number): void {
+  // Round volume so float jitter doesn't spam the bridge; emit only on a real change.
+  const v = Math.round(volume * 100) / 100;
+  if (silent === lastSilent && v === lastVolume) return;
+  lastSilent = silent;
+  lastVolume = v;
+  bridge.emit('media.audioState', { silent, volume: v });
+}
+
+/** Create (once) the iOS SystemSoundID from the embedded silent WAV, written to a temp file. */
+function ensureMuteProbeSound(): boolean {
+  if (muteSoundID) return true;
+  try {
+    const data = NSData.alloc().initWithBase64EncodedStringOptions(MUTE_PROBE_WAV_B64, 0 as NSDataBase64DecodingOptions);
+    if (!data) return false;
+    const path = NSTemporaryDirectory() + 'appwrap-mute-probe.wav';
+    data.writeToFileAtomically(path, true);
+    const ref = new interop.Reference<number>();
+    AudioServicesCreateSystemSoundID(NSURL.fileURLWithPath(path), ref);
+    muteSoundID = ref.value || 0;
+    return !!muteSoundID;
+  } catch (e) {
+    console.warn('[appwrap] mute-probe sound init failed', e);
+    return false;
+  }
+}
+
+/** Combine the (event-driven) volume with the (polled) switch state and emit. iOS. */
+function emitIOS(): void {
+  const volume = AVAudioSession.sharedInstance().outputVolume;
+  emitAudioState(switchMuted || volume <= 0.0001, volume);
+}
+
+/** Probe the hardware mute switch — the ONLY way to read it (Apple exposes no event/API) — then emit. */
+function probeSwitchIOS(): void {
+  if (!ensureMuteProbeSound()) { emitIOS(); return; }
+  if (probeCompletion && Date.now() - probeStartedAt < 1000) return;   // one still pending → skip
+  probeStartedAt = Date.now();
+  const started = probeStartedAt;
+  // Retained in a module var so NativeScript can't GC the block before AudioServices calls it back.
+  probeCompletion = () => {
+    probeCompletion = null;
+    switchMuted = (Date.now() - started) / 1000 < MUTE_PROBE_THRESHOLD;
+    emitIOS();
+  };
+  AudioServicesPlaySystemSoundWithCompletion(muteSoundID, probeCompletion);
+}
+
+/**
+ * iOS: volume is REACTIVE via KVO on AVAudioSession.outputVolume (instant — no polling). The hardware
+ * mute switch has NO OS event (Apple won't expose it), so that one axis is polled via the silent probe.
+ */
+function startAudioIOS(): void {
+  const session = AVAudioSession.sharedInstance();
+  try { session.setActiveError(true); } catch { /* benign — KVO still delivers */ }
+  if (!volObserver) {
+    if (!VolumeObserverClass) {
+      VolumeObserverClass = (NSObject as any).extend(
+        {
+          observeValueForKeyPathOfObjectChangeContext(keyPath: string) {
+            if (keyPath === 'outputVolume') emitIOS();   // hardware volume changed → emit immediately
+          },
+        },
+        { name: 'AppwrapAudioVolumeObserver' }
+      );
+    }
+    volObserver = VolumeObserverClass.alloc().init();
+    session.addObserverForKeyPathOptionsContext(volObserver, 'outputVolume', NSKeyValueObservingOptions.New, null);
+  }
+  probeSwitchIOS();                                     // initial switch read + emit
+  audioTimer = setInterval(probeSwitchIOS, AUDIO_POLL_MS);
+}
+
+function stopAudioIOS(): void {
+  if (audioTimer) { clearInterval(audioTimer); audioTimer = null; }
+  if (volObserver) {
+    try { AVAudioSession.sharedInstance().removeObserverForKeyPath(volObserver, 'outputVolume'); } catch { /* already gone */ }
+    volObserver = null;
+  }
+}
+
+/** Android: read the media-stream (STREAM_MUSIC) volume — 0 = silent — and emit. */
+function readAudioAndroid(): void {
+  try {
+    const ctx = Utils.android.getApplicationContext();
+    const am = ctx.getSystemService(android.content.Context.AUDIO_SERVICE) as android.media.AudioManager;
+    const max = am.getStreamMaxVolume(android.media.AudioManager.STREAM_MUSIC) || 1;
+    const cur = am.getStreamVolume(android.media.AudioManager.STREAM_MUSIC);
+    emitAudioState(cur === 0, cur / max);
+  } catch (e) {
+    console.warn('[appwrap] android audio read failed', e);
+  }
+}
+
+/** Android: REACTIVE — a ContentObserver on system settings fires on every volume change (no polling). */
+function startAudioAndroid(): void {
+  try {
+    const ctx = Utils.android.getApplicationContext();
+    const handler = new android.os.Handler(android.os.Looper.getMainLooper());
+    // extend lazily — the android.* globals only exist on the Android load path
+    const ObserverClass = (android.database.ContentObserver as any).extend({
+      onChange(_selfChange: boolean) { readAudioAndroid(); },
+    });
+    volContentObserver = new ObserverClass(handler);
+    ctx.getContentResolver().registerContentObserver(
+      android.provider.Settings.System.CONTENT_URI, true, volContentObserver
+    );
+  } catch (e) {
+    console.warn('[appwrap] android volume observer failed', e);
+  }
+  readAudioAndroid();   // initial state
+}
+
+function stopAudioAndroid(): void {
+  if (volContentObserver) {
+    try { Utils.android.getApplicationContext().getContentResolver().unregisterContentObserver(volContentObserver); }
+    catch { /* already gone */ }
+    volContentObserver = null;
+  }
+}
+
 /**
  * Live-media session config. getUserMedia / playback themselves are pure WebView
  * APIs (unlocked by the UIDelegate / onPermissionRequest grants in the custom
@@ -117,4 +270,21 @@ export function registerMediaHandlers(): void {
     session.setCategoryModeOptionsError(category, avMode, options as AVAudioSessionCategoryOptions);
     session.setActiveError(true);
   });
+
+  // Start streaming `media.audioState` { silent, volume } events. iOS: volume is event-driven (KVO),
+  // the switch is polled (no OS event). Android: media-stream volume polled. Idempotent; emits the
+  // current state immediately so the page doesn't wait for the first change.
+  bridge.register('media.audioWatch.start', () => {
+    if (audioTimer || volObserver || volContentObserver) return;
+    lastSilent = null; lastVolume = -1;   // force the first emit
+    if (isIOS) startAudioIOS();
+    else if (isAndroid) startAudioAndroid();
+    // unsupported platform → no events (page treats absence as "audible")
+  });
+
+  bridge.register('media.audioWatch.stop', () => {
+    if (isIOS) stopAudioIOS();
+    else if (isAndroid) stopAudioAndroid();
+    lastSilent = null; lastVolume = -1;
+  });
 }

package/runtime/app/shell/mute-probe-sound.ts

@@ -0,0 +1,6 @@
+// AUTO-GENERATED. A ~0.3s mono 8kHz 16-bit SILENT WAV, base64-encoded. Used by the iOS hardware
+// mute-switch detector in handlers-media.ts: we play this as a System Sound and time its completion —
+// a muted device finishes near-instantly (<~0.1s), an audible one takes the full clip length. Kept as
+// a code constant (no asset-bundling step) and written to a temp file at runtime for AudioServices.
+export const MUTE_PROBE_WAV_B64 =
+  'UklGRuQSAABXQVZFZm10IBAAAAABAAEAQB8AAIA+AAACABAAZGF0YcASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=';

package/src/cli.ts

@@ -741,12 +741,17 @@ function stampFcmService(outDir: string, on: boolean): void {
 }
 
 function stampAndroidAppName(outDir: string, cfg: AppwrapConfig, req: NativeReqs): void {
-  const strings = join(outDir, 'App_Resources/Android/src/main/res/values/strings.xml');
-  if (existsSync(strings)) {
-    let src = readFileSync(strings, 'utf8');
-    src = src.replace(/(<string name="app_name">)[^<]*(<\/string>)/, `$1${cfg.name}$2`);
-    writeFileSync(strings, src);
-  }
+  // Write res/values/strings.xml defining app_name = cfg.name. The NS template ships NO strings.xml
+  // (the default app_name/activity title resolve to "native" from @nativescript/core), so a regex
+  // replace was a no-op and the launcher showed "native". Write the file so app_name is authoritative
+  // (the manifest's <application> AND launcher <activity> both label off @string/app_name). XML-escape.
+  const esc = (s: string) => s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+  const stringsDir = join(outDir, 'App_Resources/Android/src/main/res/values');
+  mkdirSync(stringsDir, { recursive: true });
+  writeFileSync(
+    join(stringsDir, 'strings.xml'),
+    `<?xml version="1.0" encoding="utf-8"?>\n<resources>\n    <string name="app_name">${esc(cfg.name)}</string>\n    <string name="title_activity_kimera">${esc(cfg.name)}</string>\n</resources>\n`
+  );
   const manifest = join(outDir, 'App_Resources/Android/src/main/AndroidManifest.xml');
   if (existsSync(manifest)) {
     let src = readFileSync(manifest, 'utf8');
@@ -822,29 +827,53 @@ function findMaskableSource(cwd: string, cfg: AppwrapConfig): string | null {
   return findIconSource(cwd, cfg);
 }
 
-/** Generate iOS appiconset + Android mipmaps from the PWA's icon via sips (macOS). */
+/** Square-resize/probe abstraction over `sips` (macOS) or ImageMagick (`magick` v7 / `convert` v6),
+ * so icon generation works on Linux/CI too — not just macOS. Returns null if neither tool is present. */
+function imageRasterizer(): { width: (src: string) => number; resize: (src: string, px: number, dest: string) => void } | null {
+  const has = (cmd: string) => {
+    try { execFileSync('which', [cmd], { stdio: 'ignore' }); return true; } catch { return false; }
+  };
+  if (has('sips')) {
+    return {
+      width: (src) => parseInt(execFileSync('sips', ['-g', 'pixelWidth', src]).toString().match(/(\d+)\s*$/)?.[1] ?? '0', 10),
+      resize: (src, px, dest) => execFileSync('sips', ['-z', String(px), String(px), src, '--out', dest], { stdio: 'ignore' }),
+    };
+  }
+  const magick = has('magick') ? 'magick' : has('convert') ? 'convert' : null;
+  if (magick) {
+    // v7: `magick identify` / `magick <src> -resize`. v6: `identify` / `convert <src> -resize`. `!` forces exact (square) dims.
+    return {
+      width: (src) => {
+        const args = magick === 'magick' ? ['identify', '-format', '%w', src] : ['-format', '%w', src];
+        const bin = magick === 'magick' ? 'magick' : 'identify';
+        return parseInt(execFileSync(bin, args).toString().trim() || '0', 10);
+      },
+      resize: (src, px, dest) => execFileSync(magick, [src, '-resize', `${px}x${px}!`, dest], { stdio: 'ignore' }),
+    };
+  }
+  return null;
+}
+
+/** Generate iOS appiconset + Android mipmaps from the PWA's icon (via sips on macOS or ImageMagick on CI). */
 function generateIcons(cwd: string, outDir: string, cfg: AppwrapConfig): void {
   const source = findIconSource(cwd, cfg);
   if (!source) {
     console.warn('⚠ No app icon source found (manifest icons or config `icon`) — keeping template icons');
     return;
   }
-  // Icon rasterization uses `sips`, which is macOS-only. On Linux/CI (e.g. a GitHub Actions Android
-  // build) it's absent — skip gracefully and keep the template icons rather than throwing and failing
-  // the whole init/build. Regenerate real icons on macOS for store builds.
-  try {
-    execFileSync('which', ['sips'], { stdio: 'ignore' });
-  } catch {
-    console.warn('⚠ `sips` unavailable (non-macOS host) — keeping template icons; regenerate on macOS for store builds');
+  // Pick an image rasterizer: `sips` (macOS) OR ImageMagick (`magick` v7 / `convert` v6) so icons are
+  // generated on Linux/CI too (GitHub ubuntu runners ship ImageMagick) — NOT just macOS. Previously CI
+  // skipped icon gen entirely → the default NativeScript "N" icon shipped. If NEITHER tool exists, keep
+  // the template icons rather than failing the build.
+  const ras = imageRasterizer();
+  if (!ras) {
+    console.warn('⚠ no image tool (sips / ImageMagick) — keeping template icons; install ImageMagick or build on macOS');
     return;
   }
-  const probe = (prop: string) =>
-    parseInt(execFileSync('sips', ['-g', prop, source]).toString().match(/(\d+)\s*$/)?.[1] ?? '0', 10);
-  const w = probe('pixelWidth');
-  if (w < 512) console.warn(`⚠ Icon source is ${w}px — below the 512px App Store minimum (using it anyway)`);
+  const w = ras.width(source);
+  if (w && w < 512) console.warn(`⚠ Icon source is ${w}px — below the 512px App Store minimum (using it anyway)`);
 
-  const resize = (px: number, dest: string) =>
-    execFileSync('sips', ['-z', String(px), String(px), source, '--out', dest], { stdio: 'ignore' });
+  const resize = (px: number, dest: string) => ras.resize(source, px, dest);
 
   const iconset = join(outDir, 'App_Resources/iOS/Assets.xcassets/AppIcon.appiconset');
   if (existsSync(iconset)) {
@@ -870,8 +899,7 @@ function generateIcons(cwd: string, outDir: string, cfg: AppwrapConfig): void {
   const ADAPTIVE_DP = 108;
   const adaptiveXml = join(res, 'mipmap-anydpi-v26/ic_launcher.xml');
   if (fgSource && existsSync(adaptiveXml)) {
-    const resizeFrom = (src: string, px: number, dest: string) =>
-      execFileSync('sips', ['-z', String(px), String(px), src, '--out', dest], { stdio: 'ignore' });
+    const resizeFrom = (src: string, px: number, dest: string) => ras.resize(src, px, dest);
     for (const [density, baseline] of Object.entries(ANDROID_DENSITIES)) {
       const dir = join(res, `mipmap-${density}`);
       if (!existsSync(dir)) continue;
@@ -1711,13 +1739,19 @@ function pickDevice(devices: DeviceInfo[], explicitId?: string): DeviceInfo {
   return devices[idx];
 }
 
-/** `appwrap deploy ios [--device <id|name>] [--no-launch]` — build for device, auto-pick the
- * connected phone (USB or network; prompts if several), install + launch. Debug build (no
- * distribution signing) — for testing on your own device. Run the PWA build first (or via the script). */
+/** `appwrap deploy <ios|android> [--device <id|name>] [--no-launch]` — build for a device, auto-pick
+ * the connected phone (USB or network; prompts if several), install + launch. Debug build (no
+ * distribution signing) — for testing on your own device. Run the PWA build first (or via the script).
+ * iOS has a bespoke Debug-IPA path (below); Android delegates to `run` (NativeScript builds + installs
+ * + launches), so the `deploy <platform>` surface is symmetric across both. */
 async function deploy(cwd: string, flags: Record<string, string>, positionals: string[]): Promise<void> {
   const platform = positionals[0];
+  if (platform === 'android') {
+    // Aligned surface: `deploy android` == `run android` (Android's run already does build+install+launch).
+    return run(cwd, flags, positionals);
+  }
   if (platform !== 'ios') {
-    console.error('Usage: appwrap deploy ios [--device <id|name>] [--no-launch]  (android: use `appwrap run android`)');
+    console.error('Usage: appwrap deploy <ios|android> [--device <id|name>] [--no-launch]');
     process.exit(1);
   }
   const cfg = await loadConfig(cwd, flags);
@@ -1998,7 +2032,7 @@ async function main(): Promise<void> {
       console.log('Usage: appwrap <init|sync|dev|run|build|deploy|release|submit|logs> [--config <path>] [--out native]\n' +
         '  config: appwrap.config.ts (preferred) → .js → appwrap.json\n' +
         '  run <ios|android> [--device <id|name>]    (compile + boot in a simulator/emulator, live reload)\n' +
-        '  build <ios|android> [--release] [--aab]   deploy ios [--device <id|name>] [--no-launch]\n' +
+        '  build <ios|android> [--release] [--aab]   deploy <ios|android> [--device <id|name>] [--no-launch]\n' +
         '  release ios [--server-url <url>] [--env <name>] [--build-number <n>]  (build+sign+upload to TestFlight)\n' +
         '  submit ios [--build-number <n>] [--submit-for-review]  (promote the binary to the App Store; metadata stays in ASC)\n' +
         '  logs ios [--once] [--native]   dev [--url <url> | --port <p>]');