@livx.cc/appwrap 0.51.2 → 0.52.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@livx.cc/appwrap",
-  "version": "0.51.2",
+  "version": "0.52.0",
   "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/main-page.ts

@@ -17,6 +17,7 @@ import './shell/fcm-bootstrap.generated'; // side-effect: registers the FCM serv
 import { startEventForwarding } from './shell/events';
 import { startDevMenu } from './shell/devmenu';
 import { showEnvBannerIfActive } from './shell/env-banner';
+import { reassertEnvKeepAwake } from './shell/env-keepawake';
 import { SHELL_CONFIG } from './shell/config';
 import { bindStatusBarPage, setStatusBarStyle, applyThemeColor, enableAndroidEdgeToEdge, wireAndroidSafeArea } from './shell/status-bar';
 import { CustomWebView } from './shell/custom-webview';
@@ -95,12 +96,6 @@ export function onPageLoaded(args: EventData): void {
   if (initialized) return;
   initialized = true;
 
-  // Debug mode: keep the screen awake (no auto-lock while foreground) so the dev/inspect session
-  // and the iterate loop stay alive. iOS via the idle timer; Android via WebView keepScreenOn.
-  if (isIOS && SHELL_CONFIG.debug) {
-    try { UIApplication.sharedApplication.idleTimerDisabled = true; } catch (e) { /* no-op */ }
-  }
-
   registerHandlers();
   registerExtendedHandlers();
   registerParityHandlers();
@@ -138,6 +133,9 @@ export function onPageLoaded(args: EventData): void {
   // Env indicator banner: shown in the bottom safe area on relaunch when a non-default env override is
   // active (env-switcher only). Bottom-safe-area, auto-shrinks to a pill after 3s. No-op otherwise.
   showEnvBannerIfActive();
+  // Keep the screen awake while pointed at a NON-DEFAULT backend (or in a debug build) — same signal as the
+  // banner above, so "banner showing" ⟺ "no auto-lock". Subsumes the old iOS-only debug idle-timer block.
+  reassertEnvKeepAwake();
 
   // Halt the WebView render + JS-timer pipeline while backgrounded so a page running a continuous
   // animation (Android doesn't auto-pause rAF off-screen) stops burning CPU/battery. No-op on iOS.
@@ -147,6 +145,10 @@ export function onPageLoaded(args: EventData): void {
     // iOS: wake the WebContent renderer NOW (it stays THROTTLED for ~30-45s after a full-window system
     // surface — StoreKit manage-subscriptions sheet, itms-apps deep link, backgrounding — froze it).
     webView.wakeWebContent();
+    // Neither platform guarantees the wake lock survives a background trip (Android drops the window flag
+    // outright if the Activity was recreated). Assert-only: never write `false`, so an app driving the
+    // public `ui.keepAwake` bridge API itself (e.g. during video) isn't clobbered on resume.
+    reassertEnvKeepAwake();
   });
 
   // DEBUG: trace the iOS app-lifecycle event sequence to the pullable log sink so we can see WHICH

package/runtime/app/shell/custom-webview.android.ts

@@ -420,6 +420,40 @@ function createAssetServingClient(): android.webkit.WebViewClient {
       view.evaluateJavascript(buildBootstrapJs(), null as unknown as android.webkit.ValueCallback<string>);
   };
 
+  // Main-frame load FAILURE → NativeScript's `loadFinished` event (its `error` arg). We replace NS's own
+  // WebViewClientImpl wholesale (see initNativeView), and NS only raises that event from ITS client — so
+  // without this forward the event NEVER fires on Android and a failed load (server down, DNS, refused)
+  // is invisible to JS. iOS keeps the event because DevCertNavDelegate forwards didFail*Navigation to
+  // NS's delegate; this restores the SAME seam here rather than adding a parallel Android-only one
+  // (consumer: env-switcher's reloadToEffective).
+  // MAIN FRAME ONLY: API 23+ also reports sub-resource failures here, and a dead favicon/image must not
+  // be mistaken for "the page didn't load". minSdk is 26, so only this modern overload is ever dispatched
+  // (the legacy string-arg overload is API < 23).
+  const receivedError = (
+    view: android.webkit.WebView,
+    request: android.webkit.WebResourceRequest,
+    error: android.webkit.WebResourceError
+  ): void => {
+      if (!request?.isForMainFrame?.()) return;
+      // `_onLoadFinished` is NS's internal event-raiser (the `_` API index.android.js itself calls) — not
+      // in the public typings, hence the cast.
+      (CustomWebView.forNative(view) as any)?._onLoadFinished(
+        String(request.getUrl?.() ?? ''),
+        `${error?.getDescription?.() ?? 'Load failed'} (${error?.getErrorCode?.() ?? '?'})`
+      );
+  };
+
+  // Main-frame load SUCCESS → NativeScript's `loadFinished` event with NO `error` arg. The counterpart of
+  // `receivedError` above, and NOT optional: NS raises this from ITS WebViewClientImpl.onPageFinished,
+  // which we replace wholesale — so forwarding only the FAILURE half would leave `loadFinished` never
+  // firing on a SUCCESSFUL load. A one-shot `loadFinished` listener (env-switcher's reloadToEffective)
+  // would then never unhook on success and would leak onto the NEXT navigation, blaming a later error on
+  // an earlier switch (and naming the earlier switch's host). Both halves or neither.
+  const pageFinished = (view: android.webkit.WebView, url: string): void => {
+      // Mirrors NS's own `owner._onLoadFinished(url, undefined)` — absent `error` is what marks success.
+      (CustomWebView.forNative(view) as any)?._onLoadFinished(String(url ?? ''));
+  };
+
   // DEBUG-ONLY dev-server cert trust (Android parity with the iOS WKNavigationDelegate). `appwrap dev`
   // points at a LAN dev server that almost always uses a self-signed / mkcert TLS cert the device's
   // trust store doesn't know — the WebView would otherwise hard-fail with ERR_CERT_AUTHORITY_INVALID.
@@ -468,9 +502,15 @@ function createAssetServingClient(): android.webkit.WebViewClient {
       onPageStarted(view: android.webkit.WebView, _url: string, _favicon: android.graphics.Bitmap): void {
         pageStarted(view);
       },
+      onPageFinished(view: android.webkit.WebView, url: string): void {
+        pageFinished(view, url);
+      },
       onReceivedSslError(_view: android.webkit.WebView, handler: android.webkit.SslErrorHandler, error: android.net.http.SslError): void {
         receivedSslError(handler, error);
       },
+      onReceivedError(view: android.webkit.WebView, request: android.webkit.WebResourceRequest, error: android.webkit.WebResourceError): void {
+        receivedError(view, request, error);
+      },
     })
     : (android.webkit.WebViewClient as any).extend({
       shouldInterceptRequest(_view: android.webkit.WebView, request: android.webkit.WebResourceRequest | string): android.webkit.WebResourceResponse | null {
@@ -482,9 +522,15 @@ function createAssetServingClient(): android.webkit.WebViewClient {
       onPageStarted(view: android.webkit.WebView, _url: string, _favicon: android.graphics.Bitmap): void {
         pageStarted(view);
       },
+      onPageFinished(view: android.webkit.WebView, url: string): void {
+        pageFinished(view, url);
+      },
       onReceivedSslError(_view: android.webkit.WebView, handler: android.webkit.SslErrorHandler, error: android.net.http.SslError): void {
         receivedSslError(handler, error);
       },
+      onReceivedError(view: android.webkit.WebView, request: android.webkit.WebResourceRequest, error: android.webkit.WebResourceError): void {
+        receivedError(view, request, error);
+      },
     });
   return new assetClientClass();
 }

package/runtime/app/shell/env-keepawake.ts

@@ -0,0 +1,94 @@
+import { Application, Utils, isAndroid, isIOS } from '@nativescript/core';
+import { SHELL_CONFIG } from './config';
+import { isNonDefaultOverride } from './env-switcher';
+
+/**
+ * Keep the screen awake while the shell is pointed at a NON-PRODUCTION backend, so a long on-device test
+ * session isn't killed by auto-lock. Companion to `env-banner.ts`: same trigger, same reconcile points.
+ *
+ * WHY THE BACKEND, NOT THE BUILD: `SHELL_CONFIG.debug` is a BUILD-TIME fact, and it misses the case that
+ * actually matters — a RELEASE/TestFlight binary (`debug:false`) whose env-switcher is pointed at lab or a
+ * local dev server is a test session in every way that counts, and it auto-locks mid-test. Conversely the
+ * signal must never fire for a real user. `isNonDefaultOverride()` is exactly that line: it is true only
+ * when a persisted `kit:serverUrlOverride` resolves to a host DIFFERENT from the build-time default
+ * (`SHELL_CONFIG.serverUrl`). A real user never sets an override, so this cannot leak into production —
+ * and it is the SAME predicate the amber env banner keys off, so "banner visible" ⟺ "screen stays awake",
+ * by construction rather than by two rules kept in sync by hand.
+ *
+ * `debug` is retained as an OR, not a replacement: a debug build has its own reason to stay awake (the
+ * inspect/iterate loop) even on the default env. This subsumes the iOS-only `idleTimerDisabled` block that
+ * used to sit inline in main-page.ts; the debug-gated Android half still lives in `custom-webview.android.ts`
+ * (`wv.setKeepScreenOn(true)`), which is harmlessly redundant with this module's Android path in a debug
+ * build — both are idempotent "keep on" assertions, and only this one also covers the env-override case.
+ *
+ * Inert for `loader !== 'server'` / no envSwitcher config: `isNonDefaultOverride()` returns false via
+ * `isEnvSwitcherEnabled()`, so a non-switcher app reduces to the plain `debug` behaviour (no crash).
+ */
+
+/** Desired wake-lock state: a non-default backend override (the banner's signal), or a debug build. */
+export function shouldKeepAwake(): boolean {
+  return !!SHELL_CONFIG.debug || isNonDefaultOverride();
+}
+
+let androidRetries = 0; // bounds the boot "activity not ready" retry so it can't spin forever
+
+/** Apply the wake lock natively. iOS: the app-wide idle timer. Android: the window's KEEP_SCREEN_ON flag.
+ *
+ * The Android boot retry mirrors `env-banner.ts`: at `onPageLoaded` on a relaunch the Activity is not
+ * necessarily attached yet, so `foregroundActivity` can be null. Returning silently there would drop the
+ * wake lock in exactly the common case (relaunch straight into lab) — so retry, bounded (~2s), and
+ * re-read the DESIRED state at each attempt so a switch/reset landing mid-window wins over a stale one. */
+function applyKeepAwake(on: boolean): void {
+  if (isIOS) {
+    Utils.dispatchToMainThread(() => {
+      try { UIApplication.sharedApplication.idleTimerDisabled = on; } catch (e) { /* no-op */ }
+    });
+  } else if (isAndroid) {
+    const activity = Application.android?.foregroundActivity || Application.android?.startActivity;
+    if (!activity) {
+      if (androidRetries++ < 20) setTimeout(() => applyKeepAwake(shouldKeepAwake()), 100);
+      return;
+    }
+    androidRetries = 0;
+    activity.runOnUiThread(new java.lang.Runnable({
+      run() {
+        try {
+          const window = activity.getWindow();
+          if (!window) return;
+          const flag = android.view.WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON;
+          on ? window.addFlags(flag) : window.clearFlags(flag);
+        } catch (e) { /* no-op */ }
+      },
+    }));
+  }
+}
+
+/**
+ * Reconcile the wake lock to the EXACT desired state — including turning it OFF. For explicit env
+ * transitions only (`applySwitch`, alongside `refreshEnvBanner`), where clearing on a reset-to-default is
+ * the whole point. Idempotent.
+ */
+export function refreshEnvKeepAwake(): void {
+  applyKeepAwake(shouldKeepAwake());
+}
+
+/**
+ * Assert the wake lock if this env wants it — but NEVER write `false`. For the boot and resume paths.
+ *
+ * WHY ASSERT-ONLY, not a full reconcile: the hosted app may hold the screen on ITSELF — either via the
+ * PUBLIC `ui.keepAwake` bridge API (handlers-extended / handlers-android), or via the web Screen Wake Lock
+ * API (`navigator.wakeLock`), which Android WebView honours by keeping the same KEEP_SCREEN_ON state. That
+ * is not hypothetical: the AGF app holds a `navigator.wakeLock` for the duration of a live room, and the
+ * flag is observable on its window (`dumpsys window` → `fl=KEEP_SCREEN_ON`) with no override set at all.
+ * A full reconcile on resume would write `false` on the default env and silently CLOBBER that app's own
+ * lock after any background trip. Writing `false` here would also buy nothing: a fresh process
+ * starts with the idle timer enabled and a fresh Activity window has no KEEP_SCREEN_ON flag, so "off" is
+ * already the state at boot. Only the ON direction needs re-asserting.
+ *
+ * ON DOES need re-asserting: neither platform guarantees the lock survives a background trip. Android
+ * drops the window flag outright if the Activity is recreated (config change / process-death restore) —
+ * a NEW window has no flag, and `initialized` in main-page.ts would not re-run the boot path.
+ */
+export function reassertEnvKeepAwake(): void {
+  if (shouldKeepAwake()) applyKeepAwake(true);
+}

package/runtime/app/shell/env-switcher.ts

@@ -1,8 +1,10 @@
 import { ApplicationSettings, Dialogs, Utils, isAndroid, isIOS } from '@nativescript/core';
+import type { EventData, LoadEventData } from '@nativescript/core';
 import { SHELL_CONFIG } from './config';
 import { OVERRIDE_KEY, effectiveServerUrl, isUrlAllowed } from './server-url';
 import { bridge } from './bridge';
 import { refreshEnvBanner } from './env-banner';
+import { refreshEnvKeepAwake } from './env-keepawake';
 
 /**
  * Runtime env-switcher — re-point a `loader:'server'` shell between declared environments (prod / lab /
@@ -72,12 +74,51 @@ function clearOverride(): void {
   ApplicationSettings.remove(OVERRIDE_KEY);
 }
 
+/**
+ * The switch is PERSISTED but the visible page did NOT change — the exact gap the confirm prompt's "The
+ * app will reload" leaves the user staring at. Silence here reads as "the switch didn't work" (it did:
+ * the override is already written, so a cold start WILL land on it), which is the actionable half and the
+ * half that was missing. Name the host and the reason so an unreachable target (dev server down, DNS,
+ * TLS/ATS refusal) is distinguishable from a broken switcher.
+ */
+function notifyNotReloaded(url: string, reason: string): void {
+  console.warn(`AppWrap: env switch persisted but the in-session reload did not happen (${hostOf(url)}): ${reason}`);
+  void Dialogs.alert({
+    title: 'Still on the old environment',
+    message: `Couldn't load ${hostOf(url)}.\n${reason}\n\nThe environment change IS saved — relaunch the app to use it.`,
+    okButtonText: 'OK',
+  });
+}
+
 /** Load the current effective server URL into the live WebView (immediate switch — no wait for a cold
- * start; the persisted override also makes it stick across relaunch via the boot loader). */
+ * start; the persisted override also makes it stick across relaunch via the boot loader).
+ *
+ * NEVER fail silently: both the no-WebView path and a FAILED load report through `notifyNotReloaded`.
+ * The failure seam is NativeScript's own `loadFinished` event, whose `error` arg both platforms already
+ * populate for a main-frame failure (iOS: WKNavigationDelegate didFail[Provisional]Navigation — a refused
+ * connection is PROVISIONAL, which is exactly the case that bit; Android: WebViewClient.onReceivedError,
+ * re-wired to NS in custom-webview.android.ts because our client replaces NS's). Reusing it keeps ONE
+ * cross-platform seam — do NOT install a second WKNavigationDelegate here: custom-webview.ios.ts already
+ * owns one (DevCertNavDelegate) and a competing delegate would silently unhook its cert trust.
+ *
+ * The handler is ONE-SHOT and armed immediately before the load, so it observes this switch's outcome and
+ * cannot leak or mis-attribute a later navigation's error to the switch.
+ */
 function reloadToEffective(): void {
-  const wv = bridge.getWebView();
-  if (!wv) return;
   const url = effectiveServerUrl();
+  const wv = bridge.getWebView();
+  if (!wv) {
+    notifyNotReloaded(url, 'The app view is not available.');
+    return;
+  }
+  // `on` resolves to Observable's generic overload here (CustomWebView widens the WebView-specific one),
+  // so take EventData and narrow — `loadFinished` always carries LoadEventData.
+  const onLoadFinished = (args: EventData) => {
+    wv.off('loadFinished', onLoadFinished);
+    const error = (args as LoadEventData).error;
+    if (error) notifyNotReloaded(url, String(error));
+  };
+  wv.on('loadFinished', onLoadFinished);
   Utils.dispatchToMainThread(() => {
     if (isIOS && wv.ios) {
       (wv.ios as WKWebView).loadRequest(NSURLRequest.requestWithURL(NSURL.URLWithString(url)));
@@ -104,6 +145,7 @@ async function applySwitch(url: string | null, label: string): Promise<void> {
   else clearOverride();
   reloadToEffective();
   refreshEnvBanner(); // in-session: reflect the new env (switch) or hide (reset) — not just on relaunch
+  refreshEnvKeepAwake(); // same signal as the banner: awake off-default, normal on a reset — never disagree
 }
 
 let menuOpen = false;
@@ -236,14 +278,22 @@ export async function handleEnvDeepLink(link: string): Promise<void> {
   }
 }
 
-/** Free-form URL entry, gated by `allowPattern` (default-deny). Rejects a non-matching URL. */
+/** Free-form URL entry, gated by `allowPattern` (default-deny). Rejects a non-matching URL.
+ *
+ * The field is deliberately EMPTY — do NOT re-add a `defaultText: 'https://'` prefill. A URL is the one
+ * input class users always PASTE, and a copied URL already carries its own scheme, so a prefill breaks
+ * exactly the case this field exists for: iOS pastes at the caret (which sits AFTER the prefill), giving
+ * `https://https://host` → rejected by `allowPattern` as "Not allowed". Typing masks the bug (you type the
+ * host after the prefix), which is why it reads as "paste doesn't work". An empty field is also where iOS
+ * offers Paste most readily — long-pressing a NON-empty field raises the cursor loupe, not the edit menu.
+ * The `https://` hint lives in `message` instead, where it can't contaminate the value.
+ */
 async function promptOther(): Promise<void> {
   const res = await Dialogs.prompt({
     title: 'Custom environment',
-    message: 'Enter an allowed URL (https://…).',
+    message: 'Enter or paste an allowed URL (https://…).',
     okButtonText: 'Next',
     cancelButtonText: 'Cancel',
-    defaultText: 'https://',
     inputType: 'text',
   });
   if (!res?.result || !res.text) return;