Merge pull request #2 from renaudjenny/add-modern-concurrency

feat(Concurrency): add modern concurrency version for this library

Author: renaudjenny

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2020 Renaud Jenny
+Copyright (c) 2023 Renaud Jenny
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

Package.resolved

@@ -1,26 +1,29 @@
-// swift-tools-version:5.2
+// swift-tools-version:5.7
 // The swift-tools-version declares the minimum version of Swift required to build this package.
 
 import PackageDescription
 
 let package = Package(
-    name: "SwiftTTSCombine",
+    name: "swift-tts",
     platforms: [
-        .iOS(.v13),
-        .macOS(.v10_15),
+        .iOS(.v15),
+        .macOS(.v13),
     ],
     products: [
-        .library(
-            name: "SwiftTTSCombine",
-            targets: ["SwiftTTSCombine"]),
+        .library(name: "SwiftTTS", targets: ["SwiftTTS"]),
+        .library(name: "SwiftTTSDependency", targets: ["SwiftTTSDependency"]),
+        .library(name: "SwiftTTSCombine", targets: ["SwiftTTSCombine"]),
+    ],
+    dependencies: [
+        .package(url: "https://github.com/pointfreeco/swift-dependencies", from: "0.2.0"),
     ],
-    dependencies: [],
     targets: [
-        .target(
-            name: "SwiftTTSCombine",
-            dependencies: []),
-        .testTarget(
-            name: "SwiftTTSCombineTests",
-            dependencies: ["SwiftTTSCombine"]),
+        .target(name: "SwiftTTS", dependencies: []),
+        .testTarget(name: "SwiftTTSTests", dependencies: ["SwiftTTS"]),
+        .target(name: "SwiftTTSDependency", dependencies: [
+            .product(name: "Dependencies", package: "swift-dependencies"),
+            "SwiftTTS",
+        ]),
+        .target(name: "SwiftTTSCombine", dependencies: []),
     ]
 )

Package.swift

@@ -0,0 +1,109 @@
+import AVFoundation
+
+public struct SwiftTTS {
+    public var rateRatio: () -> Float
+    public var setRateRatio: (Float) -> Void
+    public var voice: () -> AVSpeechSynthesisVoice?
+    public var setVoice: (AVSpeechSynthesisVoice) -> Void
+    public var speak: (String) -> Void
+    public var isSpeaking: () -> AsyncStream<Bool>
+    public var speakingProgress: () -> AsyncStream<Double>
+
+    public init(
+        rateRatio: @escaping () -> Float,
+        setRateRatio: @escaping (Float) -> Void,
+        voice: @escaping () -> AVSpeechSynthesisVoice?,
+        setVoice: @escaping (AVSpeechSynthesisVoice) -> Void,
+        speak: @escaping (String) -> Void,
+        isSpeaking: @escaping () -> AsyncStream<Bool>,
+        speakingProgress: @escaping () -> AsyncStream<Double>
+    ) {
+        self.rateRatio = rateRatio
+        self.setRateRatio = setRateRatio
+        self.voice = voice
+        self.setVoice = setVoice
+        self.speak = speak
+        self.isSpeaking = isSpeaking
+        self.speakingProgress = speakingProgress
+    }
+}
+
+private final class Engine: NSObject, AVSpeechSynthesizerDelegate {
+
+    var rateRatio: Float
+    var voice: AVSpeechSynthesisVoice?
+    var isSpeaking: ((Bool) -> Void)?
+    var speakingProgress: ((Double) -> Void)?
+    private let speechSynthesizer = AVSpeechSynthesizer()
+
+    init(
+        rateRatio: Float,
+        voice: AVSpeechSynthesisVoice?
+    ) {
+        self.rateRatio = rateRatio
+        self.voice = voice
+        super.init()
+        speechSynthesizer.delegate = self
+        #if os(iOS)
+        try? AVAudioSession.sharedInstance().setCategory(.playback)
+        #endif
+    }
+
+    func speak(string: String) {
+        let speechUtterance = AVSpeechUtterance(string: string)
+        speechUtterance.voice = voice
+        speechUtterance.rate *= rateRatio
+        speechSynthesizer.speak(speechUtterance)
+        isSpeaking?(true)
+    }
+
+    func speechSynthesizer(
+        _ synthesizer: AVSpeechSynthesizer,
+        didStart utterance: AVSpeechUtterance
+    ) {
+        speakingProgress?(0.0)
+    }
+
+    func speechSynthesizer(
+        _ synthesizer: AVSpeechSynthesizer,
+        didFinish utterance: AVSpeechUtterance
+    ) {
+        isSpeaking?(false)
+        speakingProgress?(1.0)
+    }
+
+    func speechSynthesizer(
+        _ synthesizer: AVSpeechSynthesizer,
+        willSpeakRangeOfSpeechString characterRange: NSRange,
+        utterance: AVSpeechUtterance
+    ) {
+        let total = Double(utterance.speechString.count)
+        let averageBound = [Double(characterRange.lowerBound), Double(characterRange.upperBound)]
+            .reduce(0, +)/2
+        speakingProgress?(averageBound/total)
+    }
+}
+
+public extension SwiftTTS {
+    static let live = {
+        let engine = Engine(rateRatio: 1.0, voice: AVSpeechSynthesisVoice(language: "en-GB"))
+
+        let isSpeaking = AsyncStream { continuation in
+            engine.isSpeaking = { continuation.yield($0) }
+        }
+
+        let speakingProgress = AsyncStream { continuation in
+            engine.speakingProgress = { continuation.yield($0) }
+        }
+
+        return Self(
+            rateRatio: { engine.rateRatio },
+            setRateRatio: { engine.rateRatio = $0 },
+            voice: { engine.voice },
+            setVoice: { engine.voice = $0 },
+            speak: engine.speak,
+            isSpeaking: { isSpeaking },
+            speakingProgress: { speakingProgress }
+       )
+    }()
+}

