@livx.cc/appwrap 0.23.2 → 0.25.0

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

@@ -0,0 +1,222 @@
+import { Utils, isAndroid, isIOS } from '@nativescript/core';
+import { bridge } from './bridge';
+import { requestPermissions, startActivityForResult } from './android-helpers';
+
+// AVFoundation / UIKit globals (NS auto-links the frameworks via metadata when referenced).
+declare const AVCaptureSession: any;
+declare const AVCaptureDevice: any;
+declare const AVCaptureDeviceInput: any;
+declare const AVCaptureMetadataOutput: any;
+declare const AVCaptureVideoPreviewLayer: any;
+declare const AVMetadataObjectTypeQRCode: any;
+declare const AVMetadataObjectTypeEAN13Code: any;
+declare const AVMetadataObjectTypeCode128Code: any;
+declare const AVLayerVideoGravityResizeAspectFill: any;
+declare const AVCaptureDevicePositionFront: any;
+declare const AVCaptureDevicePositionBack: any;
+declare const AVCaptureDeviceDiscoverySession: any;
+declare const AVMediaTypeVideo: any;
+declare const AVCaptureDeviceTypeBuiltInWideAngleCamera: any;
+declare const AVCaptureMetadataOutputObjectsDelegate: any;
+// `dispatch_get_main_queue()` is a C macro, NOT a bridged symbol — NativeScript can't see it
+// ("is not defined" at runtime). `dispatch_queue_create` IS a real bridged libdispatch function;
+// a dedicated serial queue is the correct delegate queue for AVCaptureMetadataOutput anyway.
+declare function dispatch_queue_create(label: string, attr: any): any;
+declare const android: any, com: any;
+
+const err = (code: string, message: string) => Object.assign(new Error(message), { code });
+
+/**
+ * Camera barcode / QR decoding. iOS: AVCaptureMetadataOutput in a full-screen capture VC presented
+ * over the WebView; first machine-readable code → stop session, dismiss, resolve. Android: ZXing's
+ * own capture Activity (zxing-android-embedded) launched via startActivityForResult.
+ *
+ * Contract: `scanner.scan` resolves `{ value, format, bounds? }` on first decode, or
+ * `{ cancelled: true }` if the user dismisses (or `scanner.cancel` fires). It never rejects on a
+ * plain cancel — only on a hard failure (no camera, permission denied at the OS level).
+ */
+export function registerScannerHandlers(): void {
+  if (isIOS) registerIos();
+  else if (isAndroid) registerAndroid();
+}
+
+/** Map our small enum → the platform metadata-object types. Empty/`all` = the full supported set. */
+function iosFormatTypes(formats: any): any[] {
+  const all = [AVMetadataObjectTypeQRCode, AVMetadataObjectTypeEAN13Code, AVMetadataObjectTypeCode128Code];
+  const want = Array.isArray(formats) ? formats : formats ? [formats] : [];
+  const sel = want.filter((f: string) => f && f !== 'all');
+  if (!sel.length) return all;
+  const map: Record<string, any> = {
+    qr: AVMetadataObjectTypeQRCode,
+    ean13: AVMetadataObjectTypeEAN13Code,
+    code128: AVMetadataObjectTypeCode128Code,
+  };
+  return sel.map((f: string) => map[f]).filter(Boolean);
+}
+
+function iosFormatName(type: any): string {
+  if (type === AVMetadataObjectTypeQRCode) return 'qr';
+  if (type === AVMetadataObjectTypeEAN13Code) return 'ean13';
+  if (type === AVMetadataObjectTypeCode128Code) return 'code128';
+  return 'unknown';
+}
+
+function registerIos(): void {
+  // Strong refs while the scanner is up — ARC would otherwise free the session/VC/delegate the moment
+  // the JS locals fall out of scope, killing capture mid-stream (same hazard as handlers-oauth).
+  let activeSession: any = null;
+  let activeVC: any = null;
+  let activeDelegate: any = null;
+  let pending: { resolve: (v: any) => void } | null = null;
+
+  const dismiss = () => {
+    Utils.dispatchToMainThread(() => {
+      try { activeSession?.stopRunning(); } catch { /* already stopped */ }
+      activeVC?.dismissViewControllerAnimatedCompletion(true, null);
+      activeSession = null;
+      activeVC = null;
+      activeDelegate = null;
+    });
+  };
+
+  const settle = (value: any) => {
+    const p = pending;
+    pending = null;
+    dismiss();
+    // The metadata delegate now fires on a background serial queue; the bridge reply drives
+    // WKWebView.evaluateJavaScript, which must run on the main thread — so hop back to resolve.
+    Utils.dispatchToMainThread(() => p?.resolve(value));
+  };
+
+  bridge.register('scanner.cancel', () => { if (pending) settle({ cancelled: true }); });
+
+  bridge.register('scanner.scan', (params: any) =>
+    new Promise((resolve, reject) => {
+      if (pending) { reject(err('NATIVE_ERROR', 'scanner.scan: a scan is already in progress')); return; }
+      pending = { resolve };
+
+      Utils.dispatchToMainThread(() => {
+        try {
+          const wantFront = params?.camera === 'front';
+          const position = wantFront ? AVCaptureDevicePositionFront : AVCaptureDevicePositionBack;
+          const discovery = AVCaptureDeviceDiscoverySession.discoverySessionWithDeviceTypesMediaTypePosition(
+            [AVCaptureDeviceTypeBuiltInWideAngleCamera], AVMediaTypeVideo, position
+          );
+          const device = discovery?.devices?.firstObject ?? AVCaptureDevice.defaultDeviceWithMediaType(AVMediaTypeVideo);
+          if (!device) { pending = null; reject(err('UNSUPPORTED', 'No camera available')); return; }
+
+          const input = AVCaptureDeviceInput.deviceInputWithDeviceError(device, null);
+          if (!input) { pending = null; reject(err('NATIVE_ERROR', 'Cannot open camera input')); return; }
+
+          const session = AVCaptureSession.new();
+          if (!session.canAddInput(input)) { pending = null; reject(err('NATIVE_ERROR', 'Cannot add camera input')); return; }
+          session.addInput(input);
+
+          const output = AVCaptureMetadataOutput.new();
+          if (!session.canAddOutput(output)) { pending = null; reject(err('NATIVE_ERROR', 'Cannot add metadata output')); return; }
+          session.addOutput(output);
+
+          // Delegate fires on a dedicated serial queue (see dispatch_queue_create below); settle()
+          // hops back to the main thread for the WKWebView bridge reply.
+          const DelegateClass = (NSObject as any).extend(
+            {
+              captureOutputDidOutputMetadataObjectsFromConnection(_out: any, objects: any, _conn: any) {
+                if (!pending) return;
+                const obj = objects?.firstObject;
+                const value = obj?.stringValue;
+                if (value == null) return;
+                settle({ value: String(value), format: iosFormatName(obj.type) });
+              },
+            },
+            // The protocol MUST be declared: NativeScript uses it to map the camelCase JS method to the
+            // colonated selector `captureOutput:didOutputMetadataObjects:fromConnection:`. With an empty
+            // protocols list the method registers under the wrong selector and AVFoundation never calls
+            // it — the scanner opens but never decodes.
+            { protocols: [AVCaptureMetadataOutputObjectsDelegate] }
+          );
+          activeDelegate = DelegateClass.new();
+          output.setMetadataObjectsDelegateQueue(activeDelegate, dispatch_queue_create('cc.livx.scanner.metadata', null));
+          // metadataObjectTypes must be set AFTER addOutput (the available set is session-derived).
+          output.metadataObjectTypes = iosFormatTypes(params?.formats) as any;
+
+          const vc = UIViewController.new();
+          const preview = AVCaptureVideoPreviewLayer.layerWithSession(session);
+          preview.videoGravity = AVLayerVideoGravityResizeAspectFill;
+          preview.frame = vc.view.bounds;
+          vc.view.layer.addSublayer(preview);
+
+          // Cancel button so the user can dismiss without a successful read.
+          const btn = UIButton.buttonWithType(0 /* UIButtonTypeCustom */);
+          btn.setTitleForState('Cancel', 0 /* UIControlStateNormal */);
+          btn.frame = CGRectMake(16, 56, 100, 40);
+          const Target = (NSObject as any).extend(
+            { tap() { if (pending) settle({ cancelled: true }); } },
+            { exposedMethods: { tap: { returns: interop.types.void } } }
+          );
+          activeVC = vc;
+          (vc as any)._cancelTarget = Target.new(); // retain via the (also-retained) VC
+          btn.addTargetActionForControlEvents((vc as any)._cancelTarget, 'tap', 1 << 6 /* TouchUpInside */);
+          vc.view.addSubview(btn);
+
+          activeSession = session;
+          session.startRunning();
+
+          const root = Utils.ios.getRootViewController();
+          vc.modalPresentationStyle = 0; // fullScreen
+          root.presentViewControllerAnimatedCompletion(vc, true, null);
+        } catch (e: any) {
+          pending = null;
+          reject(err('NATIVE_ERROR', e?.message ?? 'scanner failed to start'));
+        }
+      });
+    })
+  );
+}
+
+function registerAndroid(): void {
+  // ZXing-android-embedded ships its own capture Activity (CaptureActivity). We build the launch
+  // Intent via IntentIntegrator, run it through startActivityForResult, and parse the result —
+  // no hand-built Camera2 preview. IntentResult carries the decoded text + format name.
+  const formatName = (zxingName: string): string => {
+    const n = String(zxingName ?? '').toUpperCase();
+    if (n === 'QR_CODE') return 'qr';
+    if (n === 'EAN_13') return 'ean13';
+    if (n === 'CODE_128') return 'code128';
+    return 'unknown';
+  };
+
+  bridge.register('scanner.cancel', () => {
+    // The ZXing capture Activity owns its own back/up dismissal; there's no in-process handle to it
+    // once launched. Cancel is honored by the user pressing back, which returns a null-contents result.
+  });
+
+  bridge.register('scanner.scan', async (params: any) => {
+    const granted = await requestPermissions(['android.permission.CAMERA']);
+    if (!granted) throw err('DENIED', 'Camera permission denied');
+
+    const activity = Utils.android.getCurrentActivity?.() ?? undefined;
+    const integrator = activity
+      ? new com.google.zxing.integration.android.IntentIntegrator(activity)
+      : new com.google.zxing.integration.android.IntentIntegrator(Utils.android.getApplicationContext());
+
+    // Restrict to our format set (or all). IntentIntegrator names match ZXing BarcodeFormat names.
+    const want = Array.isArray(params?.formats) ? params.formats : params?.formats ? [params.formats] : [];
+    const sel = want.filter((f: string) => f && f !== 'all');
+    if (sel.length) {
+      const map: Record<string, string> = { qr: 'QR_CODE', ean13: 'EAN_13', code128: 'CODE_128' };
+      const list = new java.util.ArrayList();
+      sel.forEach((f: string) => { const z = map[f]; if (z) list.add(z); });
+      if (list.size()) integrator.setDesiredBarcodeFormats(list);
+    }
+    integrator.setBeepEnabled(false);
+    integrator.setOrientationLocked(false);
+
+    const intent = integrator.createScanIntent();
+    const { resultCode, intent: data } = await startActivityForResult(intent);
+
+    const result = com.google.zxing.integration.android.IntentIntegrator.parseActivityResult(resultCode, data);
+    const contents = result?.getContents?.();
+    if (contents == null) return { cancelled: true }; // user backed out
+    return { value: String(contents), format: formatName(result.getFormatName?.()) };
+  });
+}

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

