@ateam-ai-mobile/expo 0.1.4 → 0.1.7

package/android/build.gradle

@@ -0,0 +1,16 @@
+apply plugin: 'com.android.library'
+apply plugin: 'org.jetbrains.kotlin.android'
+apply plugin: 'expo-module-gradle-plugin'
+
+group = 'expo.modules.adavision'
+version = '1.0.0'
+
+android {
+  namespace "expo.modules.adavision"
+  defaultConfig {
+    minSdkVersion safeExtGet("minSdkVersion", 24)
+  }
+  lintOptions {
+    abortOnError false
+  }
+}

package/android/src/main/java/expo/modules/adavision/AdaVisionModule.kt

@@ -0,0 +1,75 @@
+package expo.modules.adavision
+
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+import java.net.URI
+import kotlin.math.max
+import kotlin.math.sqrt
+
+// On-device frame-quality analysis. Reads a local frame file, computes pixel
+// statistics on a small grayscale downscale, returns only the verdict. Nothing
+// leaves the device. readText / describe (MLKit) are a later pass.
+class AdaVisionModule : Module() {
+  override fun definition() = ModuleDefinition {
+    Name("AdaVision")
+
+    Function("isSupported") { true }
+
+    AsyncFunction("assessQuality") { uri: String ->
+      val bmp = loadBitmap(uri) ?: throw Exception("Could not read frame at $uri")
+      assess(bmp)
+    }
+  }
+
+  private fun loadBitmap(uri: String): Bitmap? {
+    val path = if (uri.startsWith("file://")) URI(uri).path else uri
+    // inSampleSize=2 halves each dimension on decode — cheaper, still ample for stats.
+    val opts = BitmapFactory.Options().apply { inSampleSize = 2 }
+    return BitmapFactory.decodeFile(path, opts)
+  }
+
+  private fun assess(src: Bitmap): Map<String, Any?> {
+    val side = 128
+    val scaled = Bitmap.createScaledBitmap(src, side, side, true)
+    val px = IntArray(side * side)
+    scaled.getPixels(px, 0, side, 0, 0, side, side)
+
+    val gray = IntArray(side * side)
+    for (i in px.indices) {
+      val c = px[i]
+      val r = (c shr 16) and 0xFF
+      val g = (c shr 8) and 0xFF
+      val b = c and 0xFF
+      gray[i] = (0.299 * r + 0.587 * g + 0.114 * b).toInt()
+    }
+
+    var sum = 0.0
+    var sumSq = 0.0
+    for (v in gray) { val d = v.toDouble(); sum += d; sumSq += d * d }
+    val n = (side * side).toDouble()
+    val mean = sum / n
+    val std = sqrt(max(0.0, sumSq / n - mean * mean))
+
+    var lapSum = 0.0
+    var lapSumSq = 0.0
+    var count = 0
+    for (y in 1 until side - 1) {
+      for (x in 1 until side - 1) {
+        val i = y * side + x
+        val lap = 4.0 * gray[i] - gray[i - 1] - gray[i + 1] - gray[i - side] - gray[i + side]
+        lapSum += lap; lapSumSq += lap * lap; count++
+      }
+    }
+    val ln = count.toDouble()
+    val lapVar = max(0.0, lapSumSq / ln - (lapSum / ln) * (lapSum / ln))
+
+    // Heuristic thresholds on a 128×128 grayscale — tune with real frames.
+    val exposure = if (mean < 45) "dark" else if (mean > 205) "bright" else "good"
+    val obstructed = mean < 22 && std < 8
+    val blur = if (lapVar > 120) "sharp" else if (lapVar > 30) "slight" else "severe"
+
+    return mapOf("blur" to blur, "exposure" to exposure, "obstructed" to obstructed)
+  }
+}

package/dist/attachmentCache-DhQTqi2E.d.mts

