: View {
+ let content: Content
+ @State private var speechQueue = SpeechQueue.shared
+
+ init(@ViewBuilder content: () -> Content) {
+ self.content = content()
+ }
+
+ var body: some View {
+ ZStack(alignment: .bottom) {
+ content
+ .frame(maxWidth: .infinity, maxHeight: .infinity)
+
+ if speechQueue.hasItems {
+ VStack(spacing: 0) {
+ SpeechPlayerView()
+ .padding(.horizontal, 16)
+ .padding(.vertical, 8)
+ .transition(.move(edge: .bottom).combined(with: .opacity))
+
+ Rectangle()
+ .fill(.clear)
+ .frame(height: 49)
+ }
+ }
+ }
+ .animation(.spring(), value: speechQueue.hasItems)
+ }
+}
+
+#Preview {
+ GlobalPlayerContainerView {
+ Text("Main Content")
+ .frame(maxWidth: .infinity, maxHeight: .infinity)
+ .background(Color(.systemBackground))
+ }
+}
diff --git a/readeck/UI/SpeechPlayer/SpeechPlayerView.swift b/readeck/UI/SpeechPlayer/SpeechPlayerView.swift
new file mode 100644
index 0000000..16b7707
--- /dev/null
+++ b/readeck/UI/SpeechPlayer/SpeechPlayerView.swift
@@ -0,0 +1,186 @@
+import SwiftUI
+
+struct SpeechPlayerView: View {
+ @State var viewModel = SpeechPlayerViewModel()
+ @State private var isExpanded = false
+ @State private var dragOffset: CGFloat = 0
+ @State private var speechQueue = SpeechQueue.shared
+ @State private var ttsManager = TTSManager.shared
+
+ private let minHeight: CGFloat = 60
+ private let maxHeight: CGFloat = 300
+
+ var body: some View {
+ VStack(spacing: 0) {
+ if isExpanded {
+ expandedView
+ } else {
+ collapsedView
+ }
+ }
+ .frame(height: isExpanded ? maxHeight : minHeight)
+ .background(.ultraThinMaterial)
+ .cornerRadius(12)
+ .shadow(radius: 8, x: 0, y: -2)
+ .offset(y: dragOffset)
+ .gesture(
+ DragGesture()
+ .onChanged { value in
+ dragOffset = value.translation.height
+ }
+ .onEnded { value in
+ withAnimation(.spring()) {
+ if value.translation.height < -50 && !isExpanded {
+ isExpanded = true
+ } else if value.translation.height > 50 && isExpanded {
+ isExpanded = false
+ }
+ dragOffset = 0
+ }
+ }
+ )
+ }
+
+ private var collapsedView: some View {
+ HStack(spacing: 16) {
+ // Play/Pause Button
+ Button(action: {
+ if ttsManager.isCurrentlySpeaking() {
+ viewModel.pause()
+ } else {
+ viewModel.resume()
+ }
+ }) {
+ Image(systemName: ttsManager.isCurrentlySpeaking() ? "pause.fill" : "play.fill")
+ .font(.title2)
+ .foregroundColor(.accentColor)
+ }
+
+ // Current Text
+ VStack(alignment: .leading, spacing: 2) {
+ Text(viewModel.currentText.isEmpty ? "Keine Wiedergabe" : viewModel.currentText)
+ .font(.subheadline)
+ .fontWeight(.medium)
+ .lineLimit(1)
+ .truncationMode(.tail)
+
+ if speechQueue.queueCount > 0 {
+ Text("\(speechQueue.queueCount) Artikel in Queue")
+ .font(.caption)
+ .foregroundColor(.secondary)
+ }
+ }
+
+ Spacer()
+
+ // Stop Button
+ Button(action: {
+ viewModel.stop()
+ }) {
+ Image(systemName: "stop.fill")
+ .font(.title3)
+ .foregroundColor(.secondary)
+ }
+
+ // Expand Button
+ Button(action: {
+ withAnimation(.spring()) {
+ isExpanded.toggle()
+ }
+ }) {
+ Image(systemName: "chevron.up")
+ .font(.caption)
+ .foregroundColor(.secondary)
+ }
+ }
+ .padding(.horizontal, 16)
+ .padding(.vertical, 12)
+ }
+
+ private var expandedView: some View {
+ VStack(spacing: 16) {
+ // Header
+ HStack {
+ Text("Vorlese-Queue")
+ .font(.headline)
+ .fontWeight(.semibold)
+
+ Spacer()
+
+ Button(action: {
+ withAnimation(.spring()) {
+ isExpanded = false
+ }
+ }) {
+ Image(systemName: "chevron.down")
+ .font(.title3)
+ .foregroundColor(.secondary)
+ }
+ }
+ .padding(.horizontal, 16)
+ .padding(.top, 16)
+
+ // Controls
+ HStack(spacing: 24) {
+ Button(action: {
+ if ttsManager.isCurrentlySpeaking() {
+ viewModel.pause()
+ } else {
+ viewModel.resume()
+ }
+ }) {
+ Image(systemName: ttsManager.isCurrentlySpeaking() ? "pause.fill" : "play.fill")
+ .font(.title)
+ .foregroundColor(.accentColor)
+ }
+
+ Button(action: {
+ viewModel.stop()
+ }) {
+ Image(systemName: "stop.fill")
+ .font(.title2)
+ .foregroundColor(.secondary)
+ }
+ }
+
+ // Queue List
+ if speechQueue.queueCount == 0 {
+ Text("Keine Artikel in der Queue")
+ .font(.subheadline)
+ .foregroundColor(.secondary)
+ .padding()
+ } else {
+ ScrollView {
+ LazyVStack(spacing: 8) {
+ ForEach(Array(speechQueue.queueItems.enumerated()), id: \.offset) { index, item in
+ HStack {
+ Text("\(index + 1).")
+ .font(.caption)
+ .foregroundColor(.secondary)
+ .frame(width: 20, alignment: .leading)
+
+ Text(item)
+ .font(.subheadline)
+ .lineLimit(2)
+ .truncationMode(.tail)
+
+ Spacer()
+ }
+ .padding(.horizontal, 16)
+ .padding(.vertical, 8)
+ .background(Color(.systemGray6))
+ .cornerRadius(8)
+ }
+ }
+ .padding(.horizontal, 16)
+ }
+ }
+
+ Spacer()
+ }
+ }
+}
+
+#Preview {
+ SpeechPlayerView()
+}
diff --git a/readeck/UI/SpeechPlayer/SpeechPlayerViewModel.swift b/readeck/UI/SpeechPlayer/SpeechPlayerViewModel.swift
new file mode 100644
index 0000000..fe5d1da
--- /dev/null
+++ b/readeck/UI/SpeechPlayer/SpeechPlayerViewModel.swift
@@ -0,0 +1,24 @@
+import Foundation
+
+@Observable
+class SpeechPlayerViewModel {
+ var isSpeaking: Bool {
+ return TTSManager.shared.isCurrentlySpeaking()
+ }
+
+ var currentText: String {
+ return SpeechQueue.shared.currentText
+ }
+
+ func pause() {
+ TTSManager.shared.pause()
+ }
+
+ func resume() {
+ TTSManager.shared.resume()
+ }
+
+ func stop() {
+ SpeechQueue.shared.clear()
+ }
+}
diff --git a/readeck/Utils/SpeechQueue.swift b/readeck/Utils/SpeechQueue.swift
new file mode 100644
index 0000000..4dc66c8
--- /dev/null
+++ b/readeck/Utils/SpeechQueue.swift
@@ -0,0 +1,74 @@
+import Foundation
+
+@Observable
+class SpeechQueue {
+ private var queue: [String] = []
+ private var isProcessing = false
+ private let ttsManager: TTSManager
+ private let language: String
+
+ static let shared = SpeechQueue()
+
+ var hasItems: Bool {
+ return !queue.isEmpty || ttsManager.isCurrentlySpeaking()
+ }
+
+ var queueCount: Int {
+ return queue.count
+ }
+
+ var currentItem: String? {
+ return queue.first
+ }
+
+ var queueItems: [String] {
+ return queue
+ }
+
+ var currentText: String {
+ return queue.first ?? ""
+ }
+
+ private init(ttsManager: TTSManager = .shared, language: String = "de-DE") {
+ self.ttsManager = ttsManager
+ self.language = language
+ }
+
+ func enqueue(_ text: String) {
+ queue.append(text)
+ processQueue()
+ }
+
+ func enqueue(contentsOf texts: [String]) {
+ queue.append(contentsOf: texts)
+ processQueue()
+ }
+
+ func clear() {
+ queue.removeAll()
+ ttsManager.stop()
+ isProcessing = false
+ }
+
+ private func processQueue() {
+ guard !isProcessing, !queue.isEmpty else { return }
+ isProcessing = true
+ let next = queue.removeFirst()
+ ttsManager.speak(text: next, language: language)
+ // Delegate/Notification für didFinish kann hier angebunden werden
+ DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) { [weak self] in
+ self?.waitForSpeechToFinish()
+ }
+ }
+
+ private func waitForSpeechToFinish() {
+ if ttsManager.isCurrentlySpeaking() {
+ DispatchQueue.main.asyncAfter(deadline: .now() + 0.2) { [weak self] in
+ self?.waitForSpeechToFinish()
+ }
+ } else {
+ self.isProcessing = false
+ self.processQueue()
+ }
+ }
+}
diff --git a/readeck/Utils/StringExtensions.swift b/readeck/Utils/StringExtensions.swift
new file mode 100644
index 0000000..1c71de0
--- /dev/null
+++ b/readeck/Utils/StringExtensions.swift
@@ -0,0 +1,29 @@
+import Foundation
+
+extension String {
+ var stripHTML: String {
+ // Entfernt HTML-Tags und decodiert HTML-Entities
+ let attributedString = try? NSAttributedString(
+ data: Data(utf8),
+ options: [
+ .documentType: NSAttributedString.DocumentType.html,
+ .characterEncoding: String.Encoding.utf8.rawValue
+ ],
+ documentAttributes: nil
+ )
+
+ return attributedString?.string ?? self
+ }
+
+ var stripHTMLSimple: String {
+ // Einfache Regex-basierte HTML-Entfernung
+ return self.replacingOccurrences(of: "<[^>]+>", with: "", options: .regularExpression, range: nil)
+ .replacingOccurrences(of: " ", with: " ")
+ .replacingOccurrences(of: "&", with: "&")
+ .replacingOccurrences(of: "<", with: "<")
+ .replacingOccurrences(of: ">", with: ">")
+ .replacingOccurrences(of: """, with: "\"")
+ .replacingOccurrences(of: "'", with: "'")
+ .trimmingCharacters(in: .whitespacesAndNewlines)
+ }
+}
\ No newline at end of file
diff --git a/readeck/Utils/TTSManager.swift b/readeck/Utils/TTSManager.swift
new file mode 100644
index 0000000..d5f4c78
--- /dev/null
+++ b/readeck/Utils/TTSManager.swift
@@ -0,0 +1,165 @@
+import Foundation
+import UIKit
+import AVFoundation
+
+class TTSManager: NSObject, AVSpeechSynthesizerDelegate {
+ static let shared = TTSManager()
+ private let synthesizer = AVSpeechSynthesizer()
+ private var isSpeaking = false
+
+ override private init() {
+ super.init()
+ synthesizer.delegate = self
+ configureAudioSession()
+ }
+
+ private func configureAudioSession() {
+ do {
+ let audioSession = AVAudioSession.sharedInstance()
+ try audioSession.setCategory(.playback, mode: .spokenAudio, options: [.mixWithOthers, .duckOthers, .allowBluetooth, .allowBluetoothA2DP])
+ try audioSession.setActive(true)
+
+ // Background-Audio aktivieren
+ try audioSession.setCategory(.playback, mode: .spokenAudio, options: [.mixWithOthers, .duckOthers, .allowBluetooth, .allowBluetoothA2DP])
+
+ // Notification für App-Lifecycle
+ NotificationCenter.default.addObserver(
+ self,
+ selector: #selector(handleAppDidEnterBackground),
+ name: UIApplication.didEnterBackgroundNotification,
+ object: nil
+ )
+
+ NotificationCenter.default.addObserver(
+ self,
+ selector: #selector(handleAppWillEnterForeground),
+ name: UIApplication.willEnterForegroundNotification,
+ object: nil
+ )
+ } catch {
+ print("Fehler beim Konfigurieren der Audio-Session: \(error)")
+ }
+ }
+
+ func speak(text: String, language: String = "de-DE") {
+ guard !text.isEmpty else { return }
+ if synthesizer.isSpeaking {
+ synthesizer.stopSpeaking(at: .immediate)
+ }
+ let utterance = AVSpeechUtterance(string: text)
+
+ // Versuche eine hochwertige Stimme zu finden
+ if let enhancedVoice = findEnhancedVoice(for: language) {
+ utterance.voice = enhancedVoice
+ } else {
+ utterance.voice = AVSpeechSynthesisVoice(language: language)
+ }
+
+ utterance.rate = 0.5
+ utterance.pitchMultiplier = 1.0
+ utterance.volume = 1.0
+
+ synthesizer.speak(utterance)
+ isSpeaking = true
+ }
+
+ private func findEnhancedVoice(for language: String) -> AVSpeechSynthesisVoice? {
+ let availableVoices = AVSpeechSynthesisVoice.speechVoices()
+
+ // Bevorzugte Stimmen für alle Sprachen
+ let preferredVoiceNames = [
+ "Anna", // Deutsche Premium-Stimme
+ "Helena", // Deutsche Premium-Stimme
+ "Siri", // Siri-Stimme (falls verfügbar)
+ "Enhanced", // Enhanced-Stimmen
+ "Karen", // Englische Premium-Stimme
+ "Daniel", // Englische Premium-Stimme
+ "Marie", // Französische Premium-Stimme
+ "Paolo", // Italienische Premium-Stimme
+ "Carmen", // Spanische Premium-Stimme
+ "Yuki" // Japanische Premium-Stimme
+ ]
+
+ // Zuerst nach bevorzugten Stimmen für die spezifische Sprache suchen
+ for voiceName in preferredVoiceNames {
+ if let voice = availableVoices.first(where: {
+ $0.language == language &&
+ $0.name.contains(voiceName)
+ }) {
+ return voice
+ }
+ }
+
+ // Fallback: Erste verfügbare Stimme für die Sprache
+ return availableVoices.first(where: { $0.language == language })
+ }
+
+ func pause() {
+ synthesizer.pauseSpeaking(at: .word)
+ }
+
+ func resume() {
+ synthesizer.continueSpeaking()
+ }
+
+ func stop() {
+ synthesizer.stopSpeaking(at: .immediate)
+ isSpeaking = false
+ }
+
+ func speechSynthesizer(_ synthesizer: AVSpeechSynthesizer, didFinish utterance: AVSpeechUtterance) {
+ isSpeaking = false
+ }
+
+ func speechSynthesizer(_ synthesizer: AVSpeechSynthesizer, didCancel utterance: AVSpeechUtterance) {
+ isSpeaking = false
+ }
+
+ func isCurrentlySpeaking() -> Bool {
+ return synthesizer.isSpeaking
+ }
+
+ @objc private func handleAppDidEnterBackground() {
+ // App geht in Hintergrund - Audio-Session beibehalten
+ do {
+ try AVAudioSession.sharedInstance().setActive(true)
+ } catch {
+ print("Fehler beim Aktivieren der Audio-Session im Hintergrund: \(error)")
+ }
+ }
+
+ @objc private func handleAppWillEnterForeground() {
+ // App kommt in Vordergrund - Audio-Session erneuern
+ do {
+ try AVAudioSession.sharedInstance().setActive(true)
+ } catch {
+ print("Fehler beim Aktivieren der Audio-Session im Vordergrund: \(error)")
+ }
+ }
+
+ deinit {
+ NotificationCenter.default.removeObserver(self)
+ }
+
+ // Debug-Methode: Zeigt alle verfügbaren Stimmen für eine Sprache
+ func printAvailableVoices(for language: String = "de-DE") {
+ let voices = AVSpeechSynthesisVoice.speechVoices()
+ let filteredVoices = voices.filter { $0.language.starts(with: language.prefix(2)) }
+
+ print("Verfügbare Stimmen für \(language):")
+ for voice in filteredVoices {
+ print("- \(voice.name) (\(voice.language)) - Qualität: \(voice.quality.rawValue)")
+ }
+ }
+
+ // Debug-Methode: Zeigt alle verfügbaren Sprachen
+ func printAllAvailableLanguages() {
+ let voices = AVSpeechSynthesisVoice.speechVoices()
+ let languages = Set(voices.map { $0.language })
+
+ print("Verfügbare Sprachen:")
+ for language in languages.sorted() {
+ print("- \(language)")
+ }
+ }
+}
diff --git a/readeckTests/StringExtensionsTests.swift b/readeckTests/StringExtensionsTests.swift
new file mode 100644
index 0000000..257c293
--- /dev/null
+++ b/readeckTests/StringExtensionsTests.swift
@@ -0,0 +1,158 @@
+import XCTest
+@testable import readeck
+
+final class StringExtensionsTests: XCTestCase {
+
+ // MARK: - stripHTML Tests
+
+ func testStripHTML_SimpleTags() {
+ let html = "Dies ist ein wichtiger Artikel.
"
+ let expected = "Dies ist ein wichtiger Artikel.\n"
+
+ XCTAssertEqual(html.stripHTML, expected)
+ }
+
+ func testStripHTML_ComplexNestedTags() {
+ let html = "Titel
Text mit kursiv und fett.
Text mit Attributen
"
+ let expected = "Text mit Attributen\n"
+
+ XCTAssertEqual(html.stripHTML, expected)
+ }
+
+ func testStripHTML_EmptyTags() {
+ let html = "Inhalt
"
+ let expected = "\nInhalt\n"
+
+ XCTAssertEqual(html.stripHTML, expected)
+ }
+
+ func testStripHTML_SelfClosingTags() {
+ let html = "Text mit
Zeilenumbruch und ![](\"test.jpg\")
Bild.
"
+ let expected = "Text mit \nZeilenumbruch und Bild.\n"
+
+ XCTAssertEqual(html.stripHTML, expected)
+ }
+
+ func testStripHTML_NoTags() {
+ let plainText = "Dies ist normaler Text ohne HTML."
+
+ XCTAssertEqual(plainText.stripHTML, plainText)
+ }
+
+ func testStripHTML_EmptyString() {
+ let emptyString = ""
+
+ XCTAssertEqual(emptyString.stripHTML, emptyString)
+ }
+
+ func testStripHTML_OnlyTags() {
+ let onlyTags = "
"
+ let expected = "\n"
+
+ XCTAssertEqual(onlyTags.stripHTML, expected)
+ }
+
+ // MARK: - stripHTMLSimple Tests
+
+ func testStripHTMLSimple_BasicTags() {
+ let html = "Text mit fett.
"
+ let expected = "Text mit fett."
+
+ XCTAssertEqual(html.stripHTMLSimple, expected)
+ }
+
+ func testStripHTMLSimple_HTMLEntities() {
+ let html = "Text mit Leerzeichen, & Zeichen und "Anführungszeichen".
"
+ let expected = "Text mit Leerzeichen, & Zeichen und \"Anführungszeichen\"."
+
+ XCTAssertEqual(html.stripHTMLSimple, expected)
+ }
+
+ func testStripHTMLSimple_MoreEntities() {
+ let html = "<Tag> und 'Apostroph'
"
+ let expected = " und 'Apostroph'"
+
+ XCTAssertEqual(html.stripHTMLSimple, expected)
+ }
+
+ func testStripHTMLSimple_ComplexHTML() {
+ let html = "Überschrift
Absatz mit kursiv und fett.
Text mit Whitespace
"
+ let expected = "Text mit Whitespace"
+
+ XCTAssertEqual(html.stripHTMLSimple, expected)
+ }
+
+ // MARK: - Performance Tests
+
+ func testStripHTML_Performance() {
+ let largeHTML = String(repeating: "Dies ist ein Test mit vielen HTML Tags.
", count: 1000)
+
+ measure {
+ _ = largeHTML.stripHTML
+ }
+ }
+
+ func testStripHTMLSimple_Performance() {
+ let largeHTML = String(repeating: "Dies ist ein Test mit vielen HTML Tags.
", count: 1000)
+
+ measure {
+ _ = largeHTML.stripHTMLSimple
+ }
+ }
+
+ // MARK: - Edge Cases
+
+ func testStripHTML_MalformedHTML() {
+ let malformed = "Unvollständiger Tag"
+ let expected = "Unvollständiger Tag"
+
+ XCTAssertEqual(malformed.stripHTML, expected)
+ }
+
+ func testStripHTML_UnicodeCharacters() {
+ let html = "Text mit Umlauten: äöüß und Emojis: 🚀📱
"
+ let expected = "Text mit Umlauten: äöüß und Emojis: 🚀📱"
+
+ XCTAssertEqual(html.stripHTML, expected)
+ }
+
+ func testStripHTML_Newlines() {
+ let html = "Erste Zeile
Zweite Zeile
"
+ let expected = "Erste Zeile\nZweite Zeile"
+
+ XCTAssertEqual(html.stripHTML, expected)
+ }
+
+ func testStripHTML_ListItems() {
+ let html = "- Erster Punkt
- Zweiter Punkt
- Dritter Punkt
"
+ let expected = "Erster Punkt\nZweiter Punkt\nDritter Punkt"
+
+ XCTAssertEqual(html.stripHTML, expected)
+ }
+}