@livx.cc/appwrap 0.61.9 → 0.61.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@livx.cc/appwrap",
-  "version": "0.61.9",
+  "version": "0.61.11",
   "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/shell/capabilities.manifest.ts

@@ -83,9 +83,11 @@ export const MODULES: ModuleManifest[] = [
   // `shareFiles` hands a file to the OS sheet, and one of the activities the sheet offers for a
   // photo or video is "Save Image"/"Save Video" — which WRITES to the camera roll. iOS omits that
   // activity SILENTLY when the app carries no add-only photo-library usage string, so the sheet
-  // appears correct and simply lacks the one row the person was reaching for.
+  // appears correct and simply lacks the one row the person was reaching for. `saveToPhotos` writes
+  // straight to the library under that SAME add-only string — why it lives here and not in `photos`
+  // (which is opt-in and asks for READ access).
   {
-    name: 'share', core: true, group: 'core', capabilities: { share: 'native', shareFiles: 'native' },
+    name: 'share', core: true, group: 'core', capabilities: { share: 'native', shareFiles: 'native', saveToPhotos: 'native' },
     ios: { permissions: [{ key: 'NSPhotoLibraryAddUsageDescription', domain: 'photosAdd', defaultUsage: 'Save a photo or video you chose to your library.' }] },
   },
   { name: 'storage', core: true, group: 'core', capabilities: { storage: 'native', secureStorage: 'native' } },

package/runtime/app/shell/events.ts

@@ -4,12 +4,15 @@ import { bridge } from './bridge';
 import { connectivityStatus } from './handlers-extended';
 import { isEnvDeepLink, handleEnvDeepLink } from './env-switcher';
 
+/** A notification-tap payload as the PWA receives it (`parseApnsPayload` / the FCM intent extras). */
+export type PushTapPayload = { data: Record<string, unknown>; title?: string; body?: string };
+
 let pendingDeepLink: string | null = null;
 // A cold-launch env-switch deep link (`<scheme>://env?url=…`). Buffered like `pendingDeepLink` until the
 // PWA handshake, so the confirm dialog + WebView reload run when the shell is actually ready (not during
 // iOS didFinishLaunching / the Android launch-intent read, when no WebView exists yet).
 let pendingEnvDeepLink: string | null = null;
-let pendingPushTap: { data: Record<string, string> } | null = null;
+let pendingPushTap: PushTapPayload | 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:
@@ -81,10 +84,15 @@ export function onShortcut(id: string): void {
   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). */
-export function onPushTap(payload: { data: Record<string, string> }): void {
+/** A tray notification was tapped → the app was re-launched (or foregrounded) with the payload.
+ * Buffered until the handshake like deep links, because a cold start from a notification fires this
+ * before the WebView is running our bundle — emit it raw and the route is lost, the PWA boots at `/`
+ * and an authed user lands on the app's home list instead of the conversation.
+ *
+ * BOTH platforms route through here: Android from the launch intent, iOS from the
+ * UNUserNotificationCenter delegate (handlers-push `onRemoteMessage`, tapped=true). iOS used to
+ * `bridge.emit` directly and so had no cold-start buffering at all. */
+export function onPushTap(payload: PushTapPayload): void {
   if (pwaReady) bridge.emit('push.tap', payload);
   else pendingPushTap = payload;
 }

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

@@ -2,6 +2,7 @@ import { Application, Utils } from '@nativescript/core';
 import { bridge } from './bridge';
 import { requestPermissions, startActivityForResult, uriToDataUrl, bitmapToDataUrl } from './android-helpers';
 import { notifIdentity, notifActions } from './notif-identity';
+import { photoAssetKind } from './share-outcome';
 
 // no NS types: android-32 typings omit ContactsContract/MediaStore column + ACTION_PICK_IMAGES constants this file reads
 declare const android: any, androidx: any;
@@ -585,6 +586,40 @@ export function registerAndroidHandlers(): void {
     ctx.startActivity(chooser);
   });
 
+  // ── save to Photos (MediaStore insert into Pictures/ or Movies/) ─────
+  // API 29+ scoped storage needs NO permission to add media the app creates. Older devices would need
+  // WRITE_EXTERNAL_STORAGE, which the template does not request — reported as unsupported, not faked.
+  bridge.register('share.saveToPhotos', ({ name, mimeType, base64 }: { name?: string; mimeType?: string; base64: string }) => {
+    const kind = photoAssetKind(mimeType, name);
+    if (!kind) return { saved: false, reason: 'unsupported', message: 'only photos and videos can be saved to Photos' };
+    if (android.os.Build.VERSION.SDK_INT < 29) return { saved: false, reason: 'unsupported', message: 'needs Android 10 or later' };
+    const MS = android.provider.MediaStore;
+    const resolver = context().getContentResolver();
+    const collection = kind === 'video'
+      ? MS.Video.Media.getContentUri(MS.VOLUME_EXTERNAL_PRIMARY)
+      : MS.Images.Media.getContentUri(MS.VOLUME_EXTERNAL_PRIMARY);
+    const values = new android.content.ContentValues();
+    values.put('_display_name', String(name || (kind === 'video' ? 'video.mp4' : 'photo.jpg')));
+    if (mimeType) values.put('mime_type', String(mimeType));
+    values.put('relative_path', kind === 'video' ? 'Movies' : 'Pictures');
+    values.put('is_pending', new java.lang.Integer(1));
+    let uri: any = null;
+    try {
+      uri = resolver.insert(collection, values);
+      if (!uri) return { saved: false, reason: 'failed', message: 'MediaStore refused the file' };
+      const out = resolver.openOutputStream(uri);
+      out.write(android.util.Base64.decode(base64 ?? '', android.util.Base64.DEFAULT));
+      out.close();
+      const done = new android.content.ContentValues();
+      done.put('is_pending', new java.lang.Integer(0));
+      resolver.update(uri, done, null, null);
+      return { saved: true };
+    } catch (e) {
+      if (uri) try { resolver.delete(uri, null, null); } catch { /* best-effort cleanup */ }
+      return { saved: false, reason: 'failed', message: String((e as Error)?.message ?? e) };
+    }
+  });
+
   // ── screen orientation (Activity.setRequestedOrientation) ──────────
   const SO = android.content.pm.ActivityInfo;
   const requestedOrientation = (o: string): number => {

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

@@ -1,6 +1,7 @@
 import { Application, Http, Utils, isAndroid, isIOS } from '@nativescript/core';
 import { bridge } from './bridge';
 import { SHELL_CONFIG } from './config';
+import { onPushTap } from './events';
 
 /**
  * Remote push (APNs/FCM) — DEVICE SIDE. Acquires the token + surfaces incoming
@@ -75,9 +76,16 @@ export function onApnsError(message: string): void {
   }
 }
 
-/** iOS AppDelegate / UN delegate → a remote notification arrived (tapped = user opened it). */
+/** iOS AppDelegate / UN delegate → a remote notification arrived (tapped = user opened it).
+ *
+ * A TAP goes through `onPushTap` rather than `bridge.emit` so it is buffered until the PWA
+ * handshake. A tap that LAUNCHES the app fires from the UN delegate while the WebView has not yet
+ * loaded our bundle, so a raw emit reaches no listener and the route is dropped — the app opens on
+ * its home screen instead of the notification's target. Android already went through that gate. */
 export function onRemoteMessage(userInfo: any, tapped: boolean): void { // any: APNs userInfo is NSDictionary or auto-marshalled JS object (dual-path)
-  bridge.emit(tapped ? 'push.tap' : 'push.message', parseApnsPayload(userInfo));
+  const payload = parseApnsPayload(userInfo);
+  if (tapped) onPushTap(payload);
+  else bridge.emit('push.message', payload);
 }
 
 /** Android FirebaseMessagingService (fcm-service.android.ts) → a message arrived while the app

package/runtime/app/shell/handlers.ts

@@ -8,10 +8,14 @@ import { setStatusBarStyle } from './status-bar';
 import { buildCapabilityMap } from './capabilities.manifest';
 import { ACTIVE_MODULE_NAMES, PACK_MODULES } from './active-modules.generated';
 import { consumePendingBackgroundTaskId } from './background-context';
-import { settleShare, type ShareOutcome } from './share-outcome';
+import { settleShare, photoAssetKind, type ShareOutcome, type SaveToPhotosOutcome } from './share-outcome';
+import { appwrapNativeLog } from './native-log';
+
+/** Debug-only native diagnostic line → Documents/appwrap-web.log (`appwrap logs ios`). */
+const dlog = (line: string) => { if (SHELL_CONFIG.debug) appwrapNativeLog(line); };
 
 /** Build identifier for the native shell bundle — bump per deploy to spot stale bundles. */
-export const SHELL_BUILD = 'share-target-1';
+export const SHELL_BUILD = 'save-to-photos-1';
 
 /** Version status the web side (native-kit `kit.updates`) reports via `app.reportWebVersion`. */
 export interface WebVersionInfo { current?: string; latest?: string; build?: string | number; updateAvailable?: boolean; }
@@ -36,10 +40,12 @@ function presentShareSheet(items: NSMutableArray<any>): Promise<ShareOutcome> {
     const finish = (o: ShareOutcome | null) => {
       if (done || !o) return;
       done = true;
+      dlog(`[native:share] resolve ${JSON.stringify(o)}`);
       resolve(o);
     };
-    const presented = () => !!controller.presentingViewController && !controller.isBeingDismissed;
+    const presented = () => !!controller.presentingViewController && !controller.beingDismissed;
     controller.completionWithItemsHandler = (activityType: string, completed: boolean) => {
+      dlog(`[native:share] completion activity=${activityType} completed=${!!completed} presented=${presented()}`);
       // Recover the WebView on dismiss — a presented sheet can orphan a touch-stealing window / leave
       // the renderer throttled (see CustomWebView.recoverAfterNativeSurface).
       bridge.getWebView()?.recoverAfterNativeSurface();
@@ -152,6 +158,44 @@ export function registerHandlers(): void {
     }
   );
 
+  // SAVE TO PHOTOS — write straight into the library, no sheet. The "Save" a camera app offers is
+  // this, not a share sheet with a Save row among twenty others. Add-only access (the same
+  // NSPhotoLibraryAddUsageDescription the share module already stamps), so the person is never asked
+  // to expose their library just to receive one clip. Resolves { saved } — a refusal is a value, not
+  // a throw, so the caller can say something honest. Android overrides this in handlers-android.
+  bridge.register(
+    'share.saveToPhotos',
+    ({ name, mimeType, base64 }: { name?: string; mimeType?: string; base64: string }): Promise<SaveToPhotosOutcome> | SaveToPhotosOutcome => {
+      const kind = photoAssetKind(mimeType, name);
+      if (!isIOS || !kind) return { saved: false, reason: 'unsupported', message: kind ? 'no photo library here' : 'only photos and videos can be saved to Photos' };
+      return new Promise((resolve) => {
+        PHPhotoLibrary.requestAuthorizationForAccessLevelHandler(PHAccessLevel.AddOnly, (status) => {
+          dlog(`[native:photos] add-only authorization status=${status}`);
+          // Authorized = 3, Limited = 4. Limited still permits adding.
+          if (status !== 3 && status !== 4) return resolve({ saved: false, reason: 'denied', message: 'Photos access is off for this app' });
+          const data = NSData.alloc().initWithBase64EncodedStringOptions(base64 ?? '', 0 as unknown as NSDataBase64DecodingOptions);
+          if (!data) return resolve({ saved: false, reason: 'failed', message: 'could not read that file' });
+          // A real extension matters: Photos sniffs the container from the file URL.
+          const ext = (String(name ?? '').match(/\.[A-Za-z0-9]+$/)?.[0]) ?? (kind === 'video' ? '.mp4' : '.jpg');
+          const filePath = NSTemporaryDirectory() + 'save-' + Date.now() + ext;
+          if (!data.writeToFileAtomically(filePath, true)) return resolve({ saved: false, reason: 'failed', message: 'could not stage that file' });
+          const url = NSURL.fileURLWithPath(filePath);
+          PHPhotoLibrary.sharedPhotoLibrary().performChangesCompletionHandler(
+            () => {
+              PHAssetCreationRequest.creationRequestForAsset().addResourceWithTypeFileURLOptions(
+                kind === 'video' ? PHAssetResourceType.Video : PHAssetResourceType.Photo, url, null);
+            },
+            (ok, error) => {
+              NSFileManager.defaultManager.removeItemAtPathError(filePath);
+              dlog(`[native:photos] save ${kind} ok=${ok}${error ? ' err=' + error.localizedDescription : ''}`);
+              resolve(ok ? { saved: true } : { saved: false, reason: 'failed', message: error?.localizedDescription || 'Photos refused that file' });
+            }
+          );
+        });
+      });
+    }
+  );
+
   bridge.register('storage.get', ({ key }: { key: string }) =>
     JSON.parse(ApplicationSettings.getString(`kit:${key}`, 'null'))
   );
@@ -162,9 +206,10 @@ export function registerHandlers(): void {
     ApplicationSettings.remove(`kit:${key}`)
   );
 
-  bridge.register('toast.show', ({ message, duration }: { message: string; duration?: 'short' | 'long' }) =>
-    showToast(String(message ?? ''), duration ?? 'short')
-  );
+  bridge.register('toast.show', ({ message, duration }: { message: string; duration?: 'short' | 'long' }) => {
+    dlog(`[native:toast] show "${message}" presentedOver=${isIOS ? !!Utils.ios.getRootViewController()?.presentedViewController : "n/a"}`);
+    return showToast(String(message ?? ''), duration ?? 'short');
+  });
 
   // Persistent, tappable banner (e.g. the remote-update "tap to reload" prompt). Tap emits
   // `toast.action` { id } back to the web side.

package/runtime/app/shell/share-outcome.ts

@@ -19,3 +19,24 @@ export function settleShare(
   if (completed) return activityType ? { completed: true, activity: String(activityType) } : { completed: true };
   return sheetStillPresented ? null : { completed: false };
 }
+
+/** What `share.saveToPhotos` resolves with (native-kit `SaveToPhotosResult`). `saved:false` is never a
+ * throw: `reason` says why — 'denied' (the person refused, or Settings forbids it: only they can change
+ * it), 'unsupported' (not an image/video, or no handler on this platform), 'failed' (the write itself). */
+export interface SaveToPhotosOutcome {
+  saved: boolean;
+  reason?: 'denied' | 'unsupported' | 'failed';
+  message?: string;
+}
+
+/** Which photo-library asset a file becomes — by mime type, then by extension. `null` = neither (a
+ * library only holds photos and videos; a PDF must go through the share sheet instead). */
+export function photoAssetKind(mimeType?: string, name?: string): 'image' | 'video' | null {
+  const m = String(mimeType ?? '').toLowerCase();
+  if (m.startsWith('image/')) return 'image';
+  if (m.startsWith('video/')) return 'video';
+  const ext = String(name ?? '').toLowerCase().split('.').pop() ?? '';
+  if (['jpg', 'jpeg', 'png', 'heic', 'heif', 'gif', 'webp'].includes(ext)) return 'image';
+  if (['mp4', 'mov', 'm4v'].includes(ext)) return 'video';
+  return null;
+}

package/runtime/app/shell/toast.ts

@@ -41,7 +41,10 @@ function showIOSToast(message: string, durationMs: number): void {
   const screenBounds = UIScreen.mainScreen.bounds;
   containerView.center = CGPointMake(screenBounds.size.width / 2, screenBounds.size.height - 120);
 
-  rootVC.view.addSubview(containerView);
+  // Onto the WINDOW, not the root view: a toast that reports how a sheet ended is shown while that
+  // sheet may still be presented (or animating out), and the root view sits BELOW every presented
+  // controller — the toast would render, underneath, and be gone before the sheet was.
+  (rootVC.view.window ?? rootVC.view).addSubview(containerView);
   containerView.alpha = 0;
   containerView.transform = CGAffineTransformMakeScale(0.8, 0.8);
 

package/runtime/tests/bridge-response-delivery.test.ts

@@ -4,6 +4,7 @@ import { beforeEach, describe, expect, mock, test } from 'bun:test';
 // Superset shape — bun shares the runtime-module cache across files in a dir run, so every
 // @nativescript/core mock must expose the same named exports the runtime modules import.
 mock.module('@nativescript/core', () => ({
+  Http: { request: async () => ({ content: null }) },
   isIOS: false, isAndroid: false, WebView: class {},
   ApplicationSettings: { getString: (_k: string, d = '') => d, setString: () => {}, remove: () => {} },
   Dialogs: { confirm: async () => true, action: async () => '', alert: async () => undefined, prompt: async () => ({ result: false, text: '' }) },

package/runtime/tests/env-scheme.test.ts

@@ -10,6 +10,7 @@ import { afterEach, describe, expect, mock, test } from 'bun:test';
 // which throws-and-falls-back off-device — safe to stub minimally).
 let androidFlag = false;
 mock.module('@nativescript/core', () => ({
+  Http: { request: async () => ({ content: null }) },
   Application: { android: {} },
   get isAndroid() { return androidFlag; },
   isIOS: false,

package/runtime/tests/share-outcome.test.ts

@@ -25,3 +25,20 @@ describe('settleShare', () => {
     expect(settleShare('com.apple.UIKit.activity.Mail', false, true)).toBeNull();
   });
 });
+
+import { photoAssetKind } from '../app/shell/share-outcome';
+
+describe('photoAssetKind', () => {
+  test('mime type decides first', () => {
+    expect(photoAssetKind('video/mp4', 'x.png')).toBe('video');
+    expect(photoAssetKind('image/png')).toBe('image');
+  });
+  test('falls back to the extension when the mime type is generic', () => {
+    expect(photoAssetKind('application/octet-stream', 'clip.MOV')).toBe('video');
+    expect(photoAssetKind('', 'shot.jpeg')).toBe('image');
+  });
+  test('anything else is not a photo-library asset', () => {
+    expect(photoAssetKind('application/pdf', 'a.pdf')).toBeNull();
+    expect(photoAssetKind(undefined, undefined)).toBeNull();
+  });
+});