@@ -0,0 +1,336 @@
+import { Utils, isAndroid, isIOS } from '@nativescript/core';
+import { bridge } from './bridge';
+import { requestPermissions } from './android-helpers';
+
+// AVFoundation / Speech globals (NS auto-links the frameworks via metadata when referenced).
+declare const AVSpeechSynthesizer: any;
+declare const AVSpeechUtterance: any;
+declare const AVSpeechSynthesisVoice: any;
+declare const AVAudioEngine: any;
+declare const AVAudioSession: any;
+declare const AVAudioSessionCategoryPlayAndRecord: any;
+declare const AVAudioSessionModeMeasurement: any;
+declare const SFSpeechRecognizer: any;
+declare const SFSpeechAudioBufferRecognitionRequest: any;
+declare const SFSpeechRecognizerAuthorizationStatusAuthorized: any;
+declare const NSLocale: any;
+declare const android: any;
+declare const java: any;
+
+const err = (code: string, message: string) => Object.assign(new Error(message), { code });
+
+/**
+ * Voice I/O. TTS: iOS AVSpeechSynthesizer / Android TextToSpeech — speak resolves on finish.
+ * STT: iOS SFSpeechRecognizer + AVAudioEngine mic tap / Android SpeechRecognizer — listen resolves
+ * the FINAL transcript; partials emit `speech.partial` while listening; stopListening resolves with
+ * the best-so-far transcript.
+ *
+ * DEVICE-UNVERIFIED (any-typed FFI, no device run this session): the iOS AVAudioEngine tap +
+ * SFSpeechRecognizer authorization/lifecycle, and the Android SpeechRecognizer onResults/
+ * onPartialResults threading + TextToSpeech init race. Compile-clean only.
+ */
+export function registerSpeechHandlers(): void {
+  if (isIOS) registerIos();
+  else if (isAndroid) registerAndroid();
+}
+
+function registerIos(): void {
+  // Strong refs while a session is live — ARC would otherwise free the synthesizer/engine/delegate
+  // the moment the JS locals fall out of scope (same hazard as handlers-scanner/oauth).
+  let synth: any = null;
+  let speakDelegate: any = null;
+  let speakPending: { resolve: () => void } | null = null;
+
+  let engine: any = null;
+  let recognizer: any = null;
+  let request: any = null;
+  let task: any = null;
+  let listenPending: { resolve: (v: string) => void; reject: (e: any) => void } | null = null;
+  let best = '';
+
+  const teardownListen = () => {
+    try { task?.cancel?.(); } catch { /* noop */ }
+    try { request?.endAudio?.(); } catch { /* noop */ }
+    try {
+      engine?.inputNode?.removeTapOnBus?.(0);
+      engine?.stop?.();
+    } catch { /* noop */ }
+    task = null; request = null; engine = null;
+  };
+
+  const settleListen = () => {
+    const p = listenPending;
+    listenPending = null;
+    teardownListen();
+    p?.resolve(best);
+  };
+
+  bridge.register('speech.speak', (params: any) =>
+    new Promise<void>((resolve, reject) => {
+      Utils.dispatchToMainThread(() => {
+        try {
+          if (!synth) {
+            synth = AVSpeechSynthesizer.new();
+            const DelegateClass = (NSObject as any).extend(
+              {
+                speechSynthesizerDidFinishSpeechUtterance(_s: any, _u: any) {
+                  const p = speakPending; speakPending = null; p?.resolve();
+                },
+                speechSynthesizerDidCancelSpeechUtterance(_s: any, _u: any) {
+                  const p = speakPending; speakPending = null; p?.resolve();
+                },
+              },
+              { protocols: [] }
+            );
+            speakDelegate = DelegateClass.new();
+            synth.delegate = speakDelegate;
+          }
+          // A new speak resolves any prior pending (its utterance is being superseded).
+          speakPending?.resolve();
+          const u = AVSpeechUtterance.speechUtteranceWithString(String(params?.text ?? ''));
+          if (params?.voice) {
+            const v = AVSpeechSynthesisVoice.voiceWithIdentifier(String(params.voice));
+            if (v) u.voice = v;
+          } else if (params?.lang) {
+            const v = AVSpeechSynthesisVoice.voiceWithLanguage(String(params.lang));
+            if (v) u.voice = v;
+          }
+          if (params?.rate != null) u.rate = Number(params.rate) * AVSpeechUtterance.alloc().rate; // relative scale
+          if (params?.pitch != null) u.pitchMultiplier = Number(params.pitch);
+          speakPending = { resolve };
+          synth.speakUtterance(u);
+        } catch (e: any) {
+          reject(err('NATIVE_ERROR', e?.message ?? 'speak failed'));
+        }
+      });
+    })
+  );
+
+  bridge.register('speech.stop', () => {
+    Utils.dispatchToMainThread(() => {
+      try { synth?.stopSpeakingAtBoundary?.(0 /* immediate */); } catch { /* noop */ }
+      const p = speakPending; speakPending = null; p?.resolve();
+    });
+  });
+
+  bridge.register('speech.voices', () => {
+    const voices = AVSpeechSynthesisVoice.speechVoices();
+    const out: Array<{ id: string; name: string; lang: string }> = [];
+    const n = voices?.count ?? 0;
+    for (let i = 0; i < n; i++) {
+      const v = voices.objectAtIndex(i);
+      out.push({ id: String(v.identifier), name: String(v.name), lang: String(v.language) });
+    }
+    return out;
+  });
+
+  bridge.register('speech.stopListening', () => {
+    // End audio → the recognizer flushes a final result, then we settle with best-so-far.
+    try { engine?.inputNode?.removeTapOnBus?.(0); engine?.stop?.(); request?.endAudio?.(); } catch { /* noop */ }
+    if (listenPending) settleListen();
+  });
+
+  bridge.register('speech.listen', (params: any) =>
+    new Promise<string>((resolve, reject) => {
+      if (listenPending) { reject(err('NATIVE_ERROR', 'speech.listen: already listening')); return; }
+      best = '';
+      listenPending = { resolve, reject };
+
+      SFSpeechRecognizer.requestAuthorization((status: any) => {
+        if (status !== SFSpeechRecognizerAuthorizationStatusAuthorized) {
+          const p = listenPending; listenPending = null;
+          p?.reject(err('DENIED', 'Speech recognition not authorized'));
+          return;
+        }
+        Utils.dispatchToMainThread(() => {
+          try {
+            // Pick a locale SFSpeechRecognizer has a model for: try the requested lang, the device
+            // language code, then en-US (always supported) as a last resort. Do NOT gate on
+            // `isAvailable` — it's unreliable SYNCHRONOUSLY right after init (becomes true async via
+            // the availabilityDidChange delegate), so checking it here wrongly rejects a good recognizer
+            // (proven on-device: en-US reported unavailable). Accept any non-nil recognizer; a genuine
+            // failure surfaces in the recognitionTask error callback instead.
+            const tryRec = (id: string) => {
+              try { return SFSpeechRecognizer.alloc().initWithLocale(NSLocale.localeWithLocaleIdentifier(id)) || null; }
+              catch { return null; }
+            };
+            let langCode = 'en';
+            try { langCode = String(NSLocale.currentLocale.languageCode || 'en'); } catch { /* default */ }
+            const tried = params?.lang ? [String(params.lang)] : [langCode, 'en-US'];
+            recognizer = null;
+            for (const id of tried) { recognizer = tryRec(id); if (recognizer) break; }
+            if (!recognizer) {
+              const p = listenPending; listenPending = null;
+              p?.reject(err('UNSUPPORTED', `Speech recognizer unavailable (tried: ${tried.join(', ')})`));
+              return;
+            }
+
+            const session = AVAudioSession.sharedInstance();
+            session.setCategoryModeOptionsError(AVAudioSessionCategoryPlayAndRecord, AVAudioSessionModeMeasurement, 1 /* duckOthers */, null);
+            session.setActiveWithOptionsError(true, 0, null);
+
+            engine = AVAudioEngine.new();
+            request = SFSpeechAudioBufferRecognitionRequest.new();
+            request.shouldReportPartialResults = !!params?.partial;
+
+            task = recognizer.recognitionTaskWithRequestResultHandler(request, (result: any, error: any) => {
+              if (result) {
+                best = String(result.bestTranscription?.formattedString ?? best);
+                if (params?.partial && !result.isFinal) bridge.emit('speech.partial', { transcript: best });
+                if (result.isFinal && listenPending) settleListen();
+              }
+              if (error && listenPending) {
+                const p = listenPending; listenPending = null;
+                teardownListen();
+                p?.resolve(best); // resolve with whatever we have — stopListening contract
+              }
+            });
+
+            const input = engine.inputNode;
+            const format = input.outputFormatForBus(0);
+            input.installTapOnBusBufferSizeFormatBlock(0, 1024, format, (buffer: any, _when: any) => {
+              request?.appendAudioPCMBuffer(buffer);
+            });
+            engine.prepare();
+            engine.startAndReturnError(null);
+          } catch (e: any) {
+            const p = listenPending; listenPending = null;
+            teardownListen();
+            p?.reject(err('NATIVE_ERROR', e?.message ?? 'listen failed'));
+          }
+        });
+      });
+    })
+  );
+}
+
+function registerAndroid(): void {
+  // TextToSpeech + SpeechRecognizer are plain Java → direct interop, no kotlin flag, no gradle dep.
+  let tts: any = null;
+  let ttsReady = false;
+  const ctx = () => Utils.android.getApplicationContext();
+
+  const ensureTts = (): Promise<any> =>
+    new Promise((resolve) => {
+      if (tts && ttsReady) { resolve(tts); return; }
+      tts = new android.speech.tts.TextToSpeech(
+        ctx(),
+        new android.speech.tts.TextToSpeech.OnInitListener({
+          onInit(status: number) {
+            ttsReady = status === android.speech.tts.TextToSpeech.SUCCESS;
+            resolve(ttsReady ? tts : null);
+          },
+        })
+      );
+    });
+
+  bridge.register('speech.speak', async (params: any) => {
+    const engine = await ensureTts();
+    if (!engine) throw err('NATIVE_ERROR', 'TextToSpeech init failed');
+    const text = String(params?.text ?? '');
+    if (params?.lang) {
+      try { engine.setLanguage(new java.util.Locale.Builder().setLanguageTag(String(params.lang)).build()); } catch { /* keep default */ }
+    }
+    if (params?.rate != null) engine.setSpeechRate(Number(params.rate));
+    if (params?.pitch != null) engine.setPitch(Number(params.pitch));
+    const id = 'u' + Date.now();
+    return new Promise<void>((resolve) => {
+      engine.setOnUtteranceProgressListener(
+        new android.speech.tts.UtteranceProgressListener({
+          onStart() {},
+          onDone() { resolve(); },
+          onError() { resolve(); }, // resolve regardless — speak() promises completion, not success
+        })
+      );
+      engine.speak(text, android.speech.tts.TextToSpeech.QUEUE_FLUSH, null, id);
+    });
+  });
+
+  bridge.register('speech.stop', () => { try { tts?.stop?.(); } catch { /* noop */ } });
+
+  bridge.register('speech.voices', () => {
+    const out: Array<{ id: string; name: string; lang: string }> = [];
+    try {
+      const voices = tts?.getVoices?.();
+      if (voices) {
+        const it = voices.iterator();
+        while (it.hasNext()) {
+          const v = it.next();
+          out.push({ id: String(v.getName()), name: String(v.getName()), lang: String(v.getLocale().toLanguageTag()) });
+        }
+      }
+    } catch { /* TTS not yet init — return empty */ }
+    return out;
+  });
+
+  // STT — SpeechRecognizer must be created + driven on the main (UI) thread.
+  let recognizer: any = null;
+  let listenPending: { resolve: (v: string) => void; reject: (e: any) => void } | null = null;
+  let best = '';
+
+  const settle = () => {
+    const p = listenPending; listenPending = null;
+    try { recognizer?.stopListening?.(); recognizer?.destroy?.(); } catch { /* noop */ }
+    recognizer = null;
+    p?.resolve(best);
+  };
+
+  bridge.register('speech.stopListening', () => {
+    Utils.dispatchToMainThread(() => { if (listenPending) settle(); });
+  });
+
+  bridge.register('speech.listen', async (params: any) => {
+    const granted = await requestPermissions(['android.permission.RECORD_AUDIO']);
+    if (!granted) throw err('DENIED', 'Microphone permission denied');
+    if (listenPending) throw err('NATIVE_ERROR', 'speech.listen: already listening');
+
+    return new Promise<string>((resolve, reject) => {
+      best = '';
+      listenPending = { resolve, reject };
+      Utils.dispatchToMainThread(() => {
+        try {
+          if (!android.speech.SpeechRecognizer.isRecognitionAvailable(ctx())) {
+            const p = listenPending; listenPending = null;
+            p?.reject(err('UNSUPPORTED', 'No speech recognition service'));
+            return;
+          }
+          recognizer = android.speech.SpeechRecognizer.createSpeechRecognizer(ctx());
+          const pickText = (b: any): string => {
+            const arr = b?.getStringArrayList(android.speech.SpeechRecognizer.RESULTS_RECOGNITION);
+            return arr && arr.size() ? String(arr.get(0)) : '';
+          };
+          recognizer.setRecognitionListener(
+            new android.speech.RecognitionListener({
+              onReadyForSpeech() {}, onBeginningOfSpeech() {}, onRmsChanged() {},
+              onBufferReceived() {}, onEndOfSpeech() {}, onEvent() {},
+              onPartialResults(b: any) {
+                if (!params?.partial) return;
+                const t = pickText(b);
+                if (t) { best = t; bridge.emit('speech.partial', { transcript: t }); }
+              },
+              onResults(b: any) {
+                const t = pickText(b);
+                if (t) best = t;
+                if (listenPending) settle();
+              },
+              onError(_code: number) {
+                if (listenPending) settle(); // resolve with best-so-far (e.g. timeout/no-match)
+              },
+            })
+          );
+          const intent = new android.content.Intent(android.speech.RecognizerIntent.ACTION_RECOGNIZE_SPEECH);
+          intent.putExtra(
+            android.speech.RecognizerIntent.EXTRA_LANGUAGE_MODEL,
+            android.speech.RecognizerIntent.LANGUAGE_MODEL_FREE_FORM
+          );
+          if (params?.lang) intent.putExtra(android.speech.RecognizerIntent.EXTRA_LANGUAGE, String(params.lang));
+          if (params?.partial) intent.putExtra(android.speech.RecognizerIntent.EXTRA_PARTIAL_RESULTS, true);
+          recognizer.startListening(intent);
+        } catch (e: any) {
+          const p = listenPending; listenPending = null;
+          p?.reject(err('NATIVE_ERROR', e?.message ?? 'listen failed'));
+        }
+      });
+    });
+  });
+}

