Update state after audio player stops playing

[kakhaberikiknadze]

I send an action from button to reducer to start playing and I want to update icon to stop icon and once it's finished I want to automatically update it to play icon again. First, is straightforward and I update it but what's the best practice to update it back to "Start" once audio is finished?

Here's the simplified code just for an example ignoring all the complex logic. Just, start and stop stuff. Plus I use fireAndForget on stop for simplicity of the discussion.

struct MyReducer: ReducerProtocol {
    @Dependency(\.player) var player

    struct State: Equatable {
        // properties
    }

    enum Action {
        case start
        case startResult(TaskResult<Void>)
        case stop
    }

    var body: some ReducerProtocol<State, Action> {
        Reduce { state, action in
            switch action {
                case start:
                    // set item boolean prop to is playing
                    return .task {
                        await .startResult(
                            .init(try await player.play())
                        )
                    }
                // *** handling start result
                case stop:
                   // set item boolean prop to not playing
                   return .fireAndForget { await player.stop() } 
            }
        }
    }
}

Let's say player returns async result of, for example, Void or it returns a publisher or maybe a closure indicating it's stopped. How should I handle that properly? 🤔

Package version: 0.50.2

[kakhaberikiknadze]

Just in case you're interested in more complex implementation I'll provide it here as well.

I haven't yet added functionality on audio player to return result when audio is ended as I'm not quite sure what would be the best way of doing it.

struct ProjectsReducer: ReducerProtocol {
    @Dependency(\.fileManager) var fileManager
    @Dependency(\.simpleAudioPlayer) var audioPlayer
    
    struct State: Equatable {
        var title: String
        var icon: ImageSource
        var items: OrderedSet<Item>
    }
    
    enum Action {
        case refresh
        case refreshResult(TaskResult<[State.Item]>)
        case playAudio(State.File)
        case playAudioResult(TaskResult<State.File>)
        case stopAudio(State.File)
        case stopAudioResult(TaskResult<State.File>)
    }
    
    var body: some ReducerProtocol<State, Action> {
        Reduce { state, action in
            switch action {
            case .refresh:
                return .task {
                    await .refreshResult(
                        .init {
                            let result = try await fileManager.getContent(.documentDirectory)
                            return await result.asyncMap { url in
                                if url.hasDirectoryPath {
                                    return .directory(.init(url: url, title: url.lastPathComponent))
                                } else {
                                    return await .file(.init(url: url))
                                }
                            }
                        }
                    )
                }
            case let .refreshResult(.success(items)):
                state.items = .init(items)
                return .none
            case let .refreshResult(.failure(error)):
                print(error.localizedDescription)
                return .none
                
            // MARK: - Playback
                
            case let .playAudio(file):
                return .task {
                    await .playAudioResult(
                        .init {
                            try await audioPlayer.play(file.url)
                            return file
                        }
                    )
                }
            case let .playAudioResult(.success(file)):
                return updateFile(file: file, isRunning: true, state: &state)
            case let .playAudioResult(.failure(error)):
                print(error.localizedDescription)
                return .none
                
            case let .stopAudio(file):
                return .task {
                    await .stopAudioResult(
                        .init {
                            try await audioPlayer.stop(file.url)
                            return file
                        }
                    )
                }
            case let .stopAudioResult(.success(file)):
                return updateFile(file: file, isRunning: false, state: &state)
            case let .stopAudioResult(.failure(error)):
                print(error.localizedDescription)
                return .none
            }
        }
    }
    
    private func updateFile(
        file: State.File,
        isRunning: Bool,
        state: inout State
    ) -> EffectTask<Action> {
        if let index = state.items.firstIndex(where: { $0.id == file.id }) {
            var runningFile = file
            runningFile.isRunning = isRunning
            state.items.remove(at: index)
            state.items.insert(.file(runningFile), at: index)
        }
        return .none
    }
}

[kakhaberikiknadze]

It's about updating those trailing icons.

[kakhaberikiknadze]

I made it work by using .run.

