@glassly/bluetooth-sdk 0.1.0-dev.26

package/ios/Source/utils/TarBz2Extractor.swift

@@ -0,0 +1,257 @@
+import Compression
+import Foundation
+@_implementationOnly import libbz2
+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(
+        _ sourcePath: String,
+        to destinationPath: String,
+        error errorPointer: NSErrorPointer
+    ) -> Bool {
+        Bridge.log("TarBz2Extractor: begin extraction")
+        do {
+            try performExtraction(from: sourcePath, to: destinationPath)
+            Bridge.log("TarBz2Extractor: extraction complete")
+            return true
+        } catch let extractionError as NSError {
+            Bridge.log("TarBz2Extractor: failed - \(extractionError.localizedDescription)")
+            errorPointer?.pointee = extractionError
+            return false
+        } catch {
+            let nsError = NSError(
+                domain: "TarBz2Extractor",
+                code: -1,
+                userInfo: [NSLocalizedDescriptionKey: error.localizedDescription]
+            )
+            Bridge.log("TarBz2Extractor: failed - \(error.localizedDescription)")
+            errorPointer?.pointee = nsError
+            return false
+        }
+    }
+
+    private static func performExtraction(from sourcePath: String, to destinationPath: String) throws {
+        let fileManager = FileManager.default
+        try fileManager.createDirectory(
+            atPath: destinationPath,
+            withIntermediateDirectories: true,
+            attributes: nil
+        )
+
+        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, sourceSize: Int64) throws -> URL {
+        let tempTarURL = FileManager.default.temporaryDirectory
+            .appendingPathComponent(UUID().uuidString)
+            .appendingPathExtension("tar")
+
+        guard let sourceFile = fopen(sourcePath, "rb") else {
+            throw makeError(code: 1001, message: "Unable to open source file at \(sourcePath)")
+        }
+        defer { fclose(sourceFile) }
+
+        guard let destinationFile = fopen(tempTarURL.path, "wb") else {
+            throw makeError(code: 1002, message: "Unable to create temporary tar file")
+        }
+        defer { fclose(destinationFile) }
+
+        var bzError: Int32 = BZ_OK
+        guard let bzFile = BZ2_bzReadOpen(&bzError, sourceFile, 0, 0, nil, 0), bzError == BZ_OK else {
+            throw makeError(code: 1003, message: "Unable to open bzip stream (code \(bzError))")
+        }
+
+        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 {
+                if bytesRead > 0 {
+                    let written = buffer.withUnsafeBytes { rawBuffer -> Int in
+                        guard let baseAddress = rawBuffer.baseAddress else { return 0 }
+                        return fwrite(baseAddress, 1, Int(bytesRead), destinationFile)
+                    }
+                    guard written == Int(bytesRead) else {
+                        BZ2_bzReadClose(&bzError, bzFile)
+                        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
+                }
+            } else {
+                BZ2_bzReadClose(&bzError, bzFile)
+                throw makeError(code: 1005, message: "bzip2 read failed with code \(bzError)")
+            }
+        }
+
+        BZ2_bzReadClose(&bzError, bzFile)
+        guard bzError == BZ_OK else {
+            throw makeError(code: 1006, message: "bzip2 close failed with code \(bzError)")
+        }
+
+        Bridge.sendExtractionProgress(percentage: 80, bytesRead: sourceSize, totalBytes: sourceSize)
+
+        return tempTarURL
+    }
+
+    private static func extractTarArchive(at tarURL: URL, to destinationPath: String) throws {
+        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)
+            if sanitizedName.isEmpty {
+                continue
+            }
+
+            let entryURL = destinationRoot.appendingPathComponent(sanitizedName)
+            switch entry.info.type {
+            case .directory:
+                try fileManager.createDirectory(
+                    at: entryURL,
+                    withIntermediateDirectories: true,
+                    attributes: nil
+                )
+            case .regular:
+                guard let data = entry.data else { continue }
+                try fileManager.createDirectory(
+                    at: entryURL.deletingLastPathComponent(),
+                    withIntermediateDirectories: true,
+                    attributes: nil
+                )
+                let finalURL = remapModelFileIfNeeded(for: entryURL)
+                try data.write(to: finalURL, options: .atomic)
+            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)
+        let nestedURL = destinationURL.appendingPathComponent(destinationURL.lastPathComponent)
+
+        guard fileManager.fileExists(atPath: nestedURL.path) else { return }
+
+        let nestedFiles = try fileManager.contentsOfDirectory(at: nestedURL, includingPropertiesForKeys: nil)
+        for file in nestedFiles {
+            let target = destinationURL.appendingPathComponent(file.lastPathComponent)
+            if fileManager.fileExists(atPath: target.path) {
+                try fileManager.removeItem(at: target)
+            }
+            try fileManager.moveItem(at: file, to: target)
+        }
+
+        try fileManager.removeItem(at: nestedURL)
+    }
+
+    private static func sanitize(entryName: String) -> String {
+        var name = entryName
+
+        if name.hasPrefix("./") {
+            name.removeFirst(2)
+        }
+        while name.hasPrefix("/") {
+            name.removeFirst()
+        }
+
+        guard !name.isEmpty else { return "" }
+
+        var components = name.split(separator: "/").map(String.init)
+        guard !components.isEmpty else { return "" }
+
+        if components.count > 1 {
+            components.removeFirst()
+            name = components.joined(separator: "/")
+        } else {
+            name = components[0]
+        }
+
+        return name
+    }
+
+    private static func remapModelFileIfNeeded(for url: URL) -> URL {
+        let parent = url.deletingLastPathComponent()
+        switch url.lastPathComponent {
+        case "encoder-epoch-99-avg-1.onnx":
+            return parent.appendingPathComponent("encoder.onnx")
+        case "decoder-epoch-99-avg-1.onnx":
+            return parent.appendingPathComponent("decoder.onnx")
+        case "joiner-epoch-99-avg-1.int8.onnx":
+            return parent.appendingPathComponent("joiner.onnx")
+        default:
+            return url
+        }
+    }
+
+    private static func makeError(code: Int, message: String) -> NSError {
+        return NSError(
+            domain: "TarBz2Extractor",
+            code: code,
+            userInfo: [NSLocalizedDescriptionKey: message]
+        )
+    }
+}