package/runtime/app/shell/ios-frameworks.d.ts

@@ -30,6 +30,14 @@ declare const HKStatisticsOptions: any;
 declare const HKUnit: any;
 declare const CNContactPickerViewController: any;
 declare const CNContactPickerDelegate: any;
+// Contacts framework (contacts.getAll bulk read — CNContactStore, vs the ContactsUI picker above)
+declare const CNContactStore: any;
+declare const CNEntityType: any;
+declare const CNContactFetchRequest: any;
+declare const CNContactGivenNameKey: any;
+declare const CNContactFamilyNameKey: any;
+declare const CNContactPhoneNumbersKey: any;
+declare const CNContactEmailAddressesKey: any;
 declare const EKEventStore: any;
 declare const EKEvent: any;
 declare const EKSpan: any;

package/runtime/app/shell/keyboard.ts

@@ -0,0 +1,85 @@
+import { Application, Utils, isAndroid, isIOS } from '@nativescript/core';
+import { bridge } from './bridge';
+
+declare const android: any;
+// iOS keyboard-notification globals (marshalled from UIKit at runtime).
+declare const NSNotificationCenter: any;
+declare const UIKeyboardWillShowNotification: string;
+declare const UIKeyboardWillHideNotification: string;
+declare const UIKeyboardFrameEndUserInfoKey: string;
+
+let observersArmed = false;
+
+/**
+ * `kit.keyboard` shell handlers: dismiss the software keyboard (`keyboard.hide`)
+ * and forward show/hide so the page can lift content above it.
+ *
+ * Heights are emitted in CSS px — iOS keyboard frames are in points (≈ CSS px in
+ * a WKWebView), Android raw pixels are divided by display density. iOS observes
+ * `UIKeyboardWillShow/Hide`; Android watches the decor view's visible frame.
+ */
+export function registerKeyboardHandlers(): void {
+  bridge.register('keyboard.hide', () => {
+    Utils.dispatchToMainThread(() => {
+      if (isIOS) {
+        // WKWebView is a UIView → endEditing resigns the active field's first responder.
+        (bridge.getWebView()?.ios as any)?.endEditing?.(true);
+      } else if (isAndroid) {
+        hideAndroidKeyboard();
+      }
+    });
+  });
+
+  if (observersArmed) return;
+  observersArmed = true;
+  if (isIOS) armIosKeyboardObservers();
+  else if (isAndroid) armAndroidKeyboardObserver();
+}
+
+/** iOS: NSNotificationCenter observers → emit keyboard.show {height} / keyboard.hide. */
+function armIosKeyboardObservers(): void {
+  const center = NSNotificationCenter.defaultCenter;
+  center.addObserverForNameObjectQueueUsingBlock(UIKeyboardWillShowNotification, null, null, (note: any) => {
+    const value = note?.userInfo?.objectForKey?.(UIKeyboardFrameEndUserInfoKey);
+    const height = value ? value.CGRectValue.size.height : 0; // points ≈ CSS px in WKWebView
+    bridge.emit('keyboard.show', { height: Math.round(height) });
+  });
+  center.addObserverForNameObjectQueueUsingBlock(UIKeyboardWillHideNotification, null, null, () => {
+    bridge.emit('keyboard.hide');
+  });
+}
+
+/** Android: a global-layout listener compares the decor view's visible frame to its full height. */
+function armAndroidKeyboardObserver(): void {
+  const activity = androidActivity();
+  if (!activity) return;
+  const rootView = activity.getWindow().getDecorView();
+  const density = Utils.android.getApplicationContext().getResources().getDisplayMetrics().density || 1;
+  let lastShown = false;
+  const listener = new android.view.ViewTreeObserver.OnGlobalLayoutListener({
+    onGlobalLayout() {
+      const rect = new android.graphics.Rect();
+      rootView.getWindowVisibleDisplayFrame(rect);
+      const screenHeight = rootView.getHeight();
+      const hiddenPx = screenHeight - rect.bottom; // band covered at the bottom
+      const shown = hiddenPx > screenHeight * 0.15; // >15% ≈ keyboard, not a nav/status bar
+      if (shown === lastShown) return;
+      lastShown = shown;
+      if (shown) bridge.emit('keyboard.show', { height: Math.round(hiddenPx / density) });
+      else bridge.emit('keyboard.hide');
+    },
+  });
+  rootView.getViewTreeObserver().addOnGlobalLayoutListener(listener);
+}
+
+function hideAndroidKeyboard(): void {
+  const activity = androidActivity();
+  if (!activity) return;
+  const imm = activity.getSystemService(android.content.Context.INPUT_METHOD_SERVICE);
+  const view = activity.getCurrentFocus() ?? activity.getWindow().getDecorView();
+  imm?.hideSoftInputFromWindow(view.getWindowToken(), 0);
+}
+
+function androidActivity(): any {
+  return Application.android.foregroundActivity ?? Application.android.startActivity;
+}