Something went wrong. Try again.
A music player that connects to your cloud/distributed storage. forked from tokono.ma/diffuse
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375module UI.Audio.State exposing (..)
import Base64import Common exposing (boolToString)import Debouncer.Basic as Debouncerimport Dictimport LastFmimport List.Extra as Listimport MediaSessionimport Return exposing (return)import Return.Ext as Return exposing (communicate)import Tracksimport UI.Audio.Types exposing (..)import UI.Common.State as Commonimport UI.Common.Types exposing (DebounceManager)import UI.Ports as Portsimport UI.Queue.State as Queueimport UI.Types as UI exposing (Manager, Msg(..))import UI.User.State.Export as User
-- 📣 ░░ EVENTS
durationChange : DurationChangeEvent -> ManagerdurationChange { trackId, duration } = onlyIfMatchesNowPlaying { trackId = trackId } (\nowPlaying -> if nowPlaying.duration == Nothing || nowPlaying.duration /= Just duration then durationChange_ { trackId = trackId, duration = duration } nowPlaying
else -- Ignore repeating events Return.singleton )
durationChange_ : DurationChangeEvent -> NowPlaying -> ManagerdurationChange_ { trackId, duration } nowPlaying model = let ( identifiers, track ) = nowPlaying.item.identifiedTrack
maybeCover = List.find (\c -> List.member trackId c.trackIds) model.covers.arranged
coverPrep = Maybe.map (\cover -> { cacheKey = Base64.encode (Tracks.coverKey cover.variousArtists track) , trackFilename = identifiers.filename , trackPath = track.path , trackSourceId = track.sourceId , variousArtists = boolToString cover.variousArtists } ) maybeCover
coverLoaded = case ( maybeCover, model.cachedCovers ) of ( Just cover, Just cachedCovers ) -> let key = Base64.encode (Tracks.coverKey cover.variousArtists track) in Dict.member key cachedCovers
_ -> False
metadata = { album = track.tags.album , artist = track.tags.artist , title = track.tags.title
-- , coverPrep = coverPrep } in model |> replaceNowPlaying { nowPlaying | coverLoaded = coverLoaded, duration = Just duration } |> Return.command (Ports.setMediaSessionMetadata metadata) |> Return.command (Ports.resetScrobbleTimer { duration = duration, trackId = trackId }) |> Return.andThen (notifyScrobblersOfTrackPlaying { duration = duration })
error : ErrorAudioEvent -> Managererror { trackId, code } = onlyIfMatchesNowPlaying { trackId = trackId } (\nowPlaying -> replaceNowPlaying (case code of 2 -> { nowPlaying | loadingState = NetworkError }
3 -> { nowPlaying | loadingState = DecodeError }
4 -> { nowPlaying | loadingState = NotSupportedError }
_ -> nowPlaying ) )
ended : GenericAudioEvent -> Managerended { trackId } = onlyIfMatchesNowPlaying { trackId = trackId } (\nowPlaying model -> if model.repeat then Return.command (case nowPlaying.duration of Just duration -> Ports.resetScrobbleTimer { duration = duration, trackId = trackId }
Nothing -> Cmd.none ) (play model)
else Return.andThen (if Maybe.map (\d -> Tracks.shouldNoteProgress { duration = d }) nowPlaying.duration == Just True then noteProgress { trackId = trackId, progress = 1.0 }
else Return.singleton ) (Queue.shift model) )
hasLoaded : GenericAudioEvent -> ManagerhasLoaded { trackId } = onlyIfMatchesNowPlaying { trackId = trackId } (\nowPlaying -> replaceNowPlaying { nowPlaying | loadingState = Loaded } )
isLoading : GenericAudioEvent -> ManagerisLoading { trackId } = onlyIfMatchesNowPlaying { trackId = trackId } (\nowPlaying -> replaceNowPlaying { nowPlaying | loadingState = Loading } )
playbackStateChanged : PlaybackStateEvent -> ManagerplaybackStateChanged { trackId, isPlaying } = onlyIfMatchesNowPlaying { trackId = trackId } (\nowPlaying model -> { model | nowPlaying = Just { nowPlaying | isPlaying = isPlaying } } |> Return.singleton |> Return.command (if isPlaying then Ports.startScrobbleTimer ()
else Ports.pauseScrobbleTimer () ) |> Return.command (Ports.setMediaSessionPlaybackState (if isPlaying then MediaSession.states.playing
else MediaSession.states.paused ) ) )
timeUpdated : TimeUpdatedEvent -> ManagertimeUpdated { trackId, currentTime, duration } = onlyIfMatchesNowPlaying { trackId = trackId } (\nowPlaying model -> let dur = Maybe.withDefault 0 duration in { model | nowPlaying = Just { nowPlaying | duration = duration, playbackPosition = currentTime } } |> (if Tracks.shouldNoteProgress { duration = dur } then { trackId = trackId , progress = currentTime / dur } |> NoteProgress |> Debouncer.provideInput |> NoteProgressDebounce |> Return.task |> Return.communicate
else Return.singleton ) |> Return.command (case duration of Just d -> Ports.setMediaSessionPositionState { currentTime = currentTime , duration = d }
Nothing -> Cmd.none ) )
-- 📣 ░░ COMMANDS
pause : Managerpause model = case model.nowPlaying of Just { item } -> communicate (Ports.pause { trackId = (Tuple.second item.identifiedTrack).id } ) model
Nothing -> Return.singleton model
playPause : ManagerplayPause model = case model.nowPlaying of Just { isPlaying } -> if isPlaying then pause model
else play model
Nothing -> play model
play : Managerplay model = case model.nowPlaying of Just { item } -> communicate (Ports.play { trackId = (Tuple.second item.identifiedTrack).id , volume = model.eqSettings.volume } ) model
Nothing -> Queue.shift model
seek : { trackId : String, progress : Float } -> Managerseek { trackId, progress } = { percentage = progress, trackId = trackId } |> Ports.seek |> Return.communicate
stop : Managerstop model = model.audioElements |> List.filter (.isPreload >> (==) True) |> (\a -> { model | audioElements = a }) |> Queue.changeActiveItem Nothing |> Return.effect_ (\m -> Ports.renderAudioElements { items = m.audioElements , play = Nothing , volume = m.eqSettings.volume } )
-- 📣
noteProgress : { trackId : String, progress : Float } -> ManagernoteProgress { trackId, progress } model = let updatedProgressTable = if not model.rememberProgress then model.progress
else if progress > 0.975 then Dict.remove trackId model.progress
else Dict.insert trackId progress model.progress in if model.rememberProgress then User.saveProgress { model | progress = updatedProgressTable }
else Return.singleton model
noteProgressDebounce : DebounceManagernoteProgressDebounce = Common.debounce .progressDebouncer (\d m -> { m | progressDebouncer = d }) UI.NoteProgressDebounce
notifyScrobblersOfTrackPlaying : { duration : Float } -> ManagernotifyScrobblersOfTrackPlaying { duration } model = case model.nowPlaying of Just { item } -> { duration = round duration , msg = UI.Bypass , track = Tuple.second item.identifiedTrack } |> LastFm.nowPlaying model.lastFm |> return model
Nothing -> Return.singleton model
preloadDebounce : DebounceManagerpreloadDebounce = Common.debounce .preloadDebouncer (\d m -> { m | preloadDebouncer = d }) UI.AudioPreloadDebounce
toggleRememberProgress : ManagertoggleRememberProgress model = User.saveSettings { model | rememberProgress = not model.rememberProgress }
-- 🛠️
onlyIfMatchesNowPlaying : { trackId : String } -> (NowPlaying -> Manager) -> ManageronlyIfMatchesNowPlaying { trackId } fn model = case model.nowPlaying of Just ({ item } as nowPlaying) -> if trackId == (Tuple.second item.identifiedTrack).id then fn nowPlaying model
else Return.singleton model
Nothing -> Return.singleton model
replaceNowPlaying : NowPlaying -> ManagerreplaceNowPlaying np model = Return.singleton { model | nowPlaying = Just np }