package/ios/Tests/BluetoothSDKTests/G2CfwClassificationTests.swift

@@ -0,0 +1,78 @@
+@testable import BluetoothSDK
+import Foundation
+import XCTest
+
+/// Pins the stock-vs-CFW identity rules that gate the connect banner. A
+/// regression here re-opens the stuck "// Glassly connected" bug: text drawn
+/// down the stock path before classification, cleared down the CFW path
+/// after it, never leaves the glass.
+final class G2CfwClassificationTests: XCTestCase {
+    private func classify(
+        _ capability: String?, definitive: Bool = false, current: String? = nil
+    ) -> G2CfwClassification? {
+        G2CfwClassification.classify(
+            field100: capability.map { Data($0.utf8) },
+            definitive: definitive,
+            currentCapability: current
+        )
+    }
+
+    // MARK: - CFW detection
+
+    func testCfwBannerClassifiesWithFeaturesAndRevision() throws {
+        let result = try XCTUnwrap(classify("EVENCFW/15 img640 imgz rle directfb font15"))
+        XCTAssertTrue(result.isCfw)
+        XCTAssertEqual(result.capabilityString, "EVENCFW/15 img640 imgz rle directfb font15")
+        XCTAssertEqual(result.features, ["img640", "imgz", "rle", "directfb", "font15"])
+        XCTAssertEqual(result.protocolVersion, 15)
+    }
+
+    func testCfwDetectionDoesNotWaitForADefinitiveResponse() throws {
+        // The banner may ride any settings packet; requiring `definitive`
+        // would delay classification past the connect banner and re-split
+        // the draw/clear paths.
+        let result = try XCTUnwrap(classify("EVENCFW/12 img640", definitive: false))
+        XCTAssertTrue(result.isCfw)
+    }
+
+    func testCfwBannerTrimsNulTermination() throws {
+        let result = try XCTUnwrap(classify("EVENCFW/12 img640\0\0"))
+        XCTAssertEqual(result.capabilityString, "EVENCFW/12 img640")
+        XCTAssertEqual(result.features, ["img640"])
+    }
+
+    func testMalformedRevisionFallsBackToZero() throws {
+        let result = try XCTUnwrap(classify("EVENCFW/beta img640"))
+        XCTAssertTrue(result.isCfw)
+        XCTAssertEqual(result.protocolVersion, 0)
+    }
+
+    // MARK: - Stock classification
+
+    func testDefinitiveAbsenceClassifiesStock() throws {
+        let result = try XCTUnwrap(classify(nil, definitive: true))
+        XCTAssertFalse(result.isCfw)
+        XCTAssertEqual(result, .stock)
+    }
+
+    func testDefinitiveNonCfwPayloadClassifiesStock() throws {
+        let result = try XCTUnwrap(classify("something-else", definitive: true))
+        XCTAssertEqual(result, .stock)
+    }
+
+    // MARK: - Packets that prove nothing
+
+    func testNonDefinitiveAbsenceLeavesConnectionUnclassified() {
+        // Individual settings packets can legitimately omit field 100 or
+        // arrive truncated — only a deviceReceiveRequest response is proof.
+        XCTAssertNil(classify(nil, definitive: false))
+        XCTAssertNil(classify("garbage", definitive: false))
+    }
+
+    func testDefinitiveAbsenceNeverDowngradesDetectedCfw() {
+        // Firmware identity is connection-sticky: downgrading would
+        // reinterpret an installed mode-6 carrier as a stock BMP.
+        XCTAssertNil(classify(nil, definitive: true, current: "EVENCFW/15 img640"))
+        XCTAssertNil(classify("garbage", definitive: true, current: "EVENCFW/15 img640"))
+    }
+}