@livx.cc/appwrap 0.19.0

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

@@ -0,0 +1,69 @@
+import { Utils, isIOS } from '@nativescript/core';
+import { bridge } from './bridge';
+
+// AuthenticationServices globals (NS auto-links the framework via metadata when referenced).
+declare const ASWebAuthenticationSession: any;
+declare const ASWebAuthenticationPresentationContextProviding: any;
+
+const err = (code: string, message: string) => Object.assign(new Error(message), { code });
+
+// Keep strong refs while the sheet is up — ARC frees the session + its context provider the moment
+// the JS locals fall out of scope, which silently cancels the flow mid-handshake.
+let activeSession: any = null;
+let activeProvider: any = null;
+
+/**
+ * System-browser OAuth (iOS ASWebAuthenticationSession). Runs the provider's auth page in the
+ * OS-shared, policy-compliant browser and returns the redirect callback URL to JS — so Google et al.
+ * don't reject it as an embedded WebView (403 disallowed_useragent). Provider-agnostic: the PWA builds
+ * the auth URL + does token exchange; this only opens the browser and hands back the callback.
+ */
+export function registerOAuthHandlers(): void {
+  if (!isIOS) return;
+
+  bridge.register(
+    'oauth.authorize',
+    ({ url, callbackScheme, ephemeral }: { url: string; callbackScheme: string; ephemeral?: boolean }) =>
+      new Promise((resolve, reject) => {
+        const target = String(url ?? '');
+        const scheme = String(callbackScheme ?? '');
+        if (!target) { reject(err('NATIVE_ERROR', 'oauth.authorize: empty url')); return; }
+        if (!scheme) { reject(err('NATIVE_ERROR', 'oauth.authorize: empty callbackScheme')); return; }
+
+        Utils.dispatchToMainThread(() => {
+          const session = ASWebAuthenticationSession.alloc().initWithURLCallbackURLSchemeCompletionHandler(
+            NSURL.URLWithString(target),
+            scheme,
+            (callbackURL: any, error: any) => {
+              activeSession = null;
+              activeProvider = null;
+              if (error) {
+                // ASWebAuthenticationSessionErrorCodeCanceledLogin === 1 (user dismissed the sheet).
+                const code = error.code === 1 ? 'CANCELLED' : 'NATIVE_ERROR';
+                reject(err(code, error.localizedDescription ?? 'oauth failed'));
+                return;
+              }
+              resolve({ url: callbackURL ? String(callbackURL.absoluteString) : '' });
+            }
+          );
+
+          const ProviderClass = (NSObject as any).extend(
+            {
+              presentationAnchorForWebAuthenticationSession(_session: any): any {
+                return (
+                  Utils.ios.getRootViewController()?.view?.window ??
+                  UIApplication.sharedApplication.keyWindow
+                );
+              },
+            },
+            { protocols: [ASWebAuthenticationPresentationContextProviding] }
+          );
+          activeProvider = ProviderClass.new();
+          session.presentationContextProvider = activeProvider;
+          session.prefersEphemeralWebBrowserSession = !!ephemeral;
+          activeSession = session;
+          session.start();
+        });
+      })
+  );
+}

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