@@ -0,0 +1,18 @@
+import { AttachmentCache, OutgoingAttachment, AttachmentPreview } from '@ateam-ai-mobile/core';
+
+declare class ExpoAttachmentCache implements AttachmentCache {
+    private index;
+    private loaded;
+    private indexKey;
+    /** Pass `indexKey` when migrating from an app that already persisted an
+     *  index under a different AsyncStorage key — otherwise existing users
+     *  lose every cached preview on upgrade. */
+    constructor(opts?: {
+        indexKey?: string;
+    });
+    ready(): Promise<void>;
+    save(jobId: string, attachments: OutgoingAttachment[]): Promise<void>;
+    get(jobId: string): AttachmentPreview[] | undefined;
+}
+
+export { ExpoAttachmentCache as E };

package/dist/attachmentCache-DhQTqi2E.d.ts

@@ -0,0 +1,18 @@
+import { AttachmentCache, OutgoingAttachment, AttachmentPreview } from '@ateam-ai-mobile/core';
+
+declare class ExpoAttachmentCache implements AttachmentCache {
+    private index;
+    private loaded;
+    private indexKey;
+    /** Pass `indexKey` when migrating from an app that already persisted an
+     *  index under a different AsyncStorage key — otherwise existing users
+     *  lose every cached preview on upgrade. */
+    constructor(opts?: {
+        indexKey?: string;
+    });
+    ready(): Promise<void>;
+    save(jobId: string, attachments: OutgoingAttachment[]): Promise<void>;
+    get(jobId: string): AttachmentPreview[] | undefined;
+}
+
+export { ExpoAttachmentCache as E };

package/dist/bootstrap.d.mts

