snapback4-expo 0.2.22 → 0.2.24

package/ios/MediaFiles.swift

@@ -0,0 +1,89 @@
+import Foundation
+
+// @ref LLP 3000.007#8 — ordinary media stays in its device store's private cache
+// The module serializes access with its existing device lock.
+final class MediaFiles {
+  enum Failure: String, Error, LocalizedError {
+    case invalidIdentity = "invalid media id or closed device"
+    case invalidBytes = "invalid media bytes"
+    var errorDescription: String? { rawValue }
+  }
+
+  private var directory: URL?
+  init(directory: URL) { self.directory = directory }
+  func close() { directory = nil }
+
+  private func base(_ id: String) throws -> URL {
+    guard let directory, !id.isEmpty,
+      id.utf8.allSatisfy({ ($0 >= 48 && $0 <= 57) || ($0 >= 65 && $0 <= 90) || ($0 >= 97 && $0 <= 122) })
+    else { throw Failure.invalidIdentity }
+    return directory.appendingPathComponent(id)
+  }
+
+  // Match the server's supported brands in the initial ftyp box. This is a
+  // filename hint for already-admitted bytes, not another media admission rule.
+  private func isMP4(_ bytes: Data) -> Bool {
+    guard bytes.count >= 12, bytes[4..<8].elementsEqual("ftyp".utf8) else { return false }
+    let size32 = bytes.prefix(4).reduce(UInt64(0)) { ($0 << 8) | UInt64($1) }
+    let header = size32 == 1 ? 16 : 8
+    guard bytes.count >= header else { return false }
+    let size = size32 == 0 ? UInt64(bytes.count) : size32 == 1
+      ? bytes[8..<16].reduce(UInt64(0)) { ($0 << 8) | UInt64($1) } : size32
+    guard size >= UInt64(header), size <= UInt64(bytes.count) else { return false }
+    let brands = ["isom", "iso2", "iso5", "iso6", "mp41", "mp42", "avc1", "M4V ", "qt  "]
+    for offset in stride(from: header, to: Int(size) - 3, by: 4) where offset != header + 4 {
+      if let brand = String(data: bytes[offset..<offset + 4], encoding: .ascii), brands.contains(brand) { return true }
+    }
+    return false
+  }
+
+  private func resolve(_ id: String) throws -> URL {
+    let file = try base(id), video = file.appendingPathExtension("mp4")
+    let manager = FileManager.default
+    if manager.fileExists(atPath: file.path) {
+      // A bare file is either a legacy entry or the latest atomic write. It
+      // wins if interruption left both variants; stale bytes cannot reappear.
+      if isMP4(try Data(contentsOf: file, options: .mappedIfSafe)) {
+        if manager.fileExists(atPath: video.path) {
+          _ = try manager.replaceItemAt(video, withItemAt: file, options: .usingNewMetadataOnly)
+        } else { try manager.moveItem(at: file, to: video) }
+        return video
+      }
+      if manager.fileExists(atPath: video.path) { try manager.removeItem(at: video) }
+      return file
+    }
+    return manager.fileExists(atPath: video.path) ? video : file
+  }
+
+  func read(_ id: String) throws -> String? {
+    let file = try resolve(id)
+    guard FileManager.default.fileExists(atPath: file.path) else { return nil }
+    return try Data(contentsOf: file).map { String(format: "%02x", $0) }.joined()
+  }
+
+  func write(_ id: String, hex: String) throws {
+    let file = try base(id), chars = Array(hex.utf8)
+    guard chars.count % 2 == 0 else { throw Failure.invalidBytes }
+    var bytes = Data(capacity: chars.count / 2)
+    for i in stride(from: 0, to: chars.count, by: 2) {
+      guard let byte = UInt8(String(bytes: chars[i...i + 1], encoding: .utf8) ?? "", radix: 16) else { throw Failure.invalidBytes }
+      bytes.append(byte)
+    }
+    try FileManager.default.createDirectory(at: file.deletingLastPathComponent(), withIntermediateDirectories: true)
+    // One atomic commit point regardless of format. Resolution renames this
+    // same file within the cache; it never creates a separate display copy.
+    try bytes.write(to: file, options: .atomic)
+    _ = try resolve(id)
+  }
+
+  func remove(_ id: String) throws {
+    let file = try base(id)
+    // Remove the possible shadow first. If it cannot be removed, leave the
+    // authoritative bare file in place and report the error for retry.
+    for variant in [file.appendingPathExtension("mp4"), file] {
+      if FileManager.default.fileExists(atPath: variant.path) { try FileManager.default.removeItem(at: variant) }
+    }
+  }
+
+  func uri(_ id: String) throws -> String { try resolve(id).absoluteString }
+}

package/ios/Snapback4Device.xcframework/Info.plist

@@ -10,7 +10,7 @@
 			<key>HeadersPath</key>
 			<string>Headers</string>
 			<key>LibraryIdentifier</key>
-			<string>ios-arm64-simulator</string>
+			<string>ios-arm64</string>
 			<key>LibraryPath</key>
 			<string>libsnapback4_device.a</string>
 			<key>SupportedArchitectures</key>
@@ -19,8 +19,6 @@
 			</array>
 			<key>SupportedPlatform</key>
 			<string>ios</string>
-			<key>SupportedPlatformVariant</key>
-			<string>simulator</string>
 		</dict>
 		<dict>
 			<key>BinaryPath</key>
