Utilize core-based synchronisation

MapboxVision/Core/FileSystem.swift

@@ -0,0 +1,26 @@
+import Foundation
+
+final class FileSystem: NSObject {
+    private let archiver: Archiver
+
+    init(archiver: Archiver) {
+        self.archiver = archiver
+    }
+}
+
+extension FileSystem: FileSystemInterface {
+    func archiveFiles(filePaths: [String], archivePath: String, callback: @escaping SuccessCallback) {
+        DispatchQueue.global(qos: .utility).async {
+            do {
+                try self.archiver.archive(filePaths.map(URL.init(fileURLWithPath:)),
+                                                   destination: URL(fileURLWithPath: archivePath))
+            } catch {
+                assertionFailure("ERROR: archiving failed with error: \(error.localizedDescription)")
+                callback(false)
+                return
+            }
+
+            callback(true)
+        }
+    }
+}

MapboxVision/Core/Media.swift

@@ -0,0 +1,40 @@
+import Foundation
+
+final class Media: NSObject {
+    private let recorder: FrameRecorder
+    private let videoTrimmer: VideoTrimmer
+
+    init(recorder: FrameRecorder, videoTrimmer: VideoTrimmer) {
+        self.recorder = recorder
+        self.videoTrimmer = videoTrimmer
+    }
+}
+
+extension Media: MediaInterface {
+    func startVideoRecording(filePath: String) {
+        recorder.startRecording(to: filePath, settings: .lowQuality)
+    }
+
+    func stopVideoRecording() {
+        recorder.stopRecording()
+    }
+
+    func makeVideoClips(inputFilePath: String, clips: [VideoClip], callback: @escaping SuccessCallback) {
+        var success = true
+        let group = DispatchGroup()
+
+        for clip in clips {
+            group.enter()
+            videoTrimmer.trimVideo(source: inputFilePath, clip: clip) { error in
+                if error != nil {
+                    success = false
+                }
+                group.leave()
+            }
+        }
+
+        group.notify(queue: DispatchQueue.global(qos: .utility)) {
+            callback(success)
+        }
+    }
+}

MapboxVision/Core/Telemetry.swift

@@ -0,0 +1,30 @@
+import Foundation
+
+typealias TelemetryFileMetadata = [String: String]
+
+final class Telemetry: NSObject {
+    private let networkClient: NetworkClient
+
+    init(networkClient: NetworkClient) {
+        self.networkClient = networkClient
+    }
+}
+
+extension Telemetry: TelemetryInterface {
+    func setSyncUrl(_ url: String) {
+        networkClient.set(baseURL: URL(string: url))
+    }
+
+    func sendTelemetry(name: String, entries: [TelemetryEntry]) {
+        let entries = Dictionary(entries.map { ($0.key, $0.value) }) { first, _ in
+            assertionFailure("Duplicated key in telemetry entries.")
+            return first
+        }
+
+        networkClient.sendEvent(name: name, entries: entries)
+    }
+
+    func sendTelemetryFile(path: String, metadata: TelemetryFileMetadata, callback: @escaping SuccessCallback) {
+        networkClient.upload(file: path, metadata: metadata) { error in callback(error == nil) }
+    }
+}

MapboxVision/Services/DataProvider.swift

@@ -7,39 +7,6 @@ protocol DataProvider: AnyObject {
     func stop()
 }
 