@@ -0,0 +1,95 @@
+import { TokenProvider, AdasUser, AdasSession } from '@ateam-ai-mobile/core';
+import { RegisteredPlugin } from '@ateam-ai-mobile/plugin-runtime';
+import { UIActionRoute } from '@ateam-ai-mobile/ui';
+import { E as ExpoAttachmentCache } from './attachmentCache-DhQTqi2E.mjs';
+
+/**
+ * bootstrapExpoAdas — the single, self-contained SDK bootstrap (R10).
+ *
+ * The final high-level entry point of the "fat SDK / thin shell" arc: it folds
+ * the ~15 hand-wired seams the host used to assemble in its own adas.ts into ONE
+ * call, so the shell stops manually assembling platform providers/collectors/
+ * plugins. Internally it initializes, in the order the migrated code established:
+ * the Expo providers (haptics/bundle cache/clipboard/attachment cache + the
+ * device-primitive provider), the host-bundled native plugins, the plugin-WebView
+ * allow-list, native OAuth, the ACS reachability reporter, the L3 DeviceState
+ * engine (with the SDK's OWN collectors — the shell injects none), the plugin/
+ * UI-action navigator, and finally the core config+token bridge (initAdas).
+ *
+ * The API is DERIVED from the host's migrated adas.ts, not invented. Everything
+ * the host still owns is passed in as a small values-and-getters bag: endpoint
+ * getters (the host owns the dev/prod switch), the identity/token bridge, its
+ * branded Google client id, its host-bundled plugin resolvers, the native
+ * WebView module from its build, and its router callback.
+ *
+ * A SUBPATH (`@ateam-ai-mobile/expo/bootstrap`), like /device and /oauth: it
+ * statically pulls the optional expo native modules (via createDeviceProvider /
+ * the device-state collectors / the OAuth provider), so it must not sit on the
+ * package's main entry, which a host without those modules still has to build.
+ *
+ * The two physical reasoning paths stay DISTINCT and are wired as SEPARATE
+ * statements — never a merged bridge: LOCAL (the local tool registry + device
+ * state the plugin/voice runtime reads) and SERVER (the relay allow-list here;
+ * the DeviceBridge relay runtime itself is started by the host lifecycle, out of
+ * this module-load bootstrap's scope).
+ */
+
+/** A host-bundled native plugin: one lazy resolver registered under one or more ids. */
+interface NativePluginRegistration {
+    resolver: () => Promise<RegisteredPlugin>;
+    ids: string[];
+}
+interface BootstrapExpoAdasOptions {
+    /**
+     * Endpoint GETTERS — the host owns the dev/prod env switch, so these are read
+     * live on every SDK request (never snapshotted). `core` is required; the rest
+     * are optional (voice/consumer-auth features light up when present).
+     */
+    urls: {
+        core: () => string;
+        voice?: () => string;
+        consumerAuth?: () => string;
+        /** Trusted extra host for plugin WebViews (the relay device-bridge auth flows). */
+        relay?: () => string;
+    };
+    /** The host's token bridge — outcome mapping (transient vs auth_failed) owned by the host. */
+    tokenProvider: TokenProvider;
+    /** Current user projection for chat routing (host reads its auth store). */
+    getUser: () => AdasUser | null;
+    /** Active tenant getter (signed-in tenant, falling back to the pre-auth pick). */
+    tenant?: () => string;
+    /** Adopt a freshly-minted session on tenant switch (host persists tenant-first, then logs in). */
+    onSession?: (session: AdasSession) => void | Promise<void>;
+    /** The host's bundled Google iOS client id, for the join/open-join OAuth path. */
+    googleIosClientId?: string;
+    /** Host-bundled native plugins (AuthWebView, ConnectionsPanel, …) — lazy resolvers. */
+    nativePlugins?: NativePluginRegistration[];
+    /** Native modules remote bundles may require() (e.g. react-native-webview) — from the host build. */
+    bundleModules?: Record<string, unknown>;
+    /** Pre-SDK AsyncStorage keys, so an existing install keeps its warm caches. */
+    storageKeys?: {
+        attachmentIndex?: string;
+        bundleIndex?: string;
+    };
+    /** Connectivity sink — the SDK reports fetch reachability up/down; the host feeds its banner. */
+    onReachabilityChange?: (up: boolean) => void;
+    /** Open the host's plugin screen for a UI-action chip (the host owns its router). */
+    navigateToPlugin: (route: UIActionRoute) => void;
+    /**
+     * Reachability probe URL for the device-primitive connectivity API. The host
+     * passes this EXPLICITLY (typically `${core}/health`) as a load-time snapshot —
+     * deliberately NOT derived from `urls.core()`, so a dev/E2E core override does
+     * not silently flow into the health probe (the asymmetry the host relied on).
+     */
+    reachabilityUrl?: string;
+}
+/**
+ * Wire the entire Expo-backed ADAS platform in one call. Run for its side effect
+ * at module load, before the router mounts. Returns the attachment cache so the
+ * host can hand it to anything that needs it (initAdas already received it).
+ */
+declare function bootstrapExpoAdas(opts: BootstrapExpoAdasOptions): {
+    attachmentCache: ExpoAttachmentCache;
+};
+
+export { type BootstrapExpoAdasOptions, type NativePluginRegistration, bootstrapExpoAdas };

package/dist/bootstrap.d.ts

