@mentra/bluetooth-sdk 0.1.9 → 0.1.11

package/ios/LocalPhotoUploadServer.swift

@@ -14,6 +14,8 @@ final class LocalPhotoUploadServer {
   private let onLog: (String) -> Void
   private let onUpload: (PhotoUpload) -> Void
   private var listener: NWListener?
+  private var listenerGeneration = 0
+  private(set) var activePort: UInt16?
 
   init(onLog: @escaping (String) -> Void, onUpload: @escaping (PhotoUpload) -> Void) {
     self.onLog = onLog
@@ -23,6 +25,10 @@ final class LocalPhotoUploadServer {
   }
 
   func start(port: UInt16) throws -> UInt16 {
+    if listener != nil, activePort == port {
+      onLog("Already listening on 0.0.0.0:\(port)")
+      return port
+    }
     stop()
     try FileManager.default.createDirectory(
       at: uploadDirectory,
@@ -36,21 +42,30 @@ final class LocalPhotoUploadServer {
     }
 
     let listener = try NWListener(using: parameters, on: endpointPort)
+    listenerGeneration += 1
+    let generation = listenerGeneration
     let started = DispatchSemaphore(value: 0)
     var startError: Error?
     var isReady = false
 
     listener.stateUpdateHandler = { [weak self] state in
+      guard let self, self.listenerGeneration == generation else {
+        return
+      }
       switch state {
       case .ready:
         isReady = true
-        self?.onLog("Listening on 0.0.0.0:\(port)")
+        self.activePort = port
+        self.onLog("Listening on 0.0.0.0:\(port)")
         started.signal()
       case .failed(let error):
         startError = error
-        self?.onLog("Photo receiver failed on \(port): \(error)")
+        self.activePort = nil
+        self.listener = nil
+        self.onLog("Photo receiver failed on \(port): \(error)")
         started.signal()
       case .cancelled:
+        self.activePort = nil
         if !isReady {
           startError = PhotoUploadServerError("Listener cancelled")
           started.signal()
@@ -68,6 +83,8 @@ final class LocalPhotoUploadServer {
     listener.start(queue: queue)
 
     if started.wait(timeout: .now() + 2) == .timedOut {
+      self.listener = nil
+      listener.cancel()
       throw PhotoUploadServerError("Timed out starting listener")
     }
     if let startError {
@@ -80,8 +97,10 @@ final class LocalPhotoUploadServer {
   }
 
   func stop() {
+    listenerGeneration += 1
     listener?.cancel()
     listener = nil
+    activePort = nil
   }
 
   private func handle(_ connection: NWConnection) {
@@ -97,6 +116,7 @@ final class LocalPhotoUploadServer {
         return
       }
       if let error {
+        state.multipartParser?.cleanup()
         self.onLog("request failed: \(error.localizedDescription)")
         connection.cancel()
         return
@@ -110,12 +130,22 @@ final class LocalPhotoUploadServer {
           return
         }
       } catch {
+        state.multipartParser?.cleanup()
         self.onLog("request failed: \(error.localizedDescription)")
-        self.writeJson(connection, status: 500, body: #"{"ok":false,"error":"server_error"}"#)
+        if let uploadError = error as? PhotoUploadServerError {
+          self.writeJson(
+            connection,
+            status: 400,
+            body: #"{"ok":false,"error":\#(self.jsonString(uploadError.localizedDescription))}"#
+          )
+        } else {
+          self.writeJson(connection, status: 500, body: #"{"ok":false,"error":"server_error"}"#)
+        }
         return
       }
 
       if isComplete {
+        state.multipartParser?.cleanup()
         self.writeJson(connection, status: 400, body: #"{"ok":false,"error":"incomplete_request"}"#)
         return
       }
@@ -140,7 +170,6 @@ final class LocalPhotoUploadServer {
       }
       let request = HttpRequest.parse(headerText)
       state.request = request
-      state.bodyStartIndex = headerRange.upperBound
       onLog("\(request.method) \(request.path)")
 
       if request.method == "GET", request.path == "/" || request.path == "/health" {
@@ -163,30 +192,51 @@ final class LocalPhotoUploadServer {
       }
 
       state.contentLength = contentLength
+      guard let boundary = multipartBoundary(request.headers["content-type"] ?? "") else {
+        writeJson(connection, status: 400, body: #"{"ok":false,"error":"multipart_boundary_required"}"#)
+        return true
+      }
+      state.multipartParser = MultipartStreamParser(
+        boundary: boundary,
+        uploadDirectory: uploadDirectory
+      )
       if request.headers["expect"]?.localizedCaseInsensitiveContains("100-continue") == true {
         write(connection, text: "HTTP/1.1 100 Continue\r\n\r\n", closeAfterSend: false)
       }
+
+      let bodyFragment = Data(state.buffer[headerRange.upperBound..<state.buffer.endIndex])
+      state.buffer.removeAll(keepingCapacity: true)
+      try appendBodyFragment(bodyFragment, to: state)
     }
 
-    guard let request = state.request, let bodyStartIndex = state.bodyStartIndex else {
+    guard let request = state.request else {
       return false
     }
-    guard state.buffer.count >= bodyStartIndex + state.contentLength else {
+    if !state.buffer.isEmpty {
+      let bodyFragment = state.buffer
+      state.buffer.removeAll(keepingCapacity: true)
+      try appendBodyFragment(bodyFragment, to: state)
+    }
+
+    guard state.multipartParser?.isComplete == true else {
+      if state.bodyBytesReceived >= state.contentLength {
+        state.multipartParser?.cleanup()
+        writeJson(connection, status: 400, body: #"{"ok":false,"error":"multipart_boundary_missing"}"#)
+        return true
+      }
       return false
     }
 
-    let bodyEndIndex = bodyStartIndex + state.contentLength
-    let body = Data(state.buffer[bodyStartIndex..<bodyEndIndex])
     let contentType = request.headers["content-type"] ?? ""
     onLog("headers contentType=\(contentType) contentLength=\(state.contentLength)")
 
-    guard let boundary = multipartBoundary(contentType) else {
-      writeJson(connection, status: 400, body: #"{"ok":false,"error":"multipart_boundary_required"}"#)
+    guard let parsed = state.multipartParser?.parsedMultipart() else {
+      state.multipartParser?.cleanup()
+      writeJson(connection, status: 400, body: #"{"ok":false,"error":"incomplete_request"}"#)
       return true
     }
-
-    let parsed = parseMultipart(body, boundary: boundary)
-    guard let photoBytes = parsed.files["photo"] ?? parsed.files.values.first else {
+    guard let photoPart = parsed.files["photo"] ?? parsed.files.values.first else {
+      parsed.deleteFiles()
       writeJson(connection, status: 400, body: #"{"ok":false,"error":"photo_field_required"}"#)
       return true
     }
@@ -194,23 +244,50 @@ final class LocalPhotoUploadServer {
     let requestId = parsed.fields["requestId"] ?? parsed.fields["request_id"]
     let filename = safeFilePart(requestId ?? "photo-\(Int(Date().timeIntervalSince1970 * 1000))")
     let photoFile = uploadDirectory.appendingPathComponent("\(filename).jpg")
-    try photoBytes.write(to: photoFile, options: .atomic)
-
-    onLog("upload fields=\(parsed.fields.keys.joined(separator: ",")) requestId=\(requestId ?? "") bytes=\(photoBytes.count) saved=\(photoFile.path)")
-    onUpload(PhotoUpload(
+    var didMovePhoto = false
+    defer {
+      if didMovePhoto {
+        parsed.deleteFiles(except: photoFile)
+      } else {
+        parsed.deleteFiles()
+        try? FileManager.default.removeItem(at: photoFile)
+      }
+    }
+    try moveFile(photoPart.file, to: photoFile)
+    didMovePhoto = true
+    let upload = PhotoUpload(
       requestId: requestId,
       photoFile: photoFile,
-      byteCount: photoBytes.count,
+      byteCount: photoPart.byteCount,
       fields: parsed.fields
-    ))
+    )
+
+    onLog("upload fields=\(parsed.fields.keys.joined(separator: ",")) requestId=\(requestId ?? "") bytes=\(photoPart.byteCount) saved=\(photoFile.path)")
     writeJson(
       connection,
       status: 200,
-      body: #"{"ok":true,"requestId":"\#(jsonEscape(requestId ?? ""))","bytes":\#(photoBytes.count)}"#
+      body: #"{"ok":true,"requestId":\#(jsonString(requestId ?? "")),"bytes":\#(photoPart.byteCount)}"#
     )
+    queue.async { [onUpload] in
+      onUpload(upload)
+    }
     return true
   }
 
+  private func appendBodyFragment(_ data: Data, to state: RequestReadState) throws {
+    guard !data.isEmpty else {
+      return
+    }
+    let remaining = state.contentLength - state.bodyBytesReceived
+    guard remaining > 0 else {
+      return
+    }
+    let acceptedCount = min(data.count, remaining)
+    let accepted = Data(data[data.startIndex..<data.startIndex + acceptedCount])
+    state.bodyBytesReceived += acceptedCount
+    try state.multipartParser?.append(accepted)
+  }
+
   private func writeJson(_ connection: NWConnection, status: Int, body: String) {
     let reason: String
     switch status {
@@ -229,13 +306,12 @@ final class LocalPhotoUploadServer {
     }
 
     let bodyData = Data(body.utf8)
-    let header = """
-      HTTP/1.1 \(status) \(reason)\r
-      Content-Type: application/json\r
-      Content-Length: \(bodyData.count)\r
-      Connection: close\r
-      \r
-      """
+    let header =
+      "HTTP/1.1 \(status) \(reason)\r\n" +
+      "Content-Type: application/json\r\n" +
+      "Content-Length: \(bodyData.count)\r\n" +
+      "Connection: close\r\n" +
+      "\r\n"
     var response = Data(header.utf8)
     response.append(bodyData)
     connection.send(content: response, completion: .contentProcessed { _ in
@@ -255,61 +331,6 @@ final class LocalPhotoUploadServer {
     })
   }
 
-  private func parseMultipart(_ body: Data, boundary: String) -> ParsedMultipart {
-    let marker = Data("--\(boundary)".utf8)
-    let nextMarkerPrefix = Data("\r\n--\(boundary)".utf8)
-    let headerDelimiter = Data([13, 10, 13, 10])
-    let crlf = Data([13, 10])
-    let closing = Data([45, 45])
-    var fields: [String: String] = [:]
-    var files: [String: Data] = [:]
-    var cursor = body.startIndex
-
-    while let markerRange = body.range(of: marker, options: [], in: cursor..<body.endIndex) {
-      var partStart = markerRange.upperBound
-      if body.starts(with: closing, at: partStart) {
-        break
-      }
-      if body.starts(with: crlf, at: partStart) {
-        partStart += crlf.count
-      }
-      guard
-        let headerRange = body.range(of: headerDelimiter, options: [], in: partStart..<body.endIndex)
-      else {
-        break
-      }
-
-      let dataStart = headerRange.upperBound
-      guard
-        let nextMarkerRange = body.range(
-          of: nextMarkerPrefix,
-          options: [],
-          in: dataStart..<body.endIndex
-        )
-      else {
-        break
-      }
-
-      let headerData = body[partStart..<headerRange.lowerBound]
-      let headerBlock = String(data: headerData, encoding: .isoLatin1) ?? ""
-      let disposition = headerBlock
-        .components(separatedBy: "\r\n")
-        .first { $0.caseInsensitiveHasPrefix("Content-Disposition:") } ?? ""
-      if let name = firstCapture(#"name="([^"]+)""#, in: disposition) {
-        let bytes = Data(body[dataStart..<nextMarkerRange.lowerBound])
-        if firstCapture(#"filename="([^"]*)""#, in: disposition) != nil {
-          files[name] = bytes
-        } else {
-          fields[name] = String(data: bytes, encoding: .utf8)?
-            .trimmingCharacters(in: .whitespacesAndNewlines)
-        }
-      }
-      cursor = nextMarkerRange.lowerBound + crlf.count
-    }
-
-    return ParsedMultipart(fields: fields, files: files)
-  }
-
   private func multipartBoundary(_ contentType: String) -> String? {
     contentType
       .split(separator: ";")
@@ -321,28 +342,32 @@ final class LocalPhotoUploadServer {
       .trimmingCharacters(in: CharacterSet(charactersIn: "\""))
   }
 
-  private func firstCapture(_ pattern: String, in text: String) -> String? {
-    guard
-      let regex = try? NSRegularExpression(pattern: pattern),
-      let match = regex.firstMatch(in: text, range: NSRange(text.startIndex..., in: text)),
-      match.numberOfRanges > 1,
-      let range = Range(match.range(at: 1), in: text)
-    else {
-      return nil
-    }
-    return String(text[range])
-  }
-
   private func safeFilePart(_ value: String) -> String {
     let allowed = CharacterSet(charactersIn: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789._-")
     let sanitized = String(value.unicodeScalars.map { allowed.contains($0) ? Character($0) : "_" })
     return sanitized.isEmpty ? "photo" : sanitized
   }
 
-  private func jsonEscape(_ value: String) -> String {
-    value
-      .replacingOccurrences(of: "\\", with: "\\\\")
-      .replacingOccurrences(of: "\"", with: "\\\"")
+  private func jsonString(_ value: String) -> String {
+    guard
+      let data = try? JSONSerialization.data(withJSONObject: [value]),
+      let json = String(data: data, encoding: .utf8)
+    else {
+      return #""""#
+    }
+    return String(json.dropFirst().dropLast())
+  }
+
+  private func moveFile(_ source: URL, to destination: URL) throws {
+    if FileManager.default.fileExists(atPath: destination.path) {
+      try FileManager.default.removeItem(at: destination)
+    }
+    do {
+      try FileManager.default.moveItem(at: source, to: destination)
+    } catch {
+      try FileManager.default.copyItem(at: source, to: destination)
+      try? FileManager.default.removeItem(at: source)
+    }
   }
 
   private struct HttpRequest {
@@ -355,28 +380,266 @@ final class LocalPhotoUploadServer {
       let requestParts = lines.first?.split(separator: " ").map(String.init) ?? []
       let method = requestParts.first?.uppercased() ?? ""
       let path = requestParts.dropFirst().first?.split(separator: "?").first.map(String.init) ?? ""
-      let headers: [String: String] = Dictionary(uniqueKeysWithValues: lines.dropFirst().compactMap { line in
+      var headers: [String: String] = [:]
+      for line in lines.dropFirst() {
         guard let separator = line.firstIndex(of: ":") else {
-          return nil
+          continue
         }
-        let key = line[..<separator].lowercased()
+        let key = String(line[..<separator].lowercased())
         let value = line[line.index(after: separator)...].trimmingCharacters(in: .whitespaces)
-        return (String(key), value)
-      })
+        headers[key] = value
+      }
       return HttpRequest(method: method, path: path, headers: headers)
     }
   }
 
+  private final class MultipartStreamParser {
+    private enum Stage {
+      case initialBoundary
+      case partHeaders
+      case partBody
+      case boundarySuffix
+      case complete
+    }
+
+    private let marker: String
+    private let delimiter: Data
+    private let crlf = Data([13, 10])
+    private let headerDelimiter = Data([13, 10, 13, 10])
+    private let uploadDirectory: URL
+    private var stage: Stage = .initialBoundary
+    private var buffer = Data()
+    private var currentPart: PartWriter?
+    private var fields: [String: String] = [:]
+    private var files: [String: StreamedFile] = [:]
+
+    var isComplete: Bool {
+      stage == .complete
+    }
+
+    init(boundary: String, uploadDirectory: URL) {
+      marker = "--\(boundary)"
+      delimiter = Data("\r\n--\(boundary)".utf8)
+      self.uploadDirectory = uploadDirectory
+    }
+
+    func append(_ data: Data) throws {
+      guard !isComplete else {
+        return
+      }
+      buffer.append(data)
+      try processBuffer()
+    }
+
+    func parsedMultipart() -> ParsedMultipart? {
+      guard isComplete else {
+        return nil
+      }
+      return ParsedMultipart(fields: fields, files: files)
+    }
+
+    func cleanup() {
+      currentPart?.cleanup()
+      files.values.forEach { try? FileManager.default.removeItem(at: $0.file) }
+    }
+
+    private func processBuffer() throws {
+      while true {
+        switch stage {
+        case .initialBoundary:
+          guard let line = try popLine() else {
+            return
+          }
+          if line == "\(marker)--" {
+            stage = .complete
+            return
+          }
+          guard line == marker else {
+            throw PhotoUploadServerError("multipart_boundary_missing")
+          }
+          stage = .partHeaders
+
+        case .partHeaders:
+          guard let headerBlock = try popHeaders() else {
+            return
+          }
+          currentPart = try PartWriter(headerBlock: headerBlock, uploadDirectory: uploadDirectory)
+          stage = .partBody
+
+        case .partBody:
+          guard let currentPart else {
+            throw PhotoUploadServerError("multipart_part_missing")
+          }
+          if let delimiterRange = buffer.range(of: delimiter) {
+            let content = Data(buffer[buffer.startIndex..<delimiterRange.lowerBound])
+            try currentPart.write(content)
+            buffer.removeSubrange(buffer.startIndex..<delimiterRange.upperBound)
+            try currentPart.finish(fields: &fields, files: &files)
+            self.currentPart = nil
+            stage = .boundarySuffix
+            continue
+          }
+
+          let keepBytes = max(delimiter.count - 1, 0)
+          if buffer.count > keepBytes {
+            let writeCount = buffer.count - keepBytes
+            let content = Data(buffer[buffer.startIndex..<buffer.startIndex + writeCount])
+            try currentPart.write(content)
+            buffer.removeSubrange(buffer.startIndex..<buffer.startIndex + writeCount)
+          }
+          return
+
+        case .boundarySuffix:
+          guard buffer.count >= 2 else {
+            return
+          }
+          if buffer.starts(with: Data("--".utf8), at: buffer.startIndex) {
+            buffer.removeSubrange(buffer.startIndex..<buffer.startIndex + 2)
+            stage = .complete
+            return
+          }
+          if buffer.starts(with: crlf, at: buffer.startIndex) {
+            buffer.removeSubrange(buffer.startIndex..<buffer.startIndex + crlf.count)
+            stage = .partHeaders
+            continue
+          }
+          throw PhotoUploadServerError("invalid multipart boundary suffix")
+
+        case .complete:
+          return
+        }
+      }
+    }
+
+    private func popLine() throws -> String? {
+      guard let lineRange = buffer.range(of: crlf) else {
+        if buffer.count > LocalPhotoUploadServer.maxPartHeaderBytes {
+          throw PhotoUploadServerError("multipart line too large")
+        }
+        return nil
+      }
+      let lineData = Data(buffer[buffer.startIndex..<lineRange.lowerBound])
+      buffer.removeSubrange(buffer.startIndex..<lineRange.upperBound)
+      return String(data: lineData, encoding: .isoLatin1)
+    }
+
+    private func popHeaders() throws -> String? {
+      guard let headerRange = buffer.range(of: headerDelimiter) else {
+        if buffer.count > LocalPhotoUploadServer.maxPartHeaderBytes {
+          throw PhotoUploadServerError("multipart headers too large")
+        }
+        return nil
+      }
+      let headerData = Data(buffer[buffer.startIndex..<headerRange.lowerBound])
+      buffer.removeSubrange(buffer.startIndex..<headerRange.upperBound)
+      return String(data: headerData, encoding: .isoLatin1)
+    }
+
+    private static func firstCapture(_ pattern: String, in text: String) -> String? {
+      guard
+        let regex = try? NSRegularExpression(pattern: pattern),
+        let match = regex.firstMatch(in: text, range: NSRange(text.startIndex..., in: text)),
+        match.numberOfRanges > 1,
+        let range = Range(match.range(at: 1), in: text)
+      else {
+        return nil
+      }
+      return String(text[range])
+    }
+
+    private final class PartWriter {
+      private let name: String?
+      private let file: URL?
+      private var fileHandle: FileHandle?
+      private var fieldData = Data()
+      private var byteCount = 0
+
+      init(headerBlock: String, uploadDirectory: URL) throws {
+        let disposition = headerBlock
+          .components(separatedBy: "\r\n")
+          .first { $0.caseInsensitiveHasPrefix("Content-Disposition:") } ?? ""
+        name = MultipartStreamParser.firstCapture(#"name="([^"]+)""#, in: disposition)
+        if MultipartStreamParser.firstCapture(#"filename="([^"]*)""#, in: disposition) != nil {
+          let tempFile = uploadDirectory
+            .appendingPathComponent("upload-\(Int(Date().timeIntervalSince1970 * 1000))-\(UUID().uuidString).tmp")
+          FileManager.default.createFile(atPath: tempFile.path, contents: nil)
+          file = tempFile
+          fileHandle = try FileHandle(forWritingTo: tempFile)
+        } else {
+          file = nil
+        }
+      }
+
+      func write(_ data: Data) throws {
+        guard !data.isEmpty else {
+          return
+        }
+        byteCount += data.count
+        if let fileHandle {
+          fileHandle.write(data)
+        } else {
+          guard fieldData.count + data.count <= LocalPhotoUploadServer.maxFieldBytes else {
+            throw PhotoUploadServerError("multipart field too large")
+          }
+          fieldData.append(data)
+        }
+      }
+
+      func finish(fields: inout [String: String], files: inout [String: StreamedFile]) throws {
+        fileHandle?.closeFile()
+        fileHandle = nil
+        guard let name else {
+          cleanup()
+          return
+        }
+        if let file {
+          if let previous = files.updateValue(StreamedFile(file: file, byteCount: byteCount), forKey: name) {
+            try? FileManager.default.removeItem(at: previous.file)
+          }
+        } else {
+          fields[name] = String(data: fieldData, encoding: .utf8)?
+            .trimmingCharacters(in: .whitespacesAndNewlines)
+        }
+      }
+
+      func cleanup() {
+        fileHandle?.closeFile()
+        fileHandle = nil
+        if let file {
+          try? FileManager.default.removeItem(at: file)
+        }
+      }
+    }
+  }
+
   private final class RequestReadState {
     var buffer = Data()
     var request: HttpRequest?
-    var bodyStartIndex: Data.Index?
     var contentLength = 0
+    var bodyBytesReceived = 0
+    var multipartParser: MultipartStreamParser?
   }
 
   private struct ParsedMultipart {
     let fields: [String: String]
-    let files: [String: Data]
+    let files: [String: StreamedFile]
+
+    func deleteFiles() {
+      files.values.forEach { try? FileManager.default.removeItem(at: $0.file) }
+    }
+
+    func deleteFiles(except keptFile: URL) {
+      files.values.forEach { part in
+        if part.file.path != keptFile.path {
+          try? FileManager.default.removeItem(at: part.file)
+        }
+      }
+    }
+  }
+
+  private struct StreamedFile {
+    let file: URL
+    let byteCount: Int
   }
 
   private struct PhotoUploadServerError: LocalizedError {
@@ -392,6 +655,8 @@ final class LocalPhotoUploadServer {
   }
 
   private static let maxHeaderBytes = 64 * 1024
+  private static let maxPartHeaderBytes = 64 * 1024
+  private static let maxFieldBytes = 64 * 1024
   private static let maxUploadBytes = 25 * 1024 * 1024
 }
 

package/ios/MentraBluetoothSDK.podspec

@@ -55,6 +55,8 @@ Pod::Spec.new do |s|
     "Source/**/*.{h,m,mm,swift,hpp,cpp,c}",
     "Packages/CoreObjC/**/*.{h,m,mm,hpp,cpp,c}",
     "Packages/SherpaOnnx/SherpaOnnx.swift",
+    "Packages/SherpaOnnx/sherpa-onnx.xcframework/ios-arm64/Headers/**/*.{h,hpp}",
+    "Packages/VAD/**/*.swift",
     "Packages/SherpaOnnx/sherpa-onnx.xcframework/Headers/**/*.{h,hpp}",
     "Packages/libbz2/shim.h"
   ]
@@ -70,7 +72,7 @@ Pod::Spec.new do |s|
     "Packages/CoreObjC/lc3_cpp.h",
     "Packages/CoreObjC/mdct_neon.h",
     "Packages/CoreObjC/ltpf_neon.h",
-    "Packages/SherpaOnnx/sherpa-onnx.xcframework/Headers/sherpa-onnx/c-api/cxx-api.h",
+    "Packages/SherpaOnnx/sherpa-onnx.xcframework/ios-arm64/Headers/sherpa-onnx/c-api/cxx-api.h",
     "Packages/libbz2/shim.h",
     "Source/Bridging-Header.h"
   ]