player.usecase.swift

struct Player: UseCase {
    enum Request  {
        case play(Station)
        case pause
    }
    enum Response {
        case playing(String, on:Station)
        case paused (Station)
        case waiting(Station)
    }
    init(audioplayer p: AudioPlayer,
         store       s: Store,
         responder   r: @escaping (Response) -> ()
    ) {
        interactor = Interactor(audioplayer:p, store:s, respond:r)
    }
    func request(to request:Request) {
        switch request {
        case .play(let s): play (station: s)
        case .pause      : pause()
        }
    }
    private let interactor: Interactor
    typealias  RequestType = Request
    typealias ResponseType = Response
}

// MARK: - private
private extension Player {
    func play (station:Station) { interactor.play(station:station) }
    func pause()                { interactor.pause()               }
}
private extension Player {
    final class Interactor {
        init(audioplayer p: AudioPlayer,
             store       s: Store,
             respond     r: @escaping (Response) -> ()
        ) {
            player  = p
            store   = s
            respond = r
            player.delegate = self
        }
        func play(station s:Station) {
            let session = AVAudioSession.sharedInstance()
            do {
                try session.setActive(true)
                try session.setCategory(.playback, mode:.default, options:.defaultToSpeaker)
            } catch{
                print(error.localizedDescription)
            }
            station  = s
            songName = ""
            if let address = s.urls.last?.address {
                guard let url = URL(string:address) else { return }
                player.play(url:url)
                change(store, .current(.playing(songname:songName,on:s)))
                respond(.playing(songName, on:s))
            }
        }
        func pause() {
            player.stop()
            guard
                let station = station
            else { return }
            store.change(.current(.paused(station)))
            respond(.paused(station))
        }
        private var station : Station?
        private var player  : AudioPlayer
        private var songName: String = ""
        private let store   : Store
        private let respond : (Response) -> ()
    }
}
extension Player.Interactor:AudioPlayerDelegate {
    func audioPlayerDidReadMetadata(player: AudioPlayer, metadata: [String : String]) {
        songName = metadata["StreamTitle"] ?? ""
        songName != "" ? respond(.playing(songName,on:station!)) : ()
    }
}