first commit

Author: make1986

.gitignore

@@ -0,0 +1,8 @@
+.DS_Store
+/.build
+/Packages
+xcuserdata/
+DerivedData/
+.swiftpm/configuration/registries.json
+.swiftpm/xcode/package.xcworkspace/contents.xcworkspacedata
+.netrc

Package.resolved

@@ -0,0 +1,38 @@
+// swift-tools-version: 6.0
+// The swift-tools-version declares the minimum version of Swift required to build this package.
+
+import PackageDescription
+
+let package = Package(
+    name: "OtosakuKWS",
+    platforms: [
+        .iOS(.v16),
+        .macOS(.v12)
+    ],
+    products: [
+        // Products define the executables and libraries a package produces, making them visible to other packages.
+        .library(
+            name: "OtosakuKWS",
+            targets: ["OtosakuKWS"]),
+    ],
+    dependencies: [
+        .package(url: "https://github.com/Otosaku/OtosakuFeatureExtractor-iOS.git", from: "1.0.1"),
+        .package(url: "https://github.com/ZipArchive/ZipArchive.git", from: "2.6.0")
+    ],
+    targets: [
+        // Targets are the basic building blocks of a package, defining a module or a test suite.
+        // Targets can depend on other targets in this package and products from dependencies.
+        .target(
+            name: "OtosakuKWS",
+            dependencies: [
+                .product(name: "OtosakuFeatureExtractor", package: "OtosakuFeatureExtractor-iOS"),
+                .product(name: "ZipArchive", package: "ZipArchive")
+            ],
+            path: "Sources"
+        ),
+        .testTarget(
+            name: "OtosakuKWSTests",
+            dependencies: ["OtosakuKWS"]
+        ),
+    ]
+)

Package.swift

@@ -0,0 +1,134 @@
+//
+//  ModelDownloader.swift
+//  OtosakuKWS
+//
+//  Created by Marat Zainullin on 12/06/2025.
+//
+//
+//
+
+#if canImport(UIKit)
+import UIKit
+import Foundation
+import ZipArchive
+
+
+final class ModelDownloader: NSObject, URLSessionDownloadDelegate {
+    static let shared = ModelDownloader()
+
+    private var progressHandler: ((Float) -> Void)?
+    private var completionHandler: ((Result<URL, Error>) -> Void)?
+    private var destinationFolder: URL?
+    private var remoteURL: URL?
+    private var currentTask: URLSessionDownloadTask?
+
+    private lazy var session: URLSession = {
+        let config = URLSessionConfiguration.background(withIdentifier: "otosaku.otusaku-kws.download")
+        return URLSession(configuration: config, delegate: self, delegateQueue: nil)
+    }()
+
+    func downloadAndUnzip(from remoteURL: URL,
+                          to destinationFolder: URL,
+                          progress: @escaping (Float) -> Void,
+                          completion: @escaping (Result<URL, Error>) -> Void) {
+        self.progressHandler = progress
+        self.completionHandler = completion
+        self.destinationFolder = destinationFolder
+        self.remoteURL = remoteURL
+
+        session.getAllTasks { tasks in
+            if let existing = tasks.first(where: { $0.originalRequest?.url == remoteURL }) as? URLSessionDownloadTask {
+                self.currentTask = existing
+                UserDefaults.standard.set(remoteURL.absoluteString, forKey: "ActiveDownloadURL")
+                return
+            }
+
+            let task = self.session.downloadTask(with: remoteURL)
+            self.currentTask = task
+            UserDefaults.standard.set(remoteURL.absoluteString, forKey: "ActiveDownloadURL")
+            task.resume()
+        }
+    }
+
+    func restorePendingDownloadIfNeeded(progress: @escaping (Float) -> Void,
+                                        completion: @escaping (Result<URL, Error>) -> Void) {
+        guard let urlString = UserDefaults.standard.string(forKey: "ActiveDownloadURL"),
+              let url = URL(string: urlString) else { return }
+
+        session.getAllTasks { tasks in
+            if let existing = tasks.first(where: { $0.originalRequest?.url == url }) as? URLSessionDownloadTask {
+                self.remoteURL = url
+                self.progressHandler = progress
+                self.completionHandler = completion
+                self.currentTask = existing
+            }
+        }
+    }
+
+    func urlSession(_ session: URLSession, downloadTask: URLSessionDownloadTask,
+                    didWriteData bytesWritten: Int64,
+                    totalBytesWritten: Int64,
+                    totalBytesExpectedToWrite: Int64) {
+        guard totalBytesExpectedToWrite > 0 else { return }
+        let fractionCompleted = Float(totalBytesWritten) / Float(totalBytesExpectedToWrite)
+        DispatchQueue.main.async {
+            self.progressHandler?(fractionCompleted)
+        }
+    }
+
+    func urlSession(_ session: URLSession, downloadTask: URLSessionDownloadTask, didFinishDownloadingTo location: URL) {
+        guard let destinationFolder else {
+            completionHandler?(.failure(NSError(domain: "Missing destination folder", code: 0)))
+            return
+        }
+
+        do {
+            let fileManager = FileManager.default
+
+            if fileManager.fileExists(atPath: destinationFolder.path) {
+                try fileManager.removeItem(at: destinationFolder)
+            }
+            try fileManager.createDirectory(at: destinationFolder, withIntermediateDirectories: true)
+
+            let success = SSZipArchive.unzipFile(atPath: location.path,
+                                                 toDestination: destinationFolder.deletingLastPathComponent().path)
+            if success {
+                DispatchQueue.main.async {
+                    UserDefaults.standard.removeObject(forKey: "ActiveDownloadURL")
+                    self.completionHandler?(.success(destinationFolder))
+                    self.callBackgroundSessionCompletionIfNeeded()
+                }
+            } else {
+                throw NSError(domain: "ModelDownloader", code: 1,
+                              userInfo: [NSLocalizedDescriptionKey: "Unzipping failed"])
+            }
+        } catch {
+            DispatchQueue.main.async {
+                UserDefaults.standard.removeObject(forKey: "ActiveDownloadURL")
+                self.completionHandler?(.failure(error))
+                self.callBackgroundSessionCompletionIfNeeded()
+            }
+        }
+    }
+
+    func urlSession(_ session: URLSession, task: URLSessionTask, didCompleteWithError error: Error?) {
+        if let error {
+            DispatchQueue.main.async {
+                UserDefaults.standard.removeObject(forKey: "ActiveDownloadURL")
+                self.completionHandler?(.failure(error))
+                self.callBackgroundSessionCompletionIfNeeded()
+            }
+        }
+    }
+
+    private func callBackgroundSessionCompletionIfNeeded() {
+        DispatchQueue.main.async {
+            if let appDelegate = UIApplication.shared.delegate as? AppDelegate,
+               let completion = appDelegate.backgroundSessionCompletionHandler {
+                completion()
+                appDelegate.backgroundSessionCompletionHandler = nil
+            }
+        }
+    }
+}
+#endif

