@livx.cc/appwrap 0.26.0 → 0.28.1

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

@@ -18,23 +18,55 @@ import { appwrapNativeLog } from './native-log';
 const appendWebLog = appwrapNativeLog;
 
 /** Parse a #rrggbb config color into a UIColor (for the WebView background). */
-function uiColorFromHex(hex?: string): any {
+function uiColorFromHex(hex?: string): UIColor | null {
   const m = /^#?([0-9a-fA-F]{6})$/.exec((hex ?? '').trim());
   if (!m) return null;
   const n = parseInt(m[1], 16);
   return UIColor.colorWithRedGreenBlueAlpha(((n >> 16) & 255) / 255, ((n >> 8) & 255) / 255, (n & 255) / 255, 1);
 }
 
+/** WKScriptMessageHandler for the `appwrap` channel — forwards JSON envelopes to the owning view. */
+@NativeClass()
+class AppwrapScriptHandler extends NSObject implements WKScriptMessageHandler {
+  static ObjCProtocols = [WKScriptMessageHandler];
+  owner!: WeakRef<CustomWebView>;
+  static new(): AppwrapScriptHandler {
+    return <AppwrapScriptHandler>super.new();
+  }
+  userContentControllerDidReceiveScriptMessage(_controller: WKUserContentController, message: WKScriptMessage): void {
+    const view = this.owner.get ? this.owner.get() : (this.owner as { deref(): CustomWebView }).deref();
+    const body = message.body;
+    // Envelopes always travel as JSON strings (protocol v1)
+    if (view?.onAppwrapMessage && typeof body === 'string') {
+      view.onAppwrapMessage(body);
+    }
+  }
+}
+
+/** WKScriptMessageHandler for the `appwrapLog` channel — debug console-forwarding to the file sink. */
+@NativeClass()
+class AppwrapLogHandler extends NSObject implements WKScriptMessageHandler {
+  static ObjCProtocols = [WKScriptMessageHandler];
+  static new(): AppwrapLogHandler {
+    return <AppwrapLogHandler>super.new();
+  }
+  userContentControllerDidReceiveScriptMessage(_c: WKUserContentController, message: WKScriptMessage): void {
+    // Write to the file sink — NS console.log / NSLog don't surface to devicectl/idevicesyslog
+    // on a device build, but a file in the app container is reliably pullable.
+    if (typeof message.body === 'string') appendWebLog(message.body);
+  }
+}
+
 export class CustomWebView extends WebView {
   /** Set by the bridge before load; receives raw envelope JSON. */
   onAppwrapMessage: ((json: string) => void) | null = null;
-  private _scriptHandler: any; // retained — WKUserContentController holds it weakly
-  private _logHandler: any; // retained — debug console-forwarding handler
-  private _schemeHandler: any;
+  private _scriptHandler!: AppwrapScriptHandler; // retained — WKUserContentController holds it weakly
+  private _logHandler!: AppwrapLogHandler; // retained — debug console-forwarding handler
+  private _schemeHandler!: WKURLSchemeHandler;
   // NOT `_uiDelegate`: the base NativeScript WebView uses that exact field name, and
   // TS `private` is compile-time only — sharing it let super.initNativeView() overwrite
   // our media-capture delegate with NS's, so getUserMedia re-prompted every call.
-  private _appwrapUiDelegate: any; // retained — WKWebView holds uiDelegate weakly
+  private _appwrapUiDelegate!: WKUIDelegate; // retained — WKWebView holds uiDelegate weakly
 
   /** No-op on iOS: WKWebView suspends rAF/timers itself when the app leaves the foreground.
    * Kept for parity with the Android impl (wired to suspend/resume in main-page). */
@@ -67,39 +99,14 @@ export class CustomWebView extends WebView {
     }
 
     const owner = new WeakRef<CustomWebView>(this);
-    const HandlerClass = (NSObject as any).extend(
-      {
-        userContentControllerDidReceiveScriptMessage(
-          _controller: WKUserContentController,
-          message: WKScriptMessage
-        ): void {
-          const view = owner.get ? owner.get() : (owner as any).deref();
-          const body = message.body;
-          // Envelopes always travel as JSON strings (protocol v1)
-          if (view?.onAppwrapMessage && typeof body === 'string') {
-            view.onAppwrapMessage(body);
-          }
-        },
-      },
-      { protocols: [WKScriptMessageHandler] }
-    );
-    this._scriptHandler = HandlerClass.new();
+    this._scriptHandler = AppwrapScriptHandler.new();
+    this._scriptHandler.owner = owner;
     config.userContentController.addScriptMessageHandlerName(this._scriptHandler, 'appwrap');
 
     // Debug console-forwarding: web console/errors → NSLog (via NS console.log) → device console,
     // so `appwrap logs ios` can stream them headlessly. Only wired in debug mode.
     if (SHELL_CONFIG.debug) {
-      const LogClass = (NSObject as any).extend(
-        {
-          userContentControllerDidReceiveScriptMessage(_c: WKUserContentController, message: WKScriptMessage): void {
-            // Write to the file sink — NS console.log / NSLog don't surface to devicectl/idevicesyslog
-            // on a device build, but a file in the app container is reliably pullable.
-            if (typeof message.body === 'string') appendWebLog(message.body);
-          },
-        },
-        { protocols: [WKScriptMessageHandler] }
-      );
-      this._logHandler = LogClass.new();
+      this._logHandler = AppwrapLogHandler.new();
       config.userContentController.addScriptMessageHandlerName(this._logHandler, 'appwrapLog');
       appendWebLog('[native] log handler registered'); // boot marker: proves the file sink works
     }
@@ -124,13 +131,13 @@ export class CustomWebView extends WebView {
     // Edge-swipe to go back/forward in WebView history — the iOS native gesture
     // users expect. SPAs that own their own history still get it for free.
     webView.allowsBackForwardNavigationGestures = true;
-    if ((webView.configuration as any).dataDetectorTypes !== undefined) {
-      (webView.configuration as any).dataDetectorTypes = 0; // WKDataDetectorTypeNone
+    if (webView.configuration.dataDetectorTypes !== undefined) {
+      webView.configuration.dataDetectorTypes = 0; // WKDataDetectorTypeNone (WKDataDetectorTypes.None)
     }
 
     // Observability (debug mode only): make the WebView debuggable via Safari Web Inspector
     // (Develop → <device> → Para) — full console + network. iOS 16.4+ (guarded). Off in store builds.
-    if (SHELL_CONFIG.debug && webView.respondsToSelector('setInspectable:')) (webView as any).inspectable = true;
+    if (SHELL_CONFIG.debug && webView.respondsToSelector('setInspectable:')) webView.inspectable = true;
 
     this._appwrapUiDelegate = createUiDelegate();
     webView.UIDelegate = this._appwrapUiDelegate;
@@ -147,9 +154,9 @@ export class CustomWebView extends WebView {
     const wk = this.nativeViewProtected as WKWebView;
     if (wk && this._appwrapUiDelegate) wk.UIDelegate = this._appwrapUiDelegate;
     // Lightweight self-check surfaced via debug.webviewInfo (support diagnostics).
-    (global as any).__appwrapWebviewDiag =
+    (global as { __appwrapWebviewDiag?: string }).__appwrapWebviewDiag =
       `delegateIsMine=${!!wk && wk.UIDelegate === this._appwrapUiDelegate} ` +
-      `respondsToMedia=${!!wk && !!wk.UIDelegate && !!(wk.UIDelegate as any).respondsToSelector?.('webView:requestMediaCapturePermissionForOrigin:initiatedByFrame:type:decisionHandler:')}`;
+      `respondsToMedia=${!!wk && !!wk.UIDelegate && !!wk.UIDelegate.respondsToSelector?.('webView:requestMediaCapturePermissionForOrigin:initiatedByFrame:type:decisionHandler:')}`;
   }
 }
 
@@ -163,41 +170,42 @@ export class CustomWebView extends WebView {
  *      request body, so POSTs proxy fine.
  *  - else                      → 404 (or SPA fallback when there's no backend).
  */
-function createAppSchemeHandler(): any {
+function createAppSchemeHandler(): WKURLSchemeHandler {
   const wwwPath = nsPath.join(knownFolders.currentApp().path, 'www');
 
-  const serveFile = (task: any, url: any, filePath: string, ext: string): void => {
+  const serveFile = (task: WKURLSchemeTask, url: NSURL, filePath: string, ext: string): void => {
     const data = NSData.dataWithContentsOfFile(filePath);
     const mime = mimeFor(ext, filePath);
     const response = NSHTTPURLResponse.alloc().initWithURLStatusCodeHTTPVersionHeaderFields(
       url, 200, 'HTTP/1.1',
+      // NS auto-marshals this JS object into NSDictionary<string,string>
       {
         'Content-Type': `${mime}; charset=utf-8`,
         'Content-Length': String(data?.length ?? 0),
         'Access-Control-Allow-Origin': '*',
         'Cache-Control': 'no-cache',
-      } as any
+      } as unknown as NSDictionary<string, string>
     );
     task.didReceiveResponse(response);
     if (data) task.didReceiveData(data);
     task.didFinish();
   };
 
-  const proxyToBackend = (task: any, url: any, rel: string): void => {
+  const proxyToBackend = (task: WKURLSchemeTask, url: NSURL, rel: string): void => {
     const backend = SHELL_CONFIG.backendOrigin.replace(/\/+$/, '');
     const query = url.query ? `?${url.query}` : '';
     const req = NSMutableURLRequest.requestWithURL(NSURL.URLWithString(`${backend}/${rel}${query}`));
     req.HTTPMethod = String(task.request.HTTPMethod ?? 'GET');
     const hdrs = task.request.allHTTPHeaderFields;
     if (hdrs) req.allHTTPHeaderFields = hdrs;
-    req.setValueForHTTPHeaderField(null as any, 'Host'); // let URLSession set Host from the target URL
+    req.setValueForHTTPHeaderField(null as unknown as string, 'Host'); // let URLSession set Host from the target URL
     // WKURLSchemeHandler delivers a POST/PUT body via HTTPBodyStream (not HTTPBody) — read it.
-    let body = task.request.HTTPBody;
+    let body: NSData = task.request.HTTPBody;
     if (!body && task.request.HTTPBodyStream) {
       const stream = task.request.HTTPBodyStream;
       const acc = NSMutableData.alloc().init();
       const cap = 16384;
-      const buf = (global as any).interop.alloc(cap);
+      const buf = interop.alloc(cap);
       stream.open();
       while (stream.hasBytesAvailable) {
         const n = stream.readMaxLength(buf, cap);
@@ -211,11 +219,11 @@ function createAppSchemeHandler(): any {
 
     const dataTask = NSURLSession.sharedSession.dataTaskWithRequestCompletionHandler(
       req,
-      (data: any, resp: any, error: any) => {
+      (data: NSData, resp: NSURLResponse, error: NSError) => {
         try {
           if (error || !resp) {
             const r = NSHTTPURLResponse.alloc().initWithURLStatusCodeHTTPVersionHeaderFields(
-              url, 502, 'HTTP/1.1', { 'Content-Length': '0' } as any
+              url, 502, 'HTTP/1.1', { 'Content-Length': '0' } as unknown as NSDictionary<string, string>
             );
             task.didReceiveResponse(r);
             task.didFinish();
@@ -223,10 +231,12 @@ function createAppSchemeHandler(): any {
           }
           // Re-emit under the app:// URL (same-origin). Strip Content-Encoding (URLSession already
           // decoded the body) and recompute length; keep the upstream Content-Type + status.
-          const ct = resp.valueForHTTPHeaderField?.('Content-Type') ?? 'application/octet-stream';
+          // resp is NSHTTPURLResponse at runtime (HTTP request) — cast for the HTTP-only members.
+          const httpResp = resp as NSHTTPURLResponse;
+          const ct = httpResp.valueForHTTPHeaderField?.('Content-Type') ?? 'application/octet-stream';
           const out = NSHTTPURLResponse.alloc().initWithURLStatusCodeHTTPVersionHeaderFields(
-            url, resp.statusCode ?? 200, 'HTTP/1.1',
-            { 'Content-Type': ct, 'Content-Length': String(data?.length ?? 0), 'Cache-Control': 'no-cache' } as any
+            url, httpResp.statusCode ?? 200, 'HTTP/1.1',
+            { 'Content-Type': ct, 'Content-Length': String(data?.length ?? 0), 'Cache-Control': 'no-cache' } as unknown as NSDictionary<string, string>
           );
           task.didReceiveResponse(out);
           if (data) task.didReceiveData(data);
@@ -239,36 +249,38 @@ function createAppSchemeHandler(): any {
     dataTask.resume();
   };
 
-  const HandlerClass = (NSObject as any).extend(
-    {
-      webViewStartURLSchemeTask(_webView: WKWebView, task: any): void {
-        const url = task.request.URL;
-        let rel = decodeURIComponent(String(url.path ?? '/')).replace(/^\/+/, '');
-        if (!rel) rel = SHELL_CONFIG.entry;
-        const filePath = nsPath.join(wwwPath, rel);
-        const ext = rel.includes('.') ? rel.split('.').pop()!.toLowerCase() : '';
+  @NativeClass()
+  class AppSchemeHandler extends NSObject implements WKURLSchemeHandler {
+    static ObjCProtocols = [WKURLSchemeHandler];
+    static new(): AppSchemeHandler {
+      return <AppSchemeHandler>super.new();
+    }
+    webViewStartURLSchemeTask(_webView: WKWebView, task: WKURLSchemeTask): void {
+      const url = task.request.URL;
+      let rel = decodeURIComponent(String(url.path ?? '/')).replace(/^\/+/, '');
+      if (!rel) rel = SHELL_CONFIG.entry;
+      const filePath = nsPath.join(wwwPath, rel);
+      const ext = rel.includes('.') ? rel.split('.').pop()!.toLowerCase() : '';
 
-        if (File.exists(filePath)) { serveFile(task, url, filePath, ext); return; }
+      if (File.exists(filePath)) { serveFile(task, url, filePath, ext); return; }
 
-        const method = String(task.request.HTTPMethod ?? 'GET').toUpperCase();
-        const accept = task.request.valueForHTTPHeaderField?.('Accept') ?? '';
-        const isNavigation = method === 'GET' && accept.indexOf('text/html') >= 0;
+      const method = String(task.request.HTTPMethod ?? 'GET').toUpperCase();
+      const accept = task.request.valueForHTTPHeaderField?.('Accept') ?? '';
+      const isNavigation = method === 'GET' && accept.indexOf('text/html') >= 0;
 
-        if (isNavigation && !ext) { serveFile(task, url, nsPath.join(wwwPath, SHELL_CONFIG.entry), 'html'); return; }
-        if (SHELL_CONFIG.backendOrigin) { proxyToBackend(task, url, rel); return; }
-        if (!ext) { serveFile(task, url, nsPath.join(wwwPath, SHELL_CONFIG.entry), 'html'); return; }
+      if (isNavigation && !ext) { serveFile(task, url, nsPath.join(wwwPath, SHELL_CONFIG.entry), 'html'); return; }
+      if (SHELL_CONFIG.backendOrigin) { proxyToBackend(task, url, rel); return; }
+      if (!ext) { serveFile(task, url, nsPath.join(wwwPath, SHELL_CONFIG.entry), 'html'); return; }
 
-        const resp = NSHTTPURLResponse.alloc().initWithURLStatusCodeHTTPVersionHeaderFields(
-          url, 404, 'HTTP/1.1', { 'Content-Length': '0' } as any
-        );
-        task.didReceiveResponse(resp);
-        task.didFinish();
-      },
-      webViewStopURLSchemeTask(_webView: WKWebView, _task: any): void {
-        // single-shot responses; in-flight proxy completions are guarded by try/catch.
-      },
-    },
-    { protocols: [WKURLSchemeHandler] }
-  );
-  return HandlerClass.new();
+      const resp = NSHTTPURLResponse.alloc().initWithURLStatusCodeHTTPVersionHeaderFields(
+        url, 404, 'HTTP/1.1', { 'Content-Length': '0' } as unknown as NSDictionary<string, string>
+      );
+      task.didReceiveResponse(resp);
+      task.didFinish();
+    }
+    webViewStopURLSchemeTask(_webView: WKWebView, _task: WKURLSchemeTask): void {
+      // single-shot responses; in-flight proxy completions are guarded by try/catch.
+    }
+  }
+  return AppSchemeHandler.new();
 }

package/runtime/app/shell/devmenu.ts

@@ -19,7 +19,7 @@ export function startDevMenu(): void {
 
 // ── shake detection (total acceleration magnitude in g incl. gravity, debounced) ──
 const SHAKE_G = 1.8; // spike vs. ~1g rest
-let shakeMm: any = null; // hold a ref so CoreMotion isn't GC'd
+let shakeMm: CMMotionManager | null = null; // hold a ref so CoreMotion isn't GC'd
 let firstSpikeAt = 0;
 let spikes = 0;
 let lastMenuAt = 0;
@@ -68,7 +68,7 @@ function startAndroidShake(): void {
   const G = 9.80665;
   const listener = new android.hardware.SensorEventListener({
     onAccuracyChanged() {},
-    onSensorChanged(e: any) {
+    onSensorChanged(e: android.hardware.SensorEvent) {
       const v = e.values;
       onAccelMagnitude(Math.sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]) / G);
     },

package/runtime/app/shell/env.ts

@@ -1,7 +1,5 @@
 import { Application, isAndroid } from '@nativescript/core';
 
-declare const android: any, NSProcessInfo: any, UIAccessibilityIsReduceMotionEnabled: any;
-
 /**
  * Runtime environment hints the page can't reliably detect itself, surfaced natively so a PWA can
  * scale its rendering down inside the shell. Injected at document-start as `window.__APPWRAP__` (see
@@ -36,7 +34,7 @@ export function envGlobalsJs(): string {
 function androidIsEmulator(): boolean {
   try {
     const B = android.os.Build;
-    const has = (v: any, s: string) => String(v || '').toLowerCase().includes(s);
+    const has = (v: string, s: string) => String(v || '').toLowerCase().includes(s);
     return (
       has(B.FINGERPRINT, 'generic') || has(B.FINGERPRINT, 'emulator') || has(B.FINGERPRINT, 'unknown') ||
       has(B.MODEL, 'google_sdk') || has(B.MODEL, 'emulator') || has(B.MODEL, 'android sdk built for') ||

package/runtime/app/shell/events.ts

@@ -1,9 +1,11 @@
 import { Application, Connectivity, isAndroid } from '@nativescript/core';
+import type { AndroidActivityNewIntentEventData, OrientationChangedEventData } from '@nativescript/core';
 import { bridge } from './bridge';
 import { connectivityStatus } from './handlers-extended';
 
 let pendingDeepLink: string | null = null;
 let pendingPushTap: { data: Record<string, string> } | null = null;
+let pendingShortcut: string | null = null;
 // True only once the PWA's JS has handshaked — i.e. the WebView is actually
 // running our bundle and about to subscribe. Native page-load is too early:
 // a deeplink.open emitted then lands in a WebView with no listener and is lost
@@ -27,6 +29,15 @@ export function onDeepLink(url: string): void {
   else pendingDeepLink = url; // buffer until the PWA handshakes
 }
 
+/** A home-screen shortcut was activated (iOS performActionForShortcutItem / cold-start launchOptions;
+ * Android the launch intent's `appwrap_shortcut` extra). Buffered until the handshake like deep links
+ * (cold-start: a shortcut that launched the app would otherwise land in a WebView with no listener). */
+export function onShortcut(id: string): void {
+  if (!id) return;
+  if (pwaReady) bridge.emit('app.shortcut', { id });
+  else pendingShortcut = id;
+}
+
 /** Android: a tray notification (FCM) was tapped → re-launched the activity with the data payload as
  * intent extras. Buffered until handshake like deep links (cold-start-from-notification). iOS routes
  * taps via the AppDelegate (handlers-push onRemoteMessage). */
@@ -53,13 +64,18 @@ export function onPwaHandshake(): void {
     pendingPushTap = null;
     setTimeout(() => bridge.emit('push.tap', payload), 500);
   }
+  if (pendingShortcut) {
+    const id = pendingShortcut;
+    pendingShortcut = null;
+    setTimeout(() => bridge.emit('app.shortcut', { id }), 500);
+  }
 }
 
 /** Wire lifecycle + connectivity event forwarding (the PWA subscribes to these). */
 export function startEventForwarding(): void {
   Application.on(Application.suspendEvent, () => bridge.emit('app.pause'));
   Application.on(Application.resumeEvent, () => bridge.emit('app.resume'));
-  Application.on(Application.orientationChangedEvent, (args: any) =>
+  Application.on(Application.orientationChangedEvent, (args: OrientationChangedEventData) =>
     bridge.emit('screen.orientation.change', args?.newValue === 'landscape' ? 'landscape' : 'portrait')
   );
 
@@ -71,18 +87,23 @@ export function startEventForwarding(): void {
 /** Intents: launch intent (cold start) + onNewIntent (warm, singleTask). Carries both VIEW deep links
  * and FCM notification-tap extras. */
 function wireAndroidDeepLinks(): void {
-  const emitFromIntent = (intent: any) => {
+  const emitFromIntent = (intent: android.content.Intent | null | undefined) => {
     try {
       const data = intent?.getData?.();
       if (data) onDeepLink(String(data.toString()));
       const tap = readFcmTapExtras(intent);
       if (tap) onPushTap(tap);
+      const shortcutId = intent?.getStringExtra?.('appwrap_shortcut');
+      if (shortcutId) {
+        onShortcut(String(shortcutId));
+        intent.removeExtra?.('appwrap_shortcut'); // consume — don't re-fire on the next relayout read
+      }
     } catch (e) {
       console.warn('AppWrap: intent read failed', e);
     }
   };
 
-  Application.android.on(Application.android.activityNewIntentEvent as any, (args: any) =>
+  Application.android.on(Application.android.activityNewIntentEvent, (args: AndroidActivityNewIntentEventData) =>
     emitFromIntent(args.intent)
   );
   emitFromIntent(Application.android.startActivity?.getIntent?.());
@@ -91,7 +112,7 @@ function wireAndroidDeepLinks(): void {
 /** A tapped FCM notification re-launches the activity with the message's data payload as string
  * extras, alongside FCM's own `google.*`/`gcm.*`/`from`/`collapse_key` bookkeeping keys. Detect via
  * those markers; return the app's data keys only. Null when this isn't an FCM-originated intent. */
-function readFcmTapExtras(intent: any): { data: Record<string, string> } | null {
+function readFcmTapExtras(intent: android.content.Intent | null | undefined): { data: Record<string, string> } | null {
   try {
     const extras = intent?.getExtras?.();
     if (!extras || (!extras.containsKey('google.message_id') && !extras.containsKey('from'))) return null;

package/runtime/app/shell/fcm-firebase.d.ts

@@ -2,7 +2,8 @@
  * Minimal ambient declarations for the Firebase Messaging Android classes the FCM service extends.
  * The full classes are provided at runtime by the `firebase-messaging` AAR (added by the CLI only
  * when push is wired) — the NativeScript Android runtime marshals them. Declare-merges into the
- * `com` namespace from @nativescript/types-android. Mirrors ios-frameworks.d.ts.
+ * `com` namespace from @nativescript/types-android. (iOS SDK frameworks are typed via the
+ * @nativescript/types-ios references in references.d.ts.)
  */
 declare namespace com.google.firebase.messaging {
   class RemoteMessage {

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

@@ -2,7 +2,8 @@ import { Application, Utils } from '@nativescript/core';
 import { bridge } from './bridge';
 import { requestPermissions, startActivityForResult, uriToDataUrl, bitmapToDataUrl } from './android-helpers';
 
-declare const android: any, java: any, androidx: any;
+// no NS types: android-32 typings omit ContactsContract/MediaStore column + ACTION_PICK_IMAGES constants this file reads
+declare const android: any, androidx: any;
 
 const err = (code: string, message: string) => Object.assign(new Error(message), { code });
 
@@ -125,18 +126,21 @@ export function registerAndroidHandlers(): void {
   // ── geolocation (LocationManager) ──────────────────────────────────
   const GEO_PERMS = ['android.permission.ACCESS_FINE_LOCATION', 'android.permission.ACCESS_COARSE_LOCATION'];
   const locationManager = () => context().getSystemService(android.content.Context.LOCATION_SERVICE);
-  const toPosition = (loc: any) => ({
+  const toPosition = (loc: android.location.Location) => ({
     lat: loc.getLatitude(), lng: loc.getLongitude(), accuracy: loc.getAccuracy(),
   });
-  const makeListener = (onLocation: (loc: any) => void) =>
+  const makeListener = (onLocation: (loc: android.location.Location) => void) =>
     new android.location.LocationListener({
-      // Both overloads dispatch here — newer Android may deliver a List<Location>
-      onLocationChanged(loc: any) {
+      // Both overloads dispatch here — newer Android may deliver a List<Location>.
+      onLocationChanged(arg: android.location.Location | java.util.List<android.location.Location>) {
+        // interop: runtime duck-typing across the two Java overloads; TS can't narrow Java types here
+        let loc: any = arg;
         if (loc && typeof loc.getLatitude !== 'function' && typeof loc.size === 'function') {
           loc = loc.size() > 0 ? loc.get(loc.size() - 1) : null;
         }
         if (loc) onLocation(loc);
       },
+      onFlushComplete() {},
       onStatusChanged() {}, onProviderEnabled() {}, onProviderDisabled() {},
     });
 
@@ -148,7 +152,7 @@ export function registerAndroidHandlers(): void {
         ?? lm.getLastKnownLocation(android.location.LocationManager.NETWORK_PROVIDER);
       if (last) return resolve(toPosition(last));
 
-      let listener: any = null;
+      let listener: android.location.LocationListener | null = null;
       const timer = setTimeout(() => {
         if (listener) lm.removeUpdates(listener);
         reject(err('TIMEOUT', 'location timeout'));
@@ -165,7 +169,7 @@ export function registerAndroidHandlers(): void {
     });
   });
 
-  let geoWatchListener: any = null;
+  let geoWatchListener: android.location.LocationListener | null = null;
   bridge.register('geo.watch.start', async () => {
     if (geoWatchListener) return; // already streaming
     if (!(await requestPermissions(GEO_PERMS))) throw err('DENIED', 'location permission denied');
@@ -249,7 +253,7 @@ export function registerAndroidHandlers(): void {
 
   // ── motion (SensorManager: accelerometer + gyroscope) ──────────────
   const sensorManager = () => context().getSystemService(android.content.Context.SENSOR_SERVICE);
-  let motionListener: any = null;
+  let motionListener: android.hardware.SensorEventListener | null = null;
   const lastMotion = { ax: 0, ay: 0, az: 0, rx: 0, ry: 0, rz: 0 };
 
   bridge.register('motion.start', () => {
@@ -261,7 +265,7 @@ export function registerAndroidHandlers(): void {
     let last = 0;
     motionListener = new android.hardware.SensorEventListener({
       onAccuracyChanged() {},
-      onSensorChanged(event: any) {
+      onSensorChanged(event: android.hardware.SensorEvent) {
         const v = event.values;
         if (event.sensor.getType() === android.hardware.Sensor.TYPE_ACCELEROMETER) {
           // Android accelerometer already reports m/s² incl. gravity — kit contract matches.
@@ -296,7 +300,7 @@ export function registerAndroidHandlers(): void {
     if (resultCode !== android.app.Activity.RESULT_OK || !result?.getData()) return { picked: false };
 
     const cr = context().getContentResolver();
-    const column = (uri: any, col: string, sel: string | null, args: string[] | null): string[] => {
+    const column = (uri: android.net.Uri, col: string, sel: string | null, args: string[] | null): string[] => {
       const out: string[] = [];
       const cursor = cr.query(uri, [col], sel, args, null);
       if (cursor) {
@@ -327,7 +331,7 @@ export function registerAndroidHandlers(): void {
     }
     const CC = android.provider.ContactsContract;
     const cr = context().getContentResolver();
-    const column = (uri: any, col: string, sel: string | null, args: string[] | null): string[] => {
+    const column = (uri: android.net.Uri, col: string, sel: string | null, args: string[] | null): string[] => {
       const out: string[] = [];
       const cursor = cr.query(uri, [col], sel, args, null);
       if (cursor) {
@@ -415,7 +419,7 @@ export function registerAndroidHandlers(): void {
     dir.mkdirs();
     const uris = new java.util.ArrayList();
     const mimes = new java.util.HashSet();
-    (files ?? []).forEach((f: any, i: number) => {
+    (files ?? []).forEach((f: { name: string; mimeType: string; base64: string }, i: number) => {
       const bytes = android.util.Base64.decode(f.base64, android.util.Base64.DEFAULT);
       const out = new java.io.File(dir, i + '-' + (f.name || 'file')); // index-prefix: avoid same-name collisions
       const fos = new java.io.FileOutputStream(out);