Sources/SwiftTTS/SwiftTTS.swift

@@ -2,7 +2,7 @@ import Foundation
 import Combine
 import AVFoundation
 
-public protocol TTSEngine: class {
+public protocol TTSEngine: AnyObject {
     var rateRatio: Float { get set }
     var voice: AVSpeechSynthesisVoice? { get set }
     func speak(string: String)
@@ -25,7 +25,9 @@ public final class Engine: NSObject, ObservableObject {
         self.voice = voice
         super.init()
         self.speechSynthesizer.delegate = self
+        #if os(iOS)
         try? AVAudioSession.sharedInstance().setCategory(.playback)
+        #endif
     }
 }
 

Sources/SwiftTTSCombine/SwiftTTSCombine.swift

@@ -0,0 +1,69 @@
+import AVFoundation
+import Dependencies
+import SwiftTTS
+import XCTestDynamicOverlay
+
+extension SwiftTTS {
+    static let test = Self(
+        rateRatio: unimplemented("SwiftTTS.rateRatio"),
+        setRateRatio: unimplemented("SwiftTTS.setRateRatio"),
+        voice: unimplemented("SwiftTTS.voice"),
+        setVoice: unimplemented("SwiftTTS.setVoice"),
+        speak: unimplemented("SwiftTTS.speak"),
+        isSpeaking: unimplemented("SwiftTTS.isSpeaking"),
+        speakingProgress: unimplemented("SwiftTTS.speakingProgress")
+    )
+    static let preview = {
+        var speakingCallbacks: [() -> Void] = []
+        let speak: (String) -> Void = {
+            print("Spoken utterance: \($0)")
+            for callback in speakingCallbacks {
+                callback()
+            }
+        }
+
+        let isSpeaking = AsyncStream { continuation in
+            speakingCallbacks.append {
+                continuation.yield(true)
+                Task {
+                    try await Task.sleep(nanoseconds: 2_000_000_000)
+                    continuation.yield(false)
+                }
+            }
+        }
+
+        let speakingProgress = AsyncStream { continuation in
+            speakingCallbacks.append {
+                Task {
+                    for seconds in 0...4 {
+                        continuation.yield(Double(seconds) / 4)
+                        try await Task.sleep(nanoseconds: 500_000_000)
+                    }
+                }
+            }
+        }
+
+        return Self(
+            rateRatio: { 1.0 },
+            setRateRatio: { _ in },
+            voice: { AVSpeechSynthesisVoice(language: "en-GB") },
+            setVoice: { _ in },
+            speak: speak,
+            isSpeaking: { isSpeaking },
+            speakingProgress: { speakingProgress }
+        )
+    }()
+}
+
+private enum SwiftTTSDependencyKey: DependencyKey {
+    static let liveValue = SwiftTTS.live
+    static let testValue = SwiftTTS.test
+    static let previewValue = SwiftTTS.preview
+}
+
+public extension DependencyValues {
+    var tts: SwiftTTS {
+        get { self[SwiftTTSDependencyKey.self] }
+        set { self[SwiftTTSDependencyKey.self] = newValue }
+    }
+}