Sources/OtosakuKWS/ModelDownloader.swift

@@ -0,0 +1,95 @@
+// The Swift Programming Language
+// https://docs.swift.org/swift-book
+
+#if canImport(UIKit)
+import Foundation
+import OtosakuFeatureExtractor
+import CoreML
+
+
+public class OtosakuKWS {
+    private let TAG: String = "OtosakuKWS"
+    private let featureExtractor: OtosakuFeatureExtractor
+    private let model: OtosakuKWSModel
+    private let classes: [String]
+    
+    private var buffer: [Double] = []
+    private let totalFrameLimit = 16000
+    private var threshold: Float = 0.9
+    
+    
+    public init (
+        modelRootURL: URL,
+        featureExtractorRootURL: URL,
+        configuration: MLModelConfiguration
+    ) throws {
+        self.featureExtractor = try OtosakuFeatureExtractor(directoryURL: featureExtractorRootURL)
+        self.model = try OtosakuKWSModel(
+            url: modelRootURL.appendingPathComponent("CRNNKeywordSpotter.mlmodelc"),
+            configuration: configuration
+        )
+        self.classes = try readClasses(
+            from: modelRootURL.appendingPathComponent("classes.txt")
+        )
+    }
+    
+    public func handleAudioBuffer(_ buff: [Double]) throws {
+        buffer.append(contentsOf: buff)
+        if buffer.count > totalFrameLimit {
+            let overflow = buffer.count - totalFrameLimit
+            buffer.removeFirst(overflow)
+        }
+        if buffer.count != totalFrameLimit {
+            return
+        }
+        Task {
+            do {
+                var feats = try featureExtractor.processChunk(chunk: buffer)
+                feats = try featureExtractor.expandDims2D(array: feats)
+                let probsArray = try model.predict(x: feats)
+                var (max, idx) = (-1.0, -1)
+                for i in 0..<probsArray.count {
+                    let value = probsArray[i].doubleValue
+                    if value > max {
+                        max = value
+                        idx = i
+                    }
+                }
+                if max > threshold {
+                    let currentClass = self.classes[idx]
+                }
+            } catch {
+                print(TAG, "handleAudioBuffer: error: \(error)")
+            }
+        }
+        
+    }
+    
+    public func setProbabilityThreshold(threshold: Float) {
+        self.threshold = threshold
+    }
+    
+    public static func downloadAndUnzip(
+        from remoteURL: URL,
+        to destinationFolder: URL,
+        progress: @escaping (Float) -> Void,
+        completion: @escaping (Result<URL, Error>) -> Void
+    ) {
+        let downloader = ModelDownloader.shared
+        return downloader.downloadAndUnzip(
+            from: remoteURL,
+            to: destinationFolder,
+            progress: progress,
+            completion: completion
+        )
+    }
+    
+    
+    private func readClasses(from url: URL) throws -> [String] {
+        let text = try String(contentsOf: url, encoding: .utf8)
+        let lines = text.components(separatedBy: .newlines)
+        return lines
+    }
+}
+
+#endif

Sources/OtosakuKWS/OtosakuKWS.swift

@@ -0,0 +1,33 @@
+//
+//  OtosakuKWSModel.swift
+//  OtosakuKWS
+//
+//  Created by Marat Zainullin on 12/06/2025.
+//
+
+import CoreML
+import Foundation
+
+enum OtosakuKWSModelPredictError: Error {
+    case outputExtractionFailed
+}
+
+class OtosakuKWSModel {
+    private let model: MLModel
+    
+    public init (url: URL, configuration: MLModelConfiguration) throws {
+        model = try MLModel(contentsOf: url, configuration: configuration)
+    }
+    
+    public func predict(x: MLMultiArray) throws -> MLMultiArray {
+        let featureProvider = try MLDictionaryFeatureProvider(dictionary: [
+            "input": x
+        ])
+        let out = try model.prediction(from: featureProvider)
+        guard let probs = out.featureValue(for: "probs")?.multiArrayValue else {
+            throw OtosakuKWSModelPredictError.outputExtractionFailed
+        }
+        
+        return probs
+    }
+}

Sources/OtosakuKWS/OtosakuKWSModel.swift

@@ -0,0 +1,6 @@
+import Testing
+@testable import OtosakuKWS
+
+@Test func example() async throws {
+    // Write your test here and use APIs like `#expect(...)` to check expected conditions.
+}