@@ -0,0 +1,257 @@
+import { Application, ApplicationSettings, Color, Dialogs, Utils, isIOS } from '@nativescript/core';
+import { bridge } from './bridge';
+import { uiImageToDataUrl } from './ios-image';
+
+const err = (code: string, message: string) => Object.assign(new Error(message), { code });
+const iosOnly = () => err('UNSUPPORTED', 'iOS only for now');
+
+/**
+ * Extended-parity handlers: dialogs, reviews, storage.clear, geo watch, theme color,
+ * motion, contacts, calendar, camera. iOS-first like handlers-extended.
+ */
+export function registerParityHandlers(): void {
+  // ── dialogs (NS Dialogs — cross-platform) ──────────────────────────
+  bridge.register('ui.alert', ({ title, message, ok }: any) =>
+    Dialogs.alert({ title, message: String(message ?? ''), okButtonText: ok ?? 'OK' }).then(() => undefined)
+  );
+
+  bridge.register('ui.confirm', ({ title, message, ok, cancel }: any) =>
+    Dialogs.confirm({
+      title,
+      message: String(message ?? ''),
+      okButtonText: ok ?? 'OK',
+      cancelButtonText: cancel ?? 'Cancel',
+    }).then((r) => !!r)
+  );
+
+  bridge.register('ui.action', async ({ title, options, cancel }: any) => {
+    const cancelText = cancel ?? 'Cancel';
+    const picked = await Dialogs.action({ title, actions: options ?? [], cancelButtonText: cancelText });
+    const idx = (options ?? []).indexOf(picked);
+    return idx >= 0 ? idx : null;
+  });
+
+  // ── reviews (SKStoreReviewController) ──────────────────────────────
+  bridge.register('reviews.requestReview', () => {
+    if (!isIOS) throw iosOnly();
+    Utils.dispatchToMainThread(() => {
+      const scene = UIApplication.sharedApplication.keyWindow?.windowScene;
+      if (scene && SKStoreReviewController.requestReviewInWindowScene) {
+        SKStoreReviewController.requestReviewInWindowScene(scene);
+      } else {
+        SKStoreReviewController.requestReview();
+      }
+    });
+  });
+
+  // ── storage.clear ──────────────────────────────────────────────────
+  bridge.register('storage.clear', () => {
+    for (const key of ApplicationSettings.getAllKeys()) {
+      if (key.startsWith('kit:')) ApplicationSettings.remove(key);
+    }
+  });
+
+  // ── theme color → native chrome behind the page ────────────────────
+  bridge.register('ui.setBackgroundColor', ({ color }: { color: string }) => {
+    Utils.dispatchToMainThread(() => {
+      const root = Application.getRootView();
+      if (root) root.backgroundColor = new Color(String(color));
+    });
+  });
+
+  // ── geo.watch (persistent CLLocationManager) ───────────────────────
+  let geoManager: any = null;
+  let geoDelegate: any = null;
+
+  bridge.register('geo.watch.start', () => {
+    if (!isIOS) throw iosOnly();
+    if (geoManager) return; // already streaming
+    const DelegateClass = (NSObject as any).extend(
+      {
+        locationManagerDidUpdateLocations(_m: CLLocationManager, locations: NSArray<CLLocation>) {
+          const loc = locations.lastObject;
+          if (!loc) return;
+          bridge.emit('geo.position', {
+            lat: loc.coordinate.latitude,
+            lng: loc.coordinate.longitude,
+            accuracy: loc.horizontalAccuracy,
+          });
+        },
+        locationManagerDidFailWithError(_m: CLLocationManager, error: NSError) {
+          console.warn('AppWrap: geo.watch error', error.localizedDescription);
+        },
+        locationManagerDidChangeAuthorization(m: CLLocationManager) {
+          const st = m.authorizationStatus;
+          if (st === CLAuthorizationStatus.kCLAuthorizationStatusAuthorizedWhenInUse ||
+              st === CLAuthorizationStatus.kCLAuthorizationStatusAuthorizedAlways) {
+            m.startUpdatingLocation();
+          }
+        },
+      },
+      { protocols: [CLLocationManagerDelegate] }
+    );
+    Utils.dispatchToMainThread(() => {
+      geoManager = CLLocationManager.new();
+      geoDelegate = DelegateClass.new();
+      geoManager.delegate = geoDelegate;
+      geoManager.desiredAccuracy = kCLLocationAccuracyHundredMeters;
+      const st = geoManager.authorizationStatus;
+      if (st === CLAuthorizationStatus.kCLAuthorizationStatusNotDetermined) {
+        geoManager.requestWhenInUseAuthorization();
+      } else {
+        geoManager.startUpdatingLocation();
+      }
+    });
+  });
+
+  bridge.register('geo.watch.stop', () => {
+    geoManager?.stopUpdatingLocation();
+    geoManager = null;
+    geoDelegate = null;
+  });
+
+  // ── motion (CMMotionManager) ───────────────────────────────────────
+  // Poll the latest sample on a JS timer rather than CoreMotion's queue-handler
+  // block: the repeated JS↔Obj-C block is fragile under NativeScript (the handler
+  // can silently stop firing on-device). startDeviceMotionUpdates() + reading
+  // `mm.deviceMotion` is a plain property read on the main thread — reliable.
+  let motionManager: any = null;
+  let motionTimer: any = null;
+
+  bridge.register('motion.start', () => {
+    if (!isIOS) throw iosOnly();
+    if (motionManager) return;
+    const mm = CMMotionManager.new();
+    if (!mm.deviceMotionAvailable) throw err('UNSUPPORTED', 'No motion sensors (simulator?)');
+    motionManager = mm;
+    mm.deviceMotionUpdateInterval = 0.1;
+    mm.startDeviceMotionUpdates();
+    const G = 9.81; // CoreMotion reports in g — kit contract is m/s²
+    motionTimer = setInterval(() => {
+      const m = mm.deviceMotion;
+      if (!m) return; // first sample not ready yet
+      bridge.emit('motion.data', {
+        ax: (m.userAcceleration.x + m.gravity.x) * G,
+        ay: (m.userAcceleration.y + m.gravity.y) * G,
+        az: (m.userAcceleration.z + m.gravity.z) * G,
+        rx: m.rotationRate.x,
+        ry: m.rotationRate.y,
+        rz: m.rotationRate.z,
+      });
+    }, 100);
+  });
+
+  bridge.register('motion.stop', () => {
+    if (motionTimer) clearInterval(motionTimer);
+    motionTimer = null;
+    motionManager?.stopDeviceMotionUpdates();
+    motionManager = null;
+  });
+
+  // ── contacts (CNContactPickerViewController — no permission needed) ──
+  bridge.register('contacts.pick', () => {
+    if (!isIOS) throw iosOnly();
+    return new Promise((resolve) => {
+      Utils.dispatchToMainThread(() => {
+        const DelegateClass = (NSObject as any).extend(
+          {
+            contactPickerDidSelectContact(_picker: any, contact: any) {
+              const collect = (labeled: NSArray<any>, map: (v: any) => string) => {
+                const out: string[] = [];
+                for (let i = 0; i < labeled.count; i++) out.push(map(labeled.objectAtIndex(i).value));
+                return out;
+              };
+              resolve({
+                picked: true,
+                name: `${contact.givenName ?? ''} ${contact.familyName ?? ''}`.trim(),
+                phones: collect(contact.phoneNumbers, (v) => String(v.stringValue)),
+                emails: collect(contact.emailAddresses, (v) => String(v)),
+              });
+            },
+            contactPickerDidCancel(picker: any) {
+              picker.dismissViewControllerAnimatedCompletion(true, null);
+              resolve({ picked: false });
+            },
+          },
+          { protocols: [CNContactPickerDelegate] }
+        );
+        const picker = CNContactPickerViewController.new();
+        const delegate = DelegateClass.new();
+        (picker as any)._appwrapDelegate = delegate; // retain
+        picker.delegate = delegate;
+        Utils.ios.getRootViewController().presentViewControllerAnimatedCompletion(picker, true, null);
+      });
+    });
+  });
+
+  // ── calendar (EventKit) ────────────────────────────────────────────
+  bridge.register('calendar.createEvent', ({ title, start, durationMin, notes }: any) => {
+    if (!isIOS) throw iosOnly();
+    const store = EKEventStore.new();
+    return new Promise((resolve, reject) => {
+      const onAccess = (granted: boolean, error: NSError | null) => {
+        if (!granted) {
+          return reject(err('DENIED', error?.localizedDescription ?? 'calendar access denied'));
+        }
+        Utils.dispatchToMainThread(() => {
+          try {
+            const event = EKEvent.eventWithEventStore(store);
+            event.title = String(title ?? 'Event');
+            const startDate = start
+              ? NSDate.dateWithTimeIntervalSince1970(Date.parse(start) / 1000)
+              : NSDate.dateWithTimeIntervalSinceNow(3600);
+            event.startDate = startDate;
+            event.endDate = startDate.dateByAddingTimeInterval((durationMin ?? 60) * 60);
+            if (notes) event.notes = String(notes);
+            event.calendar = store.defaultCalendarForNewEvents;
+            store.saveEventSpanError(event, EKSpan.ThisEvent, null as any);
+            resolve({ id: String(event.eventIdentifier) });
+          } catch (e: any) {
+            reject(err('NATIVE_ERROR', e.message));
+          }
+        });
+      };
+      // iOS 17 renamed the request API; fall back for older versions
+      if (store.requestFullAccessToEventsWithCompletion) {
+        store.requestFullAccessToEventsWithCompletion(onAccess);
+      } else {
+        store.requestAccessToEntityTypeCompletion(EKEntityType.Event, onAccess);
+      }
+    });
+  });
+
+  // ── camera capture (UIImagePickerController) ───────────────────────
+  bridge.register('camera.capture', ({ dataUrl, maxSize }: any = {}) => {
+    if (!isIOS) throw iosOnly();
+    if (!UIImagePickerController.isSourceTypeAvailable(UIImagePickerControllerSourceType.Camera)) {
+      throw err('UNSUPPORTED', 'No camera on this device (simulator?)');
+    }
+    return new Promise((resolve) => {
+      Utils.dispatchToMainThread(() => {
+        const DelegateClass = (NSObject as any).extend(
+          {
+            imagePickerControllerDidFinishPickingMediaWithInfo(picker: any, info: NSDictionary<string, any>) {
+              picker.dismissViewControllerAnimatedCompletion(true, null);
+              const img = info.objectForKey(UIImagePickerControllerOriginalImage) as UIImage | null;
+              if (!img) return resolve({ picked: true });
+              const out: any = { picked: true, width: img.size.width, height: img.size.height };
+              if (dataUrl) out.dataUrl = uiImageToDataUrl(img, maxSize ?? 1024);
+              resolve(out);
+            },
+            imagePickerControllerDidCancel(picker: any) {
+              picker.dismissViewControllerAnimatedCompletion(true, null);
+              resolve({ picked: false });
+            },
+          },
+          { protocols: [UIImagePickerControllerDelegate, UINavigationControllerDelegate] }
+        );
+        const picker = UIImagePickerController.new();
+        picker.sourceType = UIImagePickerControllerSourceType.Camera;
+        const delegate = DelegateClass.new();
+        (picker as any)._appwrapDelegate = delegate; // retain
+        picker.delegate = delegate;
+        Utils.ios.getRootViewController().presentViewControllerAnimatedCompletion(picker, true, null);
+      });
+    });
+  });
+}

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