case let .playAudio(file):
                return .run { send in
                    await send(
                        .playAudioResult(
                            .init {
                                try await audioPlayer.play(file.url)
                                return file
                            }
                        )
                    )
                    try await audioPlayer.waitForStop(file.url)
                    await send(.audioFinished(file))
                }
                .cancellable(id: file.id, cancelInFlight: true)

I could not manage to hook AVAudioPlayer's end of stream publisher so far but testing out with Task.sleep(for: .seconds(2)) I saw it's working.

[acosmicflamingo]

Here is my DeviceClient dependency I created that sets up the publishers:

// swiftformat:disable indent

import A11yKit
import Combine
import Dependencies
import DeviceDependency
import ProcessInfoDependency
import UIApplicationClient
import UIKit

extension DeviceClient: DependencyKey {
  public static var liveValue: Self {
    let interfaceOrientationGenerator = { @MainActor @Sendable (
      applicationClient: UIApplicationClient
    ) -> UIInterfaceOrientation in
      applicationClient.keyWindow?.windowScene?.interfaceOrientation ?? .unknown
    }
    let conservePowerGenerator = { @MainActor @Sendable (
      device: Device, processInfo: ProcessInfo.Value
    ) -> Bool in
      device.batteryLevel <= 0.2 ||
      processInfo.thermalState == .critical ||
      processInfo.isLowPowerModeEnabled
    }
    let _implementation = Implementation(
      idiom: .init { device in device.userInterfaceIdiom },
      interfaceOrientation: .init { interfaceOrientationGenerator },
      interfaceOrientationPublisher: .init { application, notificationCenter in
        let condition = interfaceOrientationGenerator
        let notification = UIDevice.orientationDidChangeNotification
        return Just(condition(application))
          .merge(
            with: notificationCenter.publisher(for: notification)
              .map { _ in condition(application) }
          ).removeDuplicates()
          .eraseToAnyPublisher()
      },
      conservePower: .init { conservePowerGenerator },
      enableTransparency: .init { a11yClient, device, processInfo in
        // UIDevice.current.batteryLabel is always -1.0 when app
        // is run on simulator. Need to ignore device.batteryLevel
        // value when app is run on simulator and not during a
        // testing context
        let conservePower = conservePowerGenerator(device, processInfo)
        #if targetEnvironment(simulator)
          switch _XCTIsTesting {
          case true:
            return !a11yClient.reduceTransparencyEnabled && !conservePower

          case false:
            return !a11yClient.reduceTransparencyEnabled
          }
        #else
          if !device.isBatteryMonitoringEnabled {
            device.isBatteryMonitoringEnabled = true
          }
          return !a11yClient.reduceTransparencyEnabled && !conservePower
        #endif
      }
    )
    return .init(_implementation: _implementation)
  }
}

// swiftformat:enable indent

It's probably not what you're looking for because NotificationCenter does all the heavy lifting for me. What I had to do was actually create a publisher that emits a value the moment a subscriber sinks to it. With NotificationCenter publishers, it will only emit a value after a notification has been sent (which is what the Just publishers are for).

[kakhaberikiknadze]

Yeah, AVAudioPlayer doesn't really do such heavy lifting and even that publisher I made is a workaround. I'll test tomorrow if it's actually producing only one value or it's me doing something silly. It prints that the demand is 1 so I guess it's more of me doing something wrong 😀

Anyways, that's a different issue and the actual issue I had is solved by things mentioned in this thread so I guess I'll mark it as solved 🤘🏻

[acosmicflamingo]

Good luck :)

[kakhaberikiknadze]

Thanks 🙌🏻

[kakhaberikiknadze]

I tried it out in the morning and forgot to update. As it seems it was the issue of AVAudioPlayer not publishing a new time using publisher(for: \.currentTime). Custom publisher I added just for testing purposes was working as expected and also, subscribing to audio player's current time somewhere in the class was also producing only one value.

[mbrandonw]

Hi @kakhaberikiknadze, the "Voice Memos" demo application in this repo might help you. We have an AudioPlayerClient dependency whose play endpoint suspends for the duration of the audio file playing. That allows you to do things like:

return .run { send in 
  self.audioPlayer.play(…)
  await send(.audioFinished)
}

[kakhaberikiknadze]

Cool 👍🏻 Will have a look