Clean up Voice Memos demo (#915)

* Clean up Voice Memos demo

* Tests

Author: mluisbrown

Examples/VoiceMemos/VoiceMemos/AudioPlayerClient/AudioPlayerClient.swift

@@ -2,8 +2,8 @@ import ComposableArchitecture
 import Foundation
 
 struct AudioPlayerClient {
-  var play: (AnyHashable, URL) -> Effect<Action, Failure>
-  var stop: (AnyHashable) -> Effect<Never, Never>
+  var play: (URL) -> Effect<Action, Failure>
+  var stop: () -> Effect<Never, Never>
 
   enum Action: Equatable {
     case didFinishPlaying(successfully: Bool)

Examples/VoiceMemos/VoiceMemos/AudioPlayerClient/FailingAudioPlayerClient.swift

@@ -4,8 +4,8 @@ import Foundation
 #if DEBUG
   extension AudioPlayerClient {
     static let failing = Self(
-      play: { _, _ in .failing("AudioPlayerClient.play") },
-      stop: { _ in .failing("AudioPlayerClient.stop") }
+      play: { _ in .failing("AudioPlayerClient.play") },
+      stop: { .failing("AudioPlayerClient.stop") }
     )
   }
 #endif

Examples/VoiceMemos/VoiceMemos/AudioPlayerClient/LiveAudioPlayerClient.swift

@@ -2,40 +2,42 @@ import AVFoundation
 import ComposableArchitecture
 
 extension AudioPlayerClient {
-  static let live = AudioPlayerClient(
-    play: { id, url in
-      .future { callback in
-        do {
-          let delegate = try AudioPlayerClientDelegate(
-            url: url,
-            didFinishPlaying: { flag in
-              callback(.success(.didFinishPlaying(successfully: flag)))
-              dependencies[id] = nil
-            },
-            decodeErrorDidOccur: { _ in
-              callback(.failure(.decodeErrorDidOccur))
-              dependencies[id] = nil
-            }
-          )
+  static var live: Self {
+    var delegate: AudioPlayerClientDelegate?
+    return Self(
+      play: { url in
+        .future { callback in
+          delegate?.player.stop()
+          delegate = nil
+          do {
+            delegate = try AudioPlayerClientDelegate(
+              url: url,
+              didFinishPlaying: { flag in
+                callback(.success(.didFinishPlaying(successfully: flag)))
+                delegate = nil
+              },
+              decodeErrorDidOccur: { _ in
+                callback(.failure(.decodeErrorDidOccur))
+                delegate = nil
+              }
+            )
 
-          delegate.player.play()
-          dependencies[id] = delegate
-        } catch {
-          callback(.failure(.couldntCreateAudioPlayer))
+            delegate?.player.play()
+          } catch {
+            callback(.failure(.couldntCreateAudioPlayer))
+          }
+        }
+      },
+      stop: {
+        .fireAndForget {
+          delegate?.player.stop()
+          delegate = nil
         }
       }
-    },
-    stop: { id in
-      .fireAndForget {
-        dependencies[id]?.player.stop()
-        dependencies[id] = nil
-      }
-    }
-  )
+    )
+  }
 }
 
-private var dependencies: [AnyHashable: AudioPlayerClientDelegate] = [:]
-
 private class AudioPlayerClientDelegate: NSObject, AVAudioPlayerDelegate {
   let didFinishPlaying: (Bool) -> Void
   let decodeErrorDidOccur: (Error?) -> Void

Examples/VoiceMemos/VoiceMemos/AudioRecorderClient/AudioRecorderClient.swift

@@ -2,10 +2,10 @@ import ComposableArchitecture
 import Foundation
 
 struct AudioRecorderClient {
-  var currentTime: (AnyHashable) -> Effect<TimeInterval?, Never>
+  var currentTime: () -> Effect<TimeInterval?, Never>
   var requestRecordPermission: () -> Effect<Bool, Never>
-  var startRecording: (AnyHashable, URL) -> Effect<Action, Failure>
-  var stopRecording: (AnyHashable) -> Effect<Never, Never>
+  var startRecording: (URL) -> Effect<Action, Failure>
+  var stopRecording: () -> Effect<Never, Never>
 
   enum Action: Equatable {
     case didFinishRecording(successfully: Bool)

Examples/VoiceMemos/VoiceMemos/AudioRecorderClient/FailingAudioRecorderClient.swift

@@ -4,10 +4,10 @@ import Foundation
 #if DEBUG
   extension AudioRecorderClient {
     static let failing = Self(
-      currentTime: { _ in .failing("AudioRecorderClient.currentTime") },
+      currentTime: { .failing("AudioRecorderClient.currentTime") },
       requestRecordPermission: { .failing("AudioRecorderClient.requestRecordPermission") },
-      startRecording: { _, _ in .failing("AudioRecorderClient.startRecording") },
-      stopRecording: { _ in .failing("AudioRecorderClient.stopRecording") }
+      startRecording: { _ in .failing("AudioRecorderClient.startRecording") },
+      stopRecording: { .failing("AudioRecorderClient.stopRecording") }
     )
   }
 #endif

Examples/VoiceMemos/VoiceMemos/AudioRecorderClient/LiveAudioRecorderClient.swift

@@ -3,67 +3,74 @@ import ComposableArchitecture
 import ReactiveSwift
 
 extension AudioRecorderClient {
-  static let live = AudioRecorderClient(
-    currentTime: { id in
-      Effect { () -> Result<TimeInterval?, Never> in
-        guard
-          let recorder = dependencies[id]?.recorder,
-          recorder.isRecording
-        else { return .success(nil) }
-        return .success(recorder.currentTime)
-      }
-    },
-    requestRecordPermission: {
-      .future { callback in
-        AVAudioSession.sharedInstance().requestRecordPermission { granted in
-          callback(.success(granted))
+  static var live: Self {
+    var delegate: AudioRecorderClientDelegate?
+
+    return Self(
+      currentTime: {
+        .result {
+          guard
+            let recorder = delegate?.recorder,
+            recorder.isRecording
+          else { return .success(nil) }
+          return .success(recorder.currentTime)
         }
-      }
-    },
-    startRecording: { id, url in
-      .future { callback in
-        guard
-          let delegate = try? AudioRecorderClientDelegate(
-            url: url,
-            didFinishRecording: { flag in
-              callback(.success(.didFinishRecording(successfully: flag)))
-              dependencies[id] = nil
-            },
-            encodeErrorDidOccur: { _ in
-              callback(.failure(.encodeErrorDidOccur))
-              dependencies[id] = nil
-            }
-          )
-        else {
-          callback(.failure(.couldntCreateAudioRecorder))
-          return
+      },
+      requestRecordPermission: {
+        .future { callback in
+          AVAudioSession.sharedInstance().requestRecordPermission { granted in
+            callback(.success(granted))
+          }
         }
+      },
+      startRecording: { url in
+        .future { callback in
+          delegate?.recorder.stop()
+          delegate = nil
+          do {
+            delegate = try AudioRecorderClientDelegate(
+              url: url,
+              didFinishRecording: { flag in
+                callback(.success(.didFinishRecording(successfully: flag)))
+                delegate = nil
+                try? AVAudioSession.sharedInstance().setActive(false)
+              },
+              encodeErrorDidOccur: { _ in
+                callback(.failure(.encodeErrorDidOccur))
+                delegate = nil
+                try? AVAudioSession.sharedInstance().setActive(false)
+              }
+            )
+          } catch {
+            callback(.failure(.couldntCreateAudioRecorder))
+            return
+          }
 
-        do {
-          try AVAudioSession.sharedInstance().setCategory(.record, mode: .default)
-        } catch {
-          callback(.failure(.couldntActivateAudioSession))
-          return
-        }
+          do {
+            try AVAudioSession.sharedInstance().setCategory(.record, mode: .default)
+          } catch {
+            callback(.failure(.couldntActivateAudioSession))
+            return
+          }
 
-        do {
-          try AVAudioSession.sharedInstance().setActive(true, options: [])
-        } catch {
-          callback(.failure(.couldntSetAudioSessionCategory))
-          return
-        }
+          do {
+            try AVAudioSession.sharedInstance().setActive(true)
+          } catch {
+            callback(.failure(.couldntSetAudioSessionCategory))
+            return
+          }
 
-        dependencies[id] = delegate
-        delegate.recorder.record()
-      }
-    },
-    stopRecording: { id in
-      .fireAndForget {
-        dependencies[id]?.recorder.stop()
-        try? AVAudioSession.sharedInstance().setActive(false, options: [])
+          delegate?.recorder.record()
+        }
+      },
+      stopRecording: {
+        .fireAndForget {
+          delegate?.recorder.stop()
+          try? AVAudioSession.sharedInstance().setActive(false)
+        }
       }
-    }
-  )
+    )
+  }
 }
 
 private class AudioRecorderClientDelegate: NSObject, AVAudioRecorderDelegate {
@@ -98,5 +105,3 @@ private class AudioRecorderClientDelegate: NSObject, AVAudioRecorderDelegate {
     self.encodeErrorDidOccur(error)
   }
 }
-
-private var dependencies: [AnyHashable: AudioRecorderClientDelegate] = [:]

Examples/VoiceMemos/VoiceMemos/Helpers.swift

@@ -1,12 +1,5 @@
 import Foundation
 
-let dateFormatter: DateFormatter = {
-  let formatter = DateFormatter()
-  formatter.dateStyle = .short
-  formatter.timeStyle = .medium
-  return formatter
-}()
-
 let dateComponentsFormatter: DateComponentsFormatter = {
   let formatter = DateComponentsFormatter()
   formatter.allowedUnits = [.minute, .second]

Examples/VoiceMemos/VoiceMemos/VoiceMemo.swift

@@ -41,9 +41,9 @@ struct VoiceMemoEnvironment {
   var mainRunLoop: DateScheduler
 }
 
-let voiceMemoReducer = Reducer<VoiceMemo, VoiceMemoAction, VoiceMemoEnvironment> {
-  memo, action, environment in
-  struct PlayerId: Hashable {}
+let voiceMemoReducer = Reducer<
+  VoiceMemo, VoiceMemoAction, VoiceMemoEnvironment
+> { memo, action, environment in
   struct TimerId: Hashable {}
 
   switch action {
@@ -53,35 +53,31 @@ let voiceMemoReducer = Reducer<VoiceMemo, VoiceMemoAction, VoiceMemoEnvironment>
 
   case .delete:
     return .merge(
-      environment.audioPlayerClient
-        .stop(PlayerId())
-        .fireAndForget(),
-      Effect.cancel(id: PlayerId()),
+      environment.audioPlayerClient.stop().fireAndForget(),
       Effect.cancel(id: TimerId())
     )
 
   case .playButtonTapped:
     switch memo.mode {
     case .notPlaying:
       memo.mode = .playing(progress: 0)
+
       let start = environment.mainRunLoop.currentDate
       return .merge(
         Effect.timer(id: TimerId(), every: .milliseconds(500), on: environment.mainRunLoop)
           .map { .timerUpdated($0.timeIntervalSince1970 - start.timeIntervalSince1970) },
 
         environment.audioPlayerClient
-          .play(PlayerId(), memo.url)
+          .play(memo.url)
           .catchToEffect(VoiceMemoAction.audioPlayerClient)
-          .cancellable(id: PlayerId())
       )
 
     case .playing:
       memo.mode = .notPlaying
+
       return .concatenate(
         .cancel(id: TimerId()),
-        environment.audioPlayerClient
-          .stop(PlayerId())
-          .fireAndForget()
+        environment.audioPlayerClient.stop().fireAndForget()
       )
     }
 
@@ -113,42 +109,40 @@ struct VoiceMemoView: View {
   }
 
   var body: some View {
-    GeometryReader { proxy in
-      ZStack(alignment: .leading) {
-        if self.viewStore.mode.isPlaying {
-          Rectangle()
-            .foregroundColor(Color(.systemGray5))
-            .frame(width: proxy.size.width * CGFloat(self.viewStore.mode.progress ?? 0))
-            .animation(.linear(duration: 0.5), value: self.viewStore.mode.progress)
-        }
-
-        HStack {
-          TextField(
-            "Untitled, \(dateFormatter.string(from: self.viewStore.date))",
-            text: self.viewStore.binding(
-              get: \.title, send: VoiceMemoAction.titleTextFieldChanged)
-          )
-
-          Spacer()
-
-          dateComponentsFormatter.string(from: self.currentTime).map {
-            Text($0)
-              .font(.footnote.monospacedDigit())
-              .foregroundColor(Color(.systemGray))
-          }
-
-          Button(action: { self.viewStore.send(.playButtonTapped) }) {
-            Image(systemName: self.viewStore.mode.isPlaying ? "stop.circle" : "play.circle")
-              .font(.system(size: 22))
-          }
-        }
-        .frame(maxHeight: .infinity, alignment: .center)
-        .padding(.horizontal)
+    HStack {
+      TextField(
+        "Untitled, \(self.viewStore.date.formatted(date: .numeric, time: .shortened))",
+        text: self.viewStore.binding(
+          get: \.title, send: VoiceMemoAction.titleTextFieldChanged)
+      )
+
+      Spacer()
+
+      dateComponentsFormatter.string(from: self.currentTime).map {
+        Text($0)
+          .font(.footnote.monospacedDigit())
+          .foregroundColor(Color(.systemGray))
+      }
+
+      Button(action: { self.viewStore.send(.playButtonTapped) }) {
+        Image(systemName: self.viewStore.mode.isPlaying ? "stop.circle" : "play.circle")
+          .font(.system(size: 22))
       }
     }
     .buttonStyle(.borderless)
+    .frame(maxHeight: .infinity, alignment: .center)
+    .padding(.horizontal)
     .listRowBackground(self.viewStore.mode.isPlaying ? Color(.systemGray6) : .clear)
     .listRowInsets(EdgeInsets())
+    .background(
+      Color(.systemGray5)
+        .frame(maxWidth: self.viewStore.mode.isPlaying ? .infinity : 0)
+        .animation(
+          self.viewStore.mode.isPlaying ? .linear(duration: self.viewStore.duration) : nil,
+          value: self.viewStore.mode.isPlaying
+        ),
+      alignment: .leading
+    )
   }
 
   var currentTime: TimeInterval {