@@ -0,0 +1,189 @@
+import { Application, Utils, isAndroid, isIOS } from '@nativescript/core';
+import { bridge } from './bridge';
+import { SHELL_CONFIG } from './config';
+
+/**
+ * Remote push (APNs/FCM) — DEVICE SIDE. Acquires the token + surfaces incoming
+ * messages/taps; the SEND backend is the consumer's (kit.push returns a raw token).
+ *
+ * iOS needs zero extra deps (UIApplication/UNUserNotificationCenter are baseline) — only the
+ * `aps-environment` entitlement, which the CLI stamps when `appwrap.json.push` is enabled (gated
+ * so it never breaks a personal-team build that can't hold the push entitlement).
+ *
+ * Android token/permission use Firebase Messaging classes guarded at runtime — present only when
+ * the FCM plugin + google-services.json are wired (CLI, gated). Incoming Android delivery
+ * (onMessage/onTap) needs a FirebaseMessagingService → lands with the messaging plugin (1b).
+ */
+
+// ── bridge the async iOS AppDelegate APNs callbacks back to a pending push.register() ──
+let pendingRegister: { resolve: (t: PushToken) => void; reject: (e: Error) => void } | null = null;
+let cachedToken: string | null = null;
+
+interface PushToken { platform: 'apns' | 'fcm'; token: string; }
+
+/** iOS AppDelegate → APNs device token arrived. Resolve any pending register() + cache. */
+export function onApnsToken(hexToken: string): void {
+  cachedToken = hexToken;
+  if (pendingRegister) {
+    pendingRegister.resolve({ platform: 'apns', token: hexToken });
+    pendingRegister = null;
+  }
+}
+
+/** iOS AppDelegate → APNs registration failed. */
+export function onApnsError(message: string): void {
+  if (pendingRegister) {
+    pendingRegister.reject(Object.assign(new Error(message), { code: 'NATIVE_ERROR' }));
+    pendingRegister = null;
+  }
+}
+
+/** iOS AppDelegate / UN delegate → a remote notification arrived (tapped = user opened it). */
+export function onRemoteMessage(userInfo: any, tapped: boolean): void {
+  bridge.emit(tapped ? 'push.tap' : 'push.message', parseApnsPayload(userInfo));
+}
+
+/** Android FirebaseMessagingService (fcm-service.android.ts) → a message arrived while the app
+ * process is alive. Forwarded as push.message (the foreground/data path; tray-notification taps come
+ * via events.ts → push.tap). */
+export function onFcmMessage(data: Record<string, string>, title?: string, body?: string): void {
+  bridge.emit('push.message', { data, title, body });
+}
+
+/** APNs userInfo (NSDictionary or auto-marshalled object) → { data, title?, body? }. */
+function parseApnsPayload(userInfo: any): { data: Record<string, unknown>; title?: string; body?: string } {
+  const data: Record<string, unknown> = {};
+  let title: string | undefined;
+  let body: string | undefined;
+  const get = (o: any, k: string) => (o && typeof o.objectForKey === 'function' ? o.objectForKey(k) : o?.[k]);
+  try {
+    const aps = get(userInfo, 'aps');
+    const alert = get(aps, 'alert');
+    if (alert) {
+      if (typeof alert === 'string') body = alert;
+      else { title = get(alert, 'title'); body = get(alert, 'body'); }
+    }
+    // Custom (non-aps) top-level keys → data.
+    const keys = userInfo?.allKeys;
+    if (keys?.count != null) {
+      for (let i = 0; i < keys.count; i++) {
+        const k = String(keys.objectAtIndex(i));
+        if (k !== 'aps') data[k] = String(userInfo.objectForKey(k));
+      }
+    } else if (userInfo && typeof userInfo === 'object') {
+      for (const k of Object.keys(userInfo)) if (k !== 'aps') data[k] = (userInfo as any)[k];
+    }
+  } catch {
+    /* best-effort parse — never throw on an inbound message */
+  }
+  return { data, title: title ? String(title) : undefined, body: body ? String(body) : undefined };
+}
+
+export function registerPushHandlers(): void {
+  bridge.register('push.requestPermission', () => {
+    if (isIOS) {
+      return new Promise<string>((resolve) => {
+        UNUserNotificationCenter.currentNotificationCenter().requestAuthorizationWithOptionsCompletionHandler(
+          UNAuthorizationOptions.Alert | UNAuthorizationOptions.Badge | UNAuthorizationOptions.Sound,
+          (granted) => resolve(granted ? 'granted' : 'denied')
+        );
+      });
+    }
+    if (isAndroid) return androidRequestPermission();
+    throw unsupported();
+  });
+
+  bridge.register('push.register', () => {
+    if (isIOS) {
+      return new Promise<PushToken>((resolve, reject) => {
+        if (cachedToken) return resolve({ platform: 'apns', token: cachedToken });
+        pendingRegister = { resolve, reject };
+        Utils.dispatchToMainThread(() => UIApplication.sharedApplication.registerForRemoteNotifications());
+        setTimeout(() => {
+          if (pendingRegister) {
+            pendingRegister.reject(Object.assign(new Error('APNs registration timed out'), { code: 'TIMEOUT' }));
+            pendingRegister = null;
+          }
+        }, 25_000);
+      });
+    }
+    if (isAndroid) return androidGetToken();
+    throw unsupported();
+  });
+
+  bridge.register('push.unregister', () => {
+    if (isIOS) {
+      Utils.dispatchToMainThread(() => UIApplication.sharedApplication.unregisterForRemoteNotifications());
+      cachedToken = null;
+      return;
+    }
+    if (isAndroid) return androidDeleteToken();
+  });
+
+  // Debug: auto-acquire + log the FCM token at boot so it's readable HEADLESSLY (adb logcat / appwrap
+  // logs) without a UI tap — the dev loop needs the token to send a test push. Android only (iOS push
+  // is off on personal teams); no-op when push isn't configured for this platform.
+  if (SHELL_CONFIG.debug && isAndroid && SHELL_CONFIG.pushAndroid) {
+    androidGetToken()
+      .then((t) => console.log('[push] FCM token: ' + t.token))
+      .catch((e) => console.log('[push] FCM token error: ' + (e?.message || e)));
+  }
+}
+
+function unsupported(): Error {
+  return Object.assign(new Error('push unsupported on this platform'), { code: 'UNSUPPORTED' });
+}
+
+// ── Android (Firebase Messaging) — guarded; classes exist only when FCM is wired ──
+function fcm(): any {
+  const FM = (global as any).com?.google?.firebase?.messaging?.FirebaseMessaging;
+  if (!FM) throw Object.assign(new Error('FCM not configured — wire google-services.json + the messaging plugin'), { code: 'UNSUPPORTED' });
+  return FM.getInstance();
+}
+
+function androidRequestPermission(): Promise<string> {
+  // Android 13+ (API 33) gates notifications behind POST_NOTIFICATIONS; below that it's implicit.
+  return new Promise((resolve) => {
+    try {
+      const ctx = Utils.android.getApplicationContext();
+      const sdk = android.os.Build.VERSION.SDK_INT;
+      if (sdk < 33) return resolve('granted');
+      const pm = android.content.pm.PackageManager;
+      const granted = ctx.checkSelfPermission('android.permission.POST_NOTIFICATIONS') === pm.PERMISSION_GRANTED;
+      if (granted) return resolve('granted');
+      const activity = Application.android.foregroundActivity || Application.android.startActivity;
+      Application.android.on(Application.android.activityRequestPermissionsEvent as any, (args: any) => {
+        if (args.requestCode !== 7613) return;
+        const ok = args.grantResults?.length && args.grantResults[0] === pm.PERMISSION_GRANTED;
+        resolve(ok ? 'granted' : 'denied');
+      });
+      activity.requestPermissions(['android.permission.POST_NOTIFICATIONS'], 7613);
+    } catch (e: any) {
+      resolve('denied');
+    }
+  });
+}
+
+function androidGetToken(): Promise<PushToken> {
+  return new Promise((resolve, reject) => {
+    try {
+      const OnCompleteListener = (global as any).com.google.android.gms.tasks.OnCompleteListener;
+      const task = fcm().getToken();
+      task.addOnCompleteListener(new OnCompleteListener({
+        onComplete(t: any) {
+          if (t.isSuccessful()) resolve({ platform: 'fcm', token: String(t.getResult()) });
+          else reject(Object.assign(new Error('FCM token fetch failed'), { code: 'NATIVE_ERROR' }));
+        },
+      }));
+    } catch (e: any) {
+      reject(e);
+    }
+  });
+}
+
+function androidDeleteToken(): Promise<void> {
+  return new Promise((resolve) => {
+    try { fcm().deleteToken(); } catch { /* best-effort */ }
+    resolve();
+  });
+}

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