-final class RecordedDataProvider: DataProvider {
-    struct Dependencies {
-        let recordingPath: RecordingPath
-        let startTime: UInt
-    }
-
-    let dependencies: Dependencies
-    let telemetryPlayer: TelemetryPlayer
-
-    init(dependencies: Dependencies) {
-        self.dependencies = dependencies
-        self.telemetryPlayer = TelemetryPlayer()
-        telemetryPlayer.read(fromFolder: dependencies.recordingPath.recordingPath)
-    }
-
-    private var startTime = DispatchTime.now().uptimeMilliseconds
-
-    func start() {
-        startTime = DispatchTime.now().uptimeMilliseconds
-        telemetryPlayer.scrollData(dependencies.startTime)
-    }
-
-    func update() {
-        let settings = dependencies.recordingPath.settings
-        let frameSize = CGSize(width: settings.width, height: settings.height)
-        let currentTimeMS = DispatchTime.now().uptimeMilliseconds - startTime + dependencies.startTime
-        telemetryPlayer.setCurrentTime(currentTimeMS)
-        telemetryPlayer.updateData(withFrameSize: frameSize, srcSize: frameSize)
-    }
-
-    func stop() {}
-}
-
 final class RealtimeDataProvider: DataProvider {
     struct Dependencies {
         let native: VisionManagerNative
@@ -68,17 +35,3 @@ final class RealtimeDataProvider: DataProvider {
         dependencies.motionManager.stop()
     }
 }
-
-final class EmptyDataProvider: DataProvider {
-    func start() {}
-
-    func update() {}
-
-    func stop() {}
-}
-
-private extension DispatchTime {
-    var uptimeMilliseconds: UInt {
-        return UInt(DispatchTime.now().uptimeNanoseconds / 1_000_000)
-    }
-}

MapboxVision/Services/EventsManager.swift

@@ -16,16 +16,6 @@ final class EventsManager {
         return token
     }()
 
-    private let formatter: DateFormatter = {
-        let dateFormatter = DateFormatter()
-        let enUSPosixLocale = Locale(identifier: "en_US_POSIX")
-        dateFormatter.locale = enUSPosixLocale
-        dateFormatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ssZZZZZ"
-        return dateFormatter
-    }()
-
-    private lazy var recordingFormatter = DateFormatter.createRecordingFormatter()
-
     init() {
         let bundle = Bundle(for: type(of: self))
         let name = bundle.infoDictionary!["CFBundleName"] as! String
@@ -38,11 +28,6 @@ final class EventsManager {
         )
         manager.sendTurnstileEvent()
         manager.isMetricsEnabled = true
-        manager.isDebugLoggingEnabled = true
-    }
-
-    func sendEvent(name: String, entries: [String: Any]) {
-        manager.enqueueEvent(withName: name, attributes: entries)
     }
 }
 
@@ -51,52 +36,12 @@ extension EventsManager: NetworkClient {
         manager.baseURL = baseURL
     }
 
-    func upload(file: URL, toFolder folderName: String, completion: @escaping (Error?) -> Void) {
-        let contentType: String
-        switch file.pathExtension {
-        case "zip": contentType = "zip"
-        case "mp4": contentType = "video"
-        case "jpg": contentType = "image"
-        default:
-            assertionFailure("EventsManager: post unsupported content type")
-            contentType = ""
-        }
-
-        let name = file.lastPathComponent
-        let folder = file.deletingLastPathComponent().lastPathComponent
-
-        let created = file.creationDate.map(formatter.string) ?? ""
-
-        var metadata = [
-            "name": name,
-            "fileId": folder + "/" + name,
-            "sessionId": folderName,
-            "format": file.pathExtension,
-            "created": created,
-            "type": contentType,
-        ]
-
-        if contentType == "video" {
-            var startTime = created
-            var endTime = created
-
-            let components = name.deletingPathExtension.split(separator: "-")
-            if
-                let date = recordingFormatter.date(from: folder),
-                let start = components[safe: 0],
-                let startInterval = TimeInterval(start),
-                let end = components[safe: 1],
-                let endInterval = TimeInterval(end)
-            {
-                startTime = formatter.string(from: date.addingTimeInterval(startInterval))
-                endTime = formatter.string(from: date.addingTimeInterval(endInterval))
-            }
-
-            metadata["startTime"] = startTime
-            metadata["endTime"] = endTime
-        }
+    func sendEvent(name: String, entries: [String: Any]) {
+        manager.enqueueEvent(withName: name, attributes: entries)
+    }
 
-        manager.postMetadata([metadata], filePaths: [file.path], completionHandler: completion)
+    func upload(file: String, metadata: TelemetryFileMetadata, completion: @escaping (Error?) -> Void) {
+        manager.postMetadata([metadata], filePaths: [file], completionHandler: completion)
     }
 
     func cancel() {}

MapboxVision/Services/Network/NetworkClient.swift

@@ -1,7 +1,9 @@
 import Foundation
+import MapboxVisionNative
 
 protocol NetworkClient {
     func set(baseURL: URL?)
-    func upload(file: URL, toFolder folderName: String, completion: @escaping (Error?) -> Void)
+    func sendEvent(name: String, entries: [String: Any])
+    func upload(file: String, metadata: TelemetryFileMetadata, completion: @escaping (Error?) -> Void)
     func cancel()
 }