@ateam-ai-mobile/expo 0.1.5 → 0.1.8

package/src/camera/cameraTasks.ts

@@ -0,0 +1,129 @@
+/**
+ * The broker between a plugin's `await` and a mounted camera.
+ *
+ * WHY THIS EXISTS. expo-camera has no headless capture: scanning a barcode and
+ * recording a clip both require a MOUNTED `<CameraView>`. But a plugin calls
+ * `native.scanner.scanOnce()` and expects a promise — it has no way to mount
+ * anything, and it must not have to.
+ *
+ * So the API enqueues a TASK here and awaits it; `CameraTaskHost`, mounted once
+ * by the app, notices, shows the camera, does the work, and settles the
+ * promise. This is the same split as the Visual engine, for the same reason —
+ * and it is why `native.camera.scanBarcode` refuses and points here rather than
+ * pretending a function call can own a React lifecycle.
+ *
+ * ONE TASK AT A TIME, and it is the phone that says so: there is one camera. A
+ * second request while one is running is REJECTED rather than queued, because a
+ * queued scan would open the camera again minutes later, long after the user
+ * moved on and with no idea why it appeared.
+ */
+export interface ScanTask {
+  kind: 'scan';
+  opts: { formats?: string[]; timeoutMs?: number };
+  resolve: (v: { data: string; format: string }) => void;
+  reject: (e: Error) => void;
+}
+
+export interface RecordTask {
+  kind: 'record';
+  opts: { maxDurationMs?: number; withAudio?: boolean };
+  resolve: (v: { uri: string; durationMs: number | null }) => void;
+  reject: (e: Error) => void;
+}
+
+export type CameraTask = ScanTask | RecordTask;
+
+type Listener = () => void;
+
+/** Typed failure, so a caller can say something specific and true. */
+export function cameraError(code: string, message: string): Error {
+  const err: any = new Error(message);
+  err.code = code;
+  return err;
+}
+
+class CameraTaskBroker {
+  private task: CameraTask | null = null;
+  private listeners = new Set<Listener>();
+  /** Set by the host while a camera is mounted and ready. */
+  private hostMounted = false;
+
+  current(): CameraTask | null { return this.task; }
+
+  subscribe(fn: Listener): () => void {
+    this.listeners.add(fn);
+    return () => this.listeners.delete(fn);
+  }
+
+  /**
+   * Declare that a `CameraTaskHost` exists.
+   *
+   * Without it nothing will ever settle the promise, so a request must fail
+   * IMMEDIATELY and say why. The alternative is a plugin awaiting forever,
+   * which is the worst failure of the set: no error, no timeout, no camera,
+   * and a conversation that simply stops.
+   */
+  setHostMounted(mounted: boolean): void {
+    this.hostMounted = mounted;
+    if (!mounted) this.fail(cameraError('UNAVAILABLE', 'The camera surface was dismissed before the task completed.'));
+    this.notify();
+  }
+
+  isHostMounted(): boolean { return this.hostMounted; }
+
+  /** Enqueue and hand back the promise the plugin awaits. */
+  run<T>(kind: CameraTask['kind'], opts: any): Promise<T> {
+    if (!this.hostMounted) {
+      return Promise.reject(cameraError(
+        'UNAVAILABLE',
+        'No camera surface is mounted in this app, so the camera cannot be shown. ' +
+          'The host must render <CameraTaskHost /> once, near the app root.',
+      ));
+    }
+    if (this.task) {
+      return Promise.reject(cameraError(
+        'BUSY',
+        `The camera is already in use (${this.task.kind}). Only one camera task can run at a time.`,
+      ));
+    }
+    return new Promise<T>((resolve, reject) => {
+      this.task = { kind, opts, resolve, reject } as unknown as CameraTask;
+      this.notify();
+    });
+  }
+
+  /** Settle the running task successfully and clear it. */
+  complete(value: any): void {
+    const t = this.task;
+    if (!t) return;
+    this.task = null;
+    this.notify();
+    t.resolve(value);
+  }
+
+  /** Settle the running task with a failure and clear it. */
+  fail(err: Error): void {
+    const t = this.task;
+    if (!t) return;
+    this.task = null;
+    this.notify();
+    t.reject(err);
+  }
+
+  /**
+   * The user backed out.
+   *
+   * A distinct code, because "the user chose not to" is not a malfunction and
+   * a guide should say something different about it than about a broken lens.
+   */
+  cancel(): void {
+    this.fail(cameraError('CANCELLED', 'Cancelled — the camera was dismissed before anything was captured.'));
+  }
+
+  private notify(): void {
+    for (const fn of this.listeners) { try { fn(); } catch { /* a bad listener is not the broker's problem */ } }
+  }
+}
+
+/** One broker per app: there is one camera. */
+export const cameraTasks = new CameraTaskBroker();

package/src/createBridge.ts

@@ -16,6 +16,8 @@ import * as ExpoSMS from 'expo-sms';
 import * as ExpoLinking from 'expo-linking';
 import { Platform } from 'react-native';
 import * as Device from 'expo-device';
+// The SDK's one reverse geocode — the same call native.maps.reverseGeocode makes.
+import { reverseGeocode } from './maps';
 
 import type { Bridge } from '@ateam-ai-mobile/plugin-runtime';
 
@@ -361,7 +363,7 @@ export function createBridge(connectorId: string, deviceId: string): Bridge {
             accuracy: ExpoLocation.Accuracy.Balanced,
           });
 
-          const [geo] = await ExpoLocation.reverseGeocodeAsync({
+          const geo = await reverseGeocode({
             latitude: location.coords.latitude,
             longitude: location.coords.longitude,
           });