@@ -0,0 +1,70 @@
+import { Application, Color, Utils, isAndroid, isIOS } from '@nativescript/core';
+import { bridge } from './bridge';
+
+declare const android: any, androidx: any;
+
+const err = (code: string, message: string) => Object.assign(new Error(message), { code });
+
+/**
+ * System / navigation handlers shared by both platforms (each method branches
+ * internally rather than relying on the iOS-first + Android-override split):
+ *   app.openUrl       — hand a URL to the OS default handler (leaves the app)
+ *   app.openSettings  — open this app's page in the OS Settings app
+ *   browser.open      — in-app browser (SFSafariViewController / Chrome Custom Tabs)
+ */
+export function registerSystemHandlers(): void {
+  bridge.register('app.openUrl', ({ url }: { url: string }) => {
+    const target = String(url ?? '');
+    if (!target) throw err('NATIVE_ERROR', 'app.openUrl: empty url');
+    if (isIOS) {
+      Utils.dispatchToMainThread(() => {
+        const nsUrl = NSURL.URLWithString(target);
+        UIApplication.sharedApplication.openURLOptionsCompletionHandler(nsUrl, NSDictionary.new() as any, null);
+      });
+    } else if (isAndroid) {
+      const intent = new android.content.Intent(
+        android.content.Intent.ACTION_VIEW,
+        android.net.Uri.parse(target)
+      );
+      intent.addFlags(android.content.Intent.FLAG_ACTIVITY_NEW_TASK);
+      Utils.android.getApplicationContext().startActivity(intent);
+    }
+  });
+
+  bridge.register('app.openSettings', () => {
+    if (isIOS) {
+      Utils.dispatchToMainThread(() => {
+        const nsUrl = NSURL.URLWithString(UIApplicationOpenSettingsURLString);
+        UIApplication.sharedApplication.openURLOptionsCompletionHandler(nsUrl, NSDictionary.new() as any, null);
+      });
+    } else if (isAndroid) {
+      const ctx = Utils.android.getApplicationContext();
+      const intent = new android.content.Intent(
+        android.provider.Settings.ACTION_APPLICATION_DETAILS_SETTINGS,
+        android.net.Uri.fromParts('package', ctx.getPackageName(), null)
+      );
+      intent.addFlags(android.content.Intent.FLAG_ACTIVITY_NEW_TASK);
+      ctx.startActivity(intent);
+    }
+  });
+
+  bridge.register('browser.open', ({ url, toolbarColor }: { url: string; toolbarColor?: string }) => {
+    const target = String(url ?? '');
+    if (!target) throw err('NATIVE_ERROR', 'browser.open: empty url');
+    if (isIOS) {
+      Utils.dispatchToMainThread(() => {
+        const vc = SFSafariViewController.alloc().initWithURL(NSURL.URLWithString(target));
+        if (toolbarColor) vc.preferredControlTintColor = new Color(String(toolbarColor)).ios;
+        Utils.ios.getRootViewController().presentViewControllerAnimatedCompletion(vc, true, null);
+      });
+    } else if (isAndroid) {
+      Utils.dispatchToMainThread(() => {
+        const builder = new androidx.browser.customtabs.CustomTabsIntent.Builder();
+        if (toolbarColor) builder.setToolbarColor(new Color(String(toolbarColor)).android);
+        const tabs = builder.build();
+        const activity = Application.android.foregroundActivity ?? Application.android.startActivity;
+        tabs.launchUrl(activity, android.net.Uri.parse(target));
+      });
+    }
+  });
+}