@@ -0,0 +1,95 @@
+import { TokenProvider, AdasUser, AdasSession } from '@ateam-ai-mobile/core';
+import { RegisteredPlugin } from '@ateam-ai-mobile/plugin-runtime';
+import { UIActionRoute } from '@ateam-ai-mobile/ui';
+import { E as ExpoAttachmentCache } from './attachmentCache-DhQTqi2E.js';
+
+/**
+ * bootstrapExpoAdas — the single, self-contained SDK bootstrap (R10).
+ *
+ * The final high-level entry point of the "fat SDK / thin shell" arc: it folds
+ * the ~15 hand-wired seams the host used to assemble in its own adas.ts into ONE
+ * call, so the shell stops manually assembling platform providers/collectors/
+ * plugins. Internally it initializes, in the order the migrated code established:
+ * the Expo providers (haptics/bundle cache/clipboard/attachment cache + the
+ * device-primitive provider), the host-bundled native plugins, the plugin-WebView
+ * allow-list, native OAuth, the ACS reachability reporter, the L3 DeviceState
+ * engine (with the SDK's OWN collectors — the shell injects none), the plugin/
+ * UI-action navigator, and finally the core config+token bridge (initAdas).
+ *
+ * The API is DERIVED from the host's migrated adas.ts, not invented. Everything
+ * the host still owns is passed in as a small values-and-getters bag: endpoint
+ * getters (the host owns the dev/prod switch), the identity/token bridge, its
+ * branded Google client id, its host-bundled plugin resolvers, the native
+ * WebView module from its build, and its router callback.
+ *
+ * A SUBPATH (`@ateam-ai-mobile/expo/bootstrap`), like /device and /oauth: it
+ * statically pulls the optional expo native modules (via createDeviceProvider /
+ * the device-state collectors / the OAuth provider), so it must not sit on the
+ * package's main entry, which a host without those modules still has to build.
+ *
+ * The two physical reasoning paths stay DISTINCT and are wired as SEPARATE
+ * statements — never a merged bridge: LOCAL (the local tool registry + device
+ * state the plugin/voice runtime reads) and SERVER (the relay allow-list here;
+ * the DeviceBridge relay runtime itself is started by the host lifecycle, out of
+ * this module-load bootstrap's scope).
+ */
+
+/** A host-bundled native plugin: one lazy resolver registered under one or more ids. */
+interface NativePluginRegistration {
+    resolver: () => Promise<RegisteredPlugin>;
+    ids: string[];
+}
+interface BootstrapExpoAdasOptions {
+    /**
+     * Endpoint GETTERS — the host owns the dev/prod env switch, so these are read
+     * live on every SDK request (never snapshotted). `core` is required; the rest
+     * are optional (voice/consumer-auth features light up when present).
+     */
+    urls: {
+        core: () => string;
+        voice?: () => string;
+        consumerAuth?: () => string;
+        /** Trusted extra host for plugin WebViews (the relay device-bridge auth flows). */
+        relay?: () => string;
+    };
+    /** The host's token bridge — outcome mapping (transient vs auth_failed) owned by the host. */
+    tokenProvider: TokenProvider;
+    /** Current user projection for chat routing (host reads its auth store). */
+    getUser: () => AdasUser | null;
+    /** Active tenant getter (signed-in tenant, falling back to the pre-auth pick). */
+    tenant?: () => string;
+    /** Adopt a freshly-minted session on tenant switch (host persists tenant-first, then logs in). */
+    onSession?: (session: AdasSession) => void | Promise<void>;
+    /** The host's bundled Google iOS client id, for the join/open-join OAuth path. */
+    googleIosClientId?: string;
+    /** Host-bundled native plugins (AuthWebView, ConnectionsPanel, …) — lazy resolvers. */
+    nativePlugins?: NativePluginRegistration[];
+    /** Native modules remote bundles may require() (e.g. react-native-webview) — from the host build. */
+    bundleModules?: Record<string, unknown>;
+    /** Pre-SDK AsyncStorage keys, so an existing install keeps its warm caches. */
+    storageKeys?: {
+        attachmentIndex?: string;
+        bundleIndex?: string;
+    };
+    /** Connectivity sink — the SDK reports fetch reachability up/down; the host feeds its banner. */
+    onReachabilityChange?: (up: boolean) => void;
+    /** Open the host's plugin screen for a UI-action chip (the host owns its router). */
+    navigateToPlugin: (route: UIActionRoute) => void;
+    /**
+     * Reachability probe URL for the device-primitive connectivity API. The host
+     * passes this EXPLICITLY (typically `${core}/health`) as a load-time snapshot —
+     * deliberately NOT derived from `urls.core()`, so a dev/E2E core override does
+     * not silently flow into the health probe (the asymmetry the host relied on).
+     */
+    reachabilityUrl?: string;
+}
+/**
+ * Wire the entire Expo-backed ADAS platform in one call. Run for its side effect
+ * at module load, before the router mounts. Returns the attachment cache so the
+ * host can hand it to anything that needs it (initAdas already received it).
+ */
+declare function bootstrapExpoAdas(opts: BootstrapExpoAdasOptions): {
+    attachmentCache: ExpoAttachmentCache;
+};
+
+export { type BootstrapExpoAdasOptions, type NativePluginRegistration, bootstrapExpoAdas };