@mentra/bluetooth-sdk 0.1.8 → 0.1.10

package/ios/Source/utils/TarBz2Extractor.swift

@@ -6,6 +6,7 @@ import SWCompression
 @objc(TarBz2Extractor)
 class TarBz2Extractor: NSObject {
     private static let chunkSize = 1 << 16 // 64 KB
+    private static let progressEmitIntervalMs: Int64 = 200
 
     @objc
     static func extractTarBz2From(
@@ -42,14 +43,19 @@ class TarBz2Extractor: NSObject {
             attributes: nil
         )
 
-        let tempTarURL = try decompressBzipArchive(at: sourcePath)
+        let sourceSize = fileSize(atPath: sourcePath)
+        Bridge.sendExtractionProgress(percentage: 0, bytesRead: 0, totalBytes: sourceSize)
+
+        let tempTarURL = try decompressBzipArchive(at: sourcePath, sourceSize: sourceSize)
         defer { try? fileManager.removeItem(at: tempTarURL) }
 
         try extractTarArchive(at: tempTarURL, to: destinationPath)
         try flattenNestedDirectory(at: destinationPath)
+
+        Bridge.sendExtractionProgress(percentage: 100, bytesRead: sourceSize, totalBytes: sourceSize)
     }
 
-    private static func decompressBzipArchive(at sourcePath: String) throws -> URL {
+    private static func decompressBzipArchive(at sourcePath: String, sourceSize: Int64) throws -> URL {
         let tempTarURL = FileManager.default.temporaryDirectory
             .appendingPathComponent(UUID().uuidString)
             .appendingPathExtension("tar")
@@ -70,6 +76,7 @@ class TarBz2Extractor: NSObject {
         }
 
         var buffer = [Int8](repeating: 0, count: chunkSize)
+        var lastEmittedAt: Int64 = 0
         while true {
             let bytesRead = BZ2_bzRead(&bzError, bzFile, &buffer, Int32(buffer.count))
             if bzError == BZ_OK || bzError == BZ_STREAM_END {
@@ -83,6 +90,20 @@ class TarBz2Extractor: NSObject {
                         throw makeError(code: 1004, message: "Failed to write decompressed data")
                     }
                 }
+
+                let now = nowMs()
+                if now - lastEmittedAt >= progressEmitIntervalMs && sourceSize > 0 {
+                    let consumed = Int64(ftell(sourceFile))
+                    // Bzip phase claims 0–80% of total UI progress.
+                    let pct = max(0, min(80, Int((consumed * 80) / sourceSize)))
+                    Bridge.sendExtractionProgress(
+                        percentage: pct,
+                        bytesRead: consumed,
+                        totalBytes: sourceSize
+                    )
+                    lastEmittedAt = now
+                }
+
                 if bzError == BZ_STREAM_END {
                     break
                 }
@@ -97,6 +118,8 @@ class TarBz2Extractor: NSObject {
             throw makeError(code: 1006, message: "bzip2 close failed with code \(bzError)")
         }
 
+        Bridge.sendExtractionProgress(percentage: 80, bytesRead: sourceSize, totalBytes: sourceSize)
+
         return tempTarURL
     }
 
@@ -104,10 +127,12 @@ class TarBz2Extractor: NSObject {
         let destinationRoot = URL(fileURLWithPath: destinationPath, isDirectory: true)
         let fileManager = FileManager.default
 
+        let tarSize = fileSize(at: tarURL)
         let handle = try FileHandle(forReadingFrom: tarURL)
         defer { try? handle.close() }
 
         var reader = TarReader(fileHandle: handle)
+        var lastEmittedAt: Int64 = 0
 
         while let entry = try reader.read() {
             let sanitizedName = sanitize(entryName: entry.info.name)
@@ -135,9 +160,35 @@ class TarBz2Extractor: NSObject {
             default:
                 continue
             }
+
+            let now = nowMs()
+            if now - lastEmittedAt >= progressEmitIntervalMs && tarSize > 0 {
+                let consumed = Int64(handle.offsetInFile)
+                // Tar phase claims 80–99% of total UI progress.
+                let pct = 80 + max(0, min(19, Int((consumed * 19) / tarSize)))
+                Bridge.sendExtractionProgress(
+                    percentage: pct,
+                    bytesRead: consumed,
+                    totalBytes: tarSize
+                )
+                lastEmittedAt = now
+            }
         }
     }
 
+    private static func fileSize(atPath path: String) -> Int64 {
+        let attrs = try? FileManager.default.attributesOfItem(atPath: path)
+        return (attrs?[.size] as? NSNumber)?.int64Value ?? 0
+    }
+
+    private static func fileSize(at url: URL) -> Int64 {
+        return fileSize(atPath: url.path)
+    }
+
+    private static func nowMs() -> Int64 {
+        return Int64(Date().timeIntervalSince1970 * 1000)
+    }
+
     private static func flattenNestedDirectory(at destinationPath: String) throws {
         let fileManager = FileManager.default
         let destinationURL = URL(fileURLWithPath: destinationPath, isDirectory: true)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mentra/bluetooth-sdk",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "description": "SDK for communicating with smart glasses",
   "main": "build/index.js",
   "react-native": "src/index.ts",

package/plugin/build/withAndroid.js

@@ -14,17 +14,42 @@ function toGroovyString(value) {
     return JSON.stringify(value);
 }
 /**
- * Modify settings.gradle to include lc3Lib module
+ * Modify settings.gradle to include lc3Lib and silero modules
  */
 function withSettingsGradleModifications(config) {
     return (0, config_plugins_1.withSettingsGradle)(config, (config) => {
         let settingsGradle = config.modResults.contents;
-        // Add lc3Lib module if not present
+        const bluetoothSdkRoot = getBluetoothSdkRoot();
+        const bluetoothSdkRootExpression = `System.getenv("MENTRA_BLUETOOTH_SDK_PACKAGE_PATH") ?: ${toGroovyString(bluetoothSdkRoot)}`;
+        if (!settingsGradle.includes("project(':mentra-bluetooth-sdk').projectDir")) {
+            const bluetoothSdkProjectBlock = `
+  if (findProject(':mentra-bluetooth-sdk') != null) {
+    project(':mentra-bluetooth-sdk').projectDir = new File(${bluetoothSdkRootExpression}, 'android')
+  }
+`;
+            const lc3Include = "  include ':lc3Lib'";
+            settingsGradle = settingsGradle.includes(lc3Include)
+                ? settingsGradle.replace(lc3Include, `${bluetoothSdkProjectBlock}\n${lc3Include}`)
+                : `${settingsGradle}${bluetoothSdkProjectBlock}`;
+        }
         if (!settingsGradle.includes("include ':lc3Lib'")) {
-            const bluetoothSdkRoot = getBluetoothSdkRoot();
             settingsGradle += `
   include ':lc3Lib'
-  project(':lc3Lib').projectDir = new File(${toGroovyString(bluetoothSdkRoot)}, 'android/lc3Lib')
+  `;
+        }
+        if (!settingsGradle.includes("project(':lc3Lib').projectDir")) {
+            settingsGradle += `
+  project(':lc3Lib').projectDir = new File(${bluetoothSdkRootExpression}, 'android/lc3Lib')
+  `;
+        }
+        if (!settingsGradle.includes("include ':silero'")) {
+            settingsGradle += `
+  include ':silero'
+  `;
+        }
+        if (!settingsGradle.includes("project(':silero').projectDir")) {
+            settingsGradle += `
+  project(':silero').projectDir = new File(${bluetoothSdkRootExpression}, 'android/silero')
   `;
         }
         config.modResults.contents = settingsGradle;
@@ -70,8 +95,47 @@ function withGradlePropertiesModifications(config) {
         return config;
     });
 }
+/**
+ * Inject a local Maven repository into the root project's allprojects block so
+ * that `:app` (and any other module that transitively pulls our deps) can
+ * resolve `com.k2fsa.sherpa.onnx:sherpa-onnx`. The AAR is downloaded at
+ * configure-time by bluetooth-sdk's own build.gradle into
+ * `android/libs/maven/`; we just need that directory exposed as a maven repo
+ * to consumers as well. AGP rejects raw local-.aar deps from library modules,
+ * so the Maven layout is the supported workaround.
+ */
+function withSherpaOnnxLocalMavenRepo(config) {
+    return (0, config_plugins_1.withProjectBuildGradle)(config, (config) => {
+        if (config.modResults.language !== "groovy") {
+            return config;
+        }
+        let contents = config.modResults.contents;
+        const fallbackRoot = toGroovyString(getBluetoothSdkRoot());
+        const repoDirExpression = `new File(System.getenv("MENTRA_BLUETOOTH_SDK_PACKAGE_PATH") ?: ${fallbackRoot}, "android/libs/maven")`;
+        const marker = "// bluetooth-sdk: sherpa-onnx local maven repo";
+        if (contents.includes(marker)) {
+            return config;
+        }
+        const repoBlock = `    maven {\n      ${marker}\n      url = uri(${repoDirExpression})\n    }`;
+        const allprojectsMatch = contents.match(/allprojects\s*\{[\s\S]*?repositories\s*\{/);
+        if (allprojectsMatch) {
+            const insertIdx = allprojectsMatch.index + allprojectsMatch[0].length;
+            contents = contents.slice(0, insertIdx) + "\n" + repoBlock + contents.slice(insertIdx);
+        }
+        else {
+            // Fallback: append an allprojects block. Older Expo templates that don't
+            // emit allprojects {} put repositories in settings.gradle instead — but
+            // this codebase's prebuild has historically emitted allprojects, so this
+            // branch is just a safety net.
+            contents += `\nallprojects {\n  repositories {\n${repoBlock}\n  }\n}\n`;
+        }
+        config.modResults.contents = contents;
+        return config;
+    });
+}
 const withAndroidConfiguration = (config, props) => {
     config = withSettingsGradleModifications(config);
+    config = withSherpaOnnxLocalMavenRepo(config);
     if (props?.node) {
         config = withGradlePropertiesModifications(config);
     }