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

* Also rename the library `swift-tts` because it has now a more generic
  purpose than just the Combine version.

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.swift

@@ -1,26 +1,22 @@
-// 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: "SwiftTTSCombine", targets: ["SwiftTTSCombine"]),
     ],
     dependencies: [],
     targets: [
-        .target(
-            name: "SwiftTTSCombine",
-            dependencies: []),
-        .testTarget(
-            name: "SwiftTTSCombineTests",
-            dependencies: ["SwiftTTSCombine"]),
+        .target(name: "SwiftTTS", dependencies: []),
+        .testTarget(name: "SwiftTTSTests", dependencies: ["SwiftTTS"]),
+        .target(name: "SwiftTTSCombine", dependencies: []),
     ]
 )

Sources/SwiftTTS/SwiftTTS.swift

@@ -0,0 +1,91 @@
+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>
+}
+
+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/SwiftTTSCombine/SwiftTTSCombine.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
     }
 }
 

Tests/LinuxMain.swift

@@ -0,0 +1,80 @@
+import AVFoundation
+import SwiftTTS
+import XCTest
+
+@MainActor
+final class SwiftTTSTests: XCTestCase {
+    func testLiveTTSWithoutCrashing() {
+        let tts = SwiftTTS.live
+        tts.speak("Let's test that!")
+    }
+
+    func testTTSRateRatio() {
+        let tts = SwiftTTS.live
+        XCTAssertEqual(tts.rateRatio(), 1.0)
+        tts.setRateRatio(0.5)
+        XCTAssertEqual(tts.rateRatio(), 0.5)
+    }
+
+    func testTTSVoice() throws {
+        let tts = SwiftTTS.live
+        let britishVoice = try XCTUnwrap(AVSpeechSynthesisVoice(language: "en-GB"))
+        let frenchVoice = try XCTUnwrap(AVSpeechSynthesisVoice(language: "fr-FR"))
+
+        XCTAssertEqual(tts.voice(), britishVoice)
+        tts.setVoice(frenchVoice)
+        XCTAssertEqual(tts.voice(), frenchVoice)
+    }
+
+    func testTTSSpeak() {
+        let tts = SwiftTTS.live
+
+        let isSpeakingExpectation = expectation(description: "Expect is speaking to be true")
+        let hasStoppedSpeakingExpectation = expectation(description: "Expect is speaking to be false after speaking")
+
+        Task {
+            var hasSpoken = false
+            for await isSpeaking in tts.isSpeaking() {
+                if isSpeaking {
+                    hasSpoken = true
+                    isSpeakingExpectation.fulfill()
+                }
+
+                if hasSpoken && !isSpeaking {
+                    hasStoppedSpeakingExpectation.fulfill()
+                }
+            }
+        }
+
+        let isProgressZeroExpectation = expectation(description: "Expect progress to start at 0.0")
+        let isProgressReachHalfExpectation = expectation(description: "Expect progress to be greater than at 0.5")
+        let isProgressFinishCompletelyExpectation = expectation(description: "Expect progress to finish at 1.0")
+
+        Task {
+            for await progress in tts.speakingProgress() {
+                if progress == 0.0 {
+                    isProgressZeroExpectation.fulfill()
+                }
+                if progress > 0.5 && progress < 1.0 {
+                    isProgressReachHalfExpectation.fulfill()
+                }
+                if progress == 1.0 {
+                    isProgressFinishCompletelyExpectation.fulfill()
+                }
+            }
+        }
+
+        tts.speak("It's a test!")
+
+        wait(
+            for: [
+                isSpeakingExpectation,
+                hasStoppedSpeakingExpectation,
+                isProgressZeroExpectation,
+                isProgressReachHalfExpectation,
+                isProgressFinishCompletelyExpectation
+            ],
+            timeout: 2.0
+        )
+    }
+}