@livx.cc/appwrap 0.30.0 → 0.30.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@livx.cc/appwrap",
-  "version": "0.30.0",
+  "version": "0.30.1",
   "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,9 +17,44 @@ import { startDevMenu } from './shell/devmenu';
 import { SHELL_CONFIG } from './shell/config';
 import { bindStatusBarPage, setStatusBarStyle, applyThemeColor, enableAndroidEdgeToEdge, wireAndroidSafeArea } from './shell/status-bar';
 import { CustomWebView } from './shell/custom-webview';
+import { appwrapNativeLog } from './shell/native-log';
 
 let initialized = false;
 
+/** DEBUG iOS lifecycle tracer — logs NS suspend/resume/displayed AND the raw UIApplication
+ * activation notifications (willResignActive/didBecomeActive/didEnterBackground/willEnterForeground)
+ * with each connected scene's activationState, to Documents/appwrap-web.log. Diagnostic for the
+ * StoreKit-sheet freeze: a system sheet that only resigns-active (never backgrounds) produces a
+ * different event sequence than a real background, so the resume/wake path may not fire on dismiss. */
+let _lifecycleTraced = false;
+function traceIosLifecycle(): void {
+  if (_lifecycleTraced) return;
+  _lifecycleTraced = true;
+  const log = (e: string): void => {
+    let states = '';
+    try {
+      const scenes = UIApplication.sharedApplication.connectedScenes.allObjects;
+      for (let i = 0; i < scenes.count; i++) {
+        const s = scenes.objectAtIndex(i) as UIScene;
+        states += ` [${(s as any).session?.role ?? '?'}:act=${s.activationState}]`;
+      }
+    } catch { states = ' (scene-read-err)'; }
+    appwrapNativeLog(`[native:lifecycle] ${e}${states}`);
+  };
+  Application.on(Application.suspendEvent, () => log('NS.suspend'));
+  Application.on(Application.resumeEvent, () => log('NS.resume'));
+  Application.on(Application.displayedEvent, () => log('NS.displayed'));
+  const nc = NSNotificationCenter.defaultCenter;
+  const obs = (name: string, tag: string): void => {
+    nc.addObserverForNameObjectQueueUsingBlock(name, null, null, () => log(tag));
+  };
+  obs(UIApplicationWillResignActiveNotification, 'UIApp.willResignActive');
+  obs(UIApplicationDidBecomeActiveNotification, 'UIApp.didBecomeActive');
+  obs(UIApplicationDidEnterBackgroundNotification, 'UIApp.didEnterBackground');
+  obs(UIApplicationWillEnterForegroundNotification, 'UIApp.willEnterForeground');
+  appwrapNativeLog('[native:lifecycle] tracer armed');
+}
+
 export function onPageLoaded(args: EventData): void {
   const page = args.object as Page;
   page.bindingContext = { backgroundColor: SHELL_CONFIG.backgroundColor };
@@ -62,7 +97,16 @@ export function onPageLoaded(args: EventData): void {
   // 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.
   Application.on(Application.suspendEvent, () => webView.setRenderingActive(false));
-  Application.on(Application.resumeEvent, () => webView.setRenderingActive(true));
+  Application.on(Application.resumeEvent, () => {
+    webView.setRenderingActive(true);
+    // 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();
+  });
+
+  // DEBUG: trace the iOS app-lifecycle event sequence to the pullable log sink so we can see WHICH
+  // resume signal does (or doesn't) fire when returning from the StoreKit sheet vs a normal background.
+  if (isIOS && SHELL_CONFIG.debug) traceIosLifecycle();
 
   // Android system back → WebView history (iOS gets this via the edge-swipe
   // gesture). Only swallow the press when there's history to pop; otherwise let

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

@@ -89,6 +89,12 @@ export class CustomWebView extends WebView {
     }
   }
 
+  /** iOS-only renderer-wake (see custom-webview.ios.ts). No-op on Android: onResume()/resumeTimers()
+   * in setRenderingActive already restart the WebView pipeline on foreground. */
+  wakeWebContent(): void {
+    /* iOS-only */
+  }
+
   private installDocumentStartShim(wv: android.webkit.WebView): void {
     try {
       const wkt = androidx.webkit;

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

@@ -74,6 +74,45 @@ export class CustomWebView extends WebView {
     /* OS-managed on iOS */
   }
 
+  /**
+   * Proactively WAKE the WebContent renderer process on foreground (wired to Application.resumeEvent
+   * for iOS in main-page). WHY: when a full-window system surface covers the app — StoreKit's
+   * showManageSubscriptions(in:) (hosted out-of-process by com.apple.ios.StoreKitUIService), the
+   * itms-apps subscriptions deep link, or any backgrounding — the UIScene goes non-foreground and
+   * WebKit THROTTLES/SUSPENDS the WKWebView's WebContent process; its JS stops and the app UI (which
+   * IS the WebView) freezes. On return, WebKit re-acquires the scene assertion lazily (~30-45s),
+   * leaving the page frozen until then. An inbound `evaluateJavaScript` is a foreground WebContent
+   * activity (WebPageProxy::runJavaScriptInFrameInScriptWorld) — it forces WebKit to restore the
+   * process NOW instead of waiting out the throttle. The injected JS also re-fires a synthetic
+   * `visibilitychange`/`pageshow` so a loader:'server' web app reconnects its sockets immediately
+   * (it would otherwise wait for WebKit to deliver the native visibility event late). No-op on Android. */
+  wakeWebContent(): void {
+    const wk = this.nativeViewProtected as WKWebView;
+    if (!wk) return;
+    if (SHELL_CONFIG.debug) appendWebLog(`[native:lifecycle] wakeWebContent run (frame ${wk.frame.size.width}x${wk.frame.size.height})`);
+    // (1) COMPOSITOR NUDGE — force a layout + compositing pass so a WebView that returned from an
+    // occluding system surface (StoreKit sheet, deep link, backgrounding) repaints + re-hit-tests NOW
+    // rather than waiting out WebKit's lazy restore. A 1px frame perturbation, restored in the same
+    // runloop. (For the StoreKit-sheet freeze the primary fix is neutralising the orphaned tracking
+    // window in handlers-billing/the Swift shim; this nudge + the JS wake below complete the resume the
+    // OS never fires for that sheet — see handlers-billing.manageSubscriptionsSheet.)
+    const f = wk.frame;
+    if (f.size.width > 0 && f.size.height > 1) {
+      wk.frame = CGRectMake(f.origin.x, f.origin.y, f.size.width, f.size.height - 1);
+      wk.frame = f;
+      wk.setNeedsLayout();
+      wk.layoutIfNeeded();
+    }
+    // (2) Re-emit visibility so the page's own visibilitychange/pageshow listeners (socket reconnect,
+    // session refresh) run right away. document.hidden is already false on foreground — this just
+    // un-blocks resume handlers that gate on the event rather than polling.
+    wk.evaluateJavaScriptCompletionHandler(
+      `try{document.dispatchEvent(new Event('visibilitychange'));` +
+      `window.dispatchEvent(new PageTransitionEvent('pageshow',{persisted:true}));}catch(e){}`,
+      () => { /* fire-and-forget; the eval itself is the wake */ }
+    );
+  }
+
   createNativeView(): WKWebView {
     const config = WKWebViewConfiguration.new();
     config.allowsInlineMediaPlayback = true;

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

@@ -14,4 +14,10 @@ export class CustomWebView extends WebView {
   setRenderingActive(_active: boolean): void {
     /* overridden per-platform */
   }
+
+  /** iOS: wake the WebContent renderer on foreground so a system-sheet/background throttle doesn't
+   * leave the WebView frozen for ~30-45s (see custom-webview.ios.ts). No-op on Android. */
+  wakeWebContent(): void {
+    /* overridden per-platform */
+  }
 }

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

@@ -1,9 +1,12 @@
 import { Utils, isIOS } from '@nativescript/core';
 import { bridge } from './bridge';
+import { appwrapNativeLog } from './native-log';
+import { SHELL_CONFIG } from './config';
 
 // @objc Swift shim (AppwrapManageSubscriptions.swift, billing nativeSrc) — no NS types; bridges
 // StoreKit 2's Swift-async showManageSubscriptions(in:) to a completion the ObjC bridge can call.
-declare const AppwrapManageSubscriptions: { present(completion: (message: string | null) => void): void };
+// completion(errorMessage, diagnostic): diagnostic is a post-dismiss window-hierarchy dump (DEBUG).
+declare const AppwrapManageSubscriptions: { present(completion: (message: string | null, diagnostic: string | null) => void): void };
 
 /**
  * In-app purchases — iOS StoreKit 1 (SKPaymentQueue). StoreKit 2 (Product/Transaction)
@@ -214,7 +217,14 @@ export function registerBillingHandlers(): void {
   // deep-link path above is untouched. Rejects on iOS <15, no scene, or a StoreKit error.
   bridge.register('billing.manageSubscriptionsSheet', () => {
     return new Promise<void>((resolve, reject) => {
-      AppwrapManageSubscriptions.present((message: string | null) => {
+      AppwrapManageSubscriptions.present((message: string | null, diagnostic: string | null) => {
+        if (SHELL_CONFIG.debug) appwrapNativeLog(`[native:lifecycle] manageSubscriptionsSheet done err=${message ?? 'none'}\n${diagnostic ?? '(no diag)'}`);
+        // The StoreKit sheet presents/dismisses WITHOUT the app scene leaving foregroundActive, so iOS
+        // never fires resumeEvent → the WebView's normal foreground wake (wakeWebContent) doesn't run.
+        // Drive it explicitly here (the only callback that fires) to un-throttle/repaint the WebView.
+        // (The native shim separately neutralises the orphaned StoreKit tracking-window that otherwise
+        // floats above our window and swallows touches — together they clear the post-sheet freeze.)
+        bridge.getWebView()?.wakeWebContent();
         if (message) reject(err('NATIVE_ERROR', message));
         else resolve();
       });

package/runtime/modules-native/billing/App_Resources/iOS/src/AppwrapManageSubscriptions.swift

@@ -7,31 +7,87 @@ import UIKit
 // callback (NativeScript can't await Swift async) and runs it on the main actor against the active
 // foreground UIWindowScene. Shipped via the billing module's nativeSrc → compiled into the app target
 // only when `billing` is active. iOS 15+ (StoreKit 2); the JS layer guards the deep-link fallback.
+//
+// THE FREEZE IT FIXES: showManageSubscriptions(in:) presents/dismisses WITHOUT the app scene ever
+// leaving foregroundActive (verified: zero app-lifecycle events fire across present→dismiss), so (a)
+// the OS never fires a resume the WebView could wake on, and (b) the dismissal leaves an orphaned
+// interactive UITrackingElementWindow at windowLevel 1 ABOVE our app window that swallows every touch —
+// the app underneath stays alive but unresponsive ("frozen for minutes" until iOS reaps the window).
+// We recover explicitly from THIS completion (the only thing that fires): after letting the dismissal
+// settle, neutralise any stray above-our-main window (uie=false + hide) and re-key our window. The JS
+// layer additionally drives the WebView's own resume (wakeWebContent) since no native resume arrives.
 @objc(AppwrapManageSubscriptions)
 public final class AppwrapManageSubscriptions: NSObject {
-  // completion(nil) on success; completion(message) on failure. Always invoked on the main thread
-  // so the NativeScript JS continuation (and WebView response delivery) resumes on the UI thread.
-  @objc public static func present(_ completion: @escaping (String?) -> Void) {
+  // completion(error, diagnostic): error nil on success / message on failure; diagnostic is a
+  // before/after window-hierarchy dump (DEBUG aid) the JS layer logs to the file sink. Always on main.
+  @objc public static func present(_ completion: @escaping (String?, String?) -> Void) {
     guard #available(iOS 15.0, *) else {
-      completion("StoreKit 2 manage-subscriptions sheet requires iOS 15+")
+      completion("StoreKit 2 manage-subscriptions sheet requires iOS 15+", nil)
       return
     }
     Task { @MainActor in
       guard let scene = AppwrapManageSubscriptions.activeWindowScene() else {
-        completion("No active UIWindowScene to present the subscriptions sheet")
+        completion("No active UIWindowScene to present the subscriptions sheet", nil)
         return
       }
+      var err: String? = nil
       do {
         try await AppStore.showManageSubscriptions(in: scene)
-        completion(nil)
       } catch {
-        completion(error.localizedDescription)
+        err = error.localizedDescription
       }
+      let before = AppwrapManageSubscriptions.dump(scene, tag: "BEFORE")
+      // The await can return before the dismissal animation finishes finalizing the orphan tracking
+      // window — settle first, then neutralise it (hiding at completion-time was too early to stick).
+      try? await Task.sleep(nanoseconds: 350_000_000)
+      let after = AppwrapManageSubscriptions.recover(scene)
+      completion(err, before + "\n" + after)
     }
   }
 
+  // Read-only dump of the scene's windows (+ presented-VC chain, key/interaction flags) for diagnosis.
+  @available(iOS 15.0, *)
+  @MainActor private static func dump(_ scene: UIWindowScene, tag: String) -> String {
+    var lines: [String] = ["\(tag): windows=\(scene.windows.count) keyWin=\(scene.keyWindow.map { ptr($0) } ?? "nil")"]
+    for (i, w) in scene.windows.enumerated() {
+      var presented: [String] = []
+      var vc = w.rootViewController
+      while let p = vc?.presentedViewController { presented.append(String(describing: type(of: p))); vc = p }
+      lines.append("  [\(i)] \(ptr(w)) level=\(w.windowLevel.rawValue) key=\(w.isKeyWindow) hidden=\(w.isHidden) uie=\(w.isUserInteractionEnabled) root=\(w.rootViewController.map { String(describing: type(of: $0)) } ?? "nil") presented=\(presented.isEmpty ? "none" : presented.joined(separator: ">"))")
+    }
+    return lines.joined(separator: "\n")
+  }
+
+  // Neutralise any window sitting ABOVE our main app window (touch-stealer), dismiss a lingering
+  // presented controller, and re-assert our main window as key. Returns the post-recovery dump.
+  @available(iOS 15.0, *)
+  @MainActor private static func recover(_ scene: UIWindowScene) -> String {
+    var lines: [String] = []
+    let main = scene.windows
+      .filter { !$0.isHidden && $0.rootViewController != nil }
+      .min { $0.windowLevel.rawValue < $1.windowLevel.rawValue }
+    for (i, w) in scene.windows.enumerated() {
+      if let presented = w.rootViewController?.presentedViewController {
+        presented.dismiss(animated: false)
+        lines.append("  recover: dismissed \(String(describing: type(of: presented))) on win[\(i)]")
+      }
+      if let m = main, w !== m, w.windowLevel.rawValue >= m.windowLevel.rawValue, w.windowLevel.rawValue > 0 {
+        // Pass touches THROUGH to our app window below, and take it out of the hierarchy.
+        w.isUserInteractionEnabled = false
+        w.isHidden = true
+        lines.append("  recover: neutralised win[\(i)] level=\(w.windowLevel.rawValue) root=\(w.rootViewController.map { String(describing: type(of: $0)) } ?? "nil")")
+      }
+    }
+    if let m = main { m.makeKeyAndVisible(); lines.append("  recover: re-keyed main") }
+    return AppwrapManageSubscriptions.dump(scene, tag: "AFTER-RECOVER") + "\n" + lines.joined(separator: "\n")
+  }
+
+  @MainActor private static func ptr(_ w: UIWindow) -> String {
+    return "UIWindow<\(UInt(bitPattern: ObjectIdentifier(w).hashValue) & 0xffffff)>"
+  }
+
   // The foreground-active window scene (the one allowed to present UI). Falls back to any connected
-  // window scene so a not-yet-foregroundActive launch still finds a presenter.
+  // window scene so a not-yet-foreground launch still finds a presenter.
   @MainActor private static func activeWindowScene() -> UIWindowScene? {
     let scenes = UIApplication.shared.connectedScenes.compactMap { $0 as? UIWindowScene }
     return scenes.first { $0.activationState == .foregroundActive } ?? scenes.first