@@ -28,7 +26,7 @@
 			<key>HeadersPath</key>
 			<string>Headers</string>
 			<key>LibraryIdentifier</key>
-			<string>ios-arm64</string>
+			<string>ios-arm64-simulator</string>
 			<key>LibraryPath</key>
 			<string>libsnapback4_device.a</string>
 			<key>SupportedArchitectures</key>
@@ -37,6 +35,8 @@
 			</array>
 			<key>SupportedPlatform</key>
 			<string>ios</string>
+			<key>SupportedPlatformVariant</key>
+			<string>simulator</string>
 		</dict>
 	</array>
 	<key>CFBundlePackageType</key>

package/ios/Snapback4Module.swift

@@ -6,7 +6,7 @@ import Snapback4Device
 // link and the transport. Handles are small integers the module hands out.
 public final class Snapback4Module: Module {
   private var devices: [Int: OpaquePointer] = [:]
-  private var mediaDirectories: [Int: URL] = [:]
+  private var mediaFiles: [Int: MediaFiles] = [:]
   private var nextHandle = 1
   private let lock = NSLock()
 
@@ -37,7 +37,7 @@ public final class Snapback4Module: Module {
       let handle = self.nextHandle
       self.nextHandle += 1
       self.devices[handle] = device
-      self.mediaDirectories[handle] = URL(fileURLWithPath: path + ".media", isDirectory: true)
+      self.mediaFiles[handle] = MediaFiles(directory: URL(fileURLWithPath: path + ".media", isDirectory: true))
       return handle
     }
 
@@ -57,52 +57,33 @@ public final class Snapback4Module: Module {
 
     // @ref LLP 3000.007#8 — the opener owns ordinary media in Documents
     AsyncFunction("readAsset") { (handle: Int, id: String) -> String? in
-      self.lock.lock()
-      defer { self.lock.unlock() }
-      let file = try self.assetFile(handle, id)
-      guard FileManager.default.fileExists(atPath: file.path) else { return nil }
-      return try Data(contentsOf: file).map { String(format: "%02x", $0) }.joined()
+      try self.withMedia(handle) { try $0.read(id) }
     }
     AsyncFunction("writeAsset") { (handle: Int, id: String, hex: String) in
-      self.lock.lock()
-      defer { self.lock.unlock() }
-      let file = try self.assetFile(handle, id)
-      let chars = Array(hex.utf8)
-      guard chars.count % 2 == 0 else { throw Snapback4OpenException("invalid media bytes") }
-      var bytes = Data(capacity: chars.count / 2)
-      for i in stride(from: 0, to: chars.count, by: 2) {
-        guard let byte = UInt8(String(bytes: chars[i...i+1], encoding: .utf8) ?? "", radix: 16) else { throw Snapback4OpenException("invalid media bytes") }
-        bytes.append(byte)
-      }
-      try FileManager.default.createDirectory(at: file.deletingLastPathComponent(), withIntermediateDirectories: true)
-      try bytes.write(to: file, options: .atomic)
+      try self.withMedia(handle) { try $0.write(id, hex: hex) }
     }
     AsyncFunction("removeAsset") { (handle: Int, id: String) in
-      self.lock.lock()
-      defer { self.lock.unlock() }
-      let file = try self.assetFile(handle, id)
-      if FileManager.default.fileExists(atPath: file.path) { try FileManager.default.removeItem(at: file) }
+      try self.withMedia(handle) { try $0.remove(id) }
     }
     Function("assetUri") { (handle: Int, id: String) -> String in
-      self.lock.lock()
-      defer { self.lock.unlock() }
-      return try self.assetFile(handle, id).absoluteString
+      try self.withMedia(handle) { try $0.uri(id) }
     }
 
     Function("close") { (handle: Int) in
       self.lock.lock()
       defer { self.lock.unlock() }
-      self.mediaDirectories.removeValue(forKey: handle)
+      self.mediaFiles.removeValue(forKey: handle)?.close()
       if let device = self.devices.removeValue(forKey: handle) {
         sb4_close(device)
       }
     }
   }
-  private func assetFile(_ handle: Int, _ id: String) throws -> URL {
-    guard let directory = mediaDirectories[handle], !id.isEmpty,
-      id.utf8.allSatisfy({ ($0 >= 48 && $0 <= 57) || ($0 >= 65 && $0 <= 90) || ($0 >= 97 && $0 <= 122) })
-    else { throw Snapback4OpenException("invalid media id or closed device") }
-    return directory.appendingPathComponent(id)
+  private func withMedia<T>(_ handle: Int, _ body: (MediaFiles) throws -> T) throws -> T {
+    lock.lock()
+    defer { lock.unlock() }
+    guard let files = mediaFiles[handle] else { throw Snapback4OpenException("invalid media id or closed device") }
+    do { return try body(files) }
+    catch let failure as MediaFiles.Failure { throw Snapback4OpenException(failure.rawValue) }
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "snapback4-expo",
-  "version": "0.2.22",
+  "version": "0.2.24",
   "type": "module",
   "description": "Snapback 4's native module for Expo: the device in Rust (the partition in its own SQLite, the stream applied, the outbox kept, queries and predictions answered) behind one JSON call, and the opener `snapback4/native` takes.",
   "main": "src/index.ts",