player.js

/*
 * @copyright Copyright (c) 2021 Jonas Heinrich <onny@project-insanity.org>
 *
 * @author Jonas Heinrich <onny@project-insanity.org>
 *
 * @license GNU AGPL version 3 or any later version
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as
 * published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 *
 */

import { Player } from './../services/Player'
import { FyydApi } from './../services/FyydApi'

const player = new Player()
const fyydClient = new FyydApi()

export default {
	state: {
		isPlaying: false,
		isBuffering: false,
		isMute: false,
		isPaused: false,
		volume: parseFloat(localStorage.getItem('podcast.volume')),
		oldVolume: null,
		title: '',
		image: '',
		episodeId: null,
		duration: null,
		seek: 0,
		lastplaytimeupdate: null,
		podcastName: '',
	},
	getters: {
		getTitle: state => {
			return state.title
		},
		getPodcastName: state => {
			return state.podcastName
		},
		getImage: state => {
			return state.image
		},
		getSeek: state => {
			return state.seek
		},
		getDuration: state => {
			return state.duration
		},
		getVolume: state => {
			if (state.volume) {
				return state.volume
			} else {
				return 0.5
			}
		},
		isPlaying: state => {
			return state.isPlaying
		},
		isBuffering: state => {
			return state.isBuffering
		},
		isPaused: state => (id) => {
			return (state.episodeId === id && state.isPaused)
		},
		episodeLoaded: state => (id) => {
			return (state.episodeId === id)
		},
		episodePlaying: state => (id) => {
			return (state.episodeId === id && state.isPlaying)
		},
	},
	mutations: {
		setVolume(state, volume) {
			state.volume = volume
			localStorage.setItem('podcast.volume', volume)
			player.setVolume(state.volume)
		},
		toggleMute(state) {
			if (state.isMute) {
				state.volume = state.oldVolume
				state.isMute = false
			} else {
				if (state.volume === 0) {
					state.volume = 1
				} else {
					state.oldVolume = state.volume
					state.volume = 0
					state.isMute = true
				}
			}
			localStorage.setItem('podcast.volume', state.volume)
			player.setVolume(state.volume)
		},
		setTitle(state, title) {
			state.title = title
		},
		setDuration(state, duration) {
			duration = Math.round(duration)
			state.duration = duration
		},
		setSeek(state, seek) {
			seek = Math.round(seek)
			state.seek = seek
		},
		seekEpisode(state, seek) {
			player.seek(seek)
			seek = Math.round(seek)
			state.seek = seek
		},
		setPlaying(state, playerState) {
			state.isPlaying = playerState
		},
		setPausing(state, pauseState) {
			state.isPaused = pauseState
		},
		setBuffering(state, bufferingState) {
			state.isBuffering = bufferingState
		},
		setImage(state, image) {
			state.image = image
		},
		setEpisodeId(state, episodeId) {
			state.episodeId = episodeId
		},
		setPodcastName(state, name) {
			state.podcastName = name
		},
	},
	actions: {
		setPlaying(context, playerState) {
			context.commit('setPlaying', playerState)
		},
		setBuffering(context, bufferingState) {
			context.commit('setBuffering', bufferingState)
		},
		setVolume(context, volume) {
			context.commit('setVolume', volume)
		},
		toggleMute(context) {
			context.commit('toggleMute')
		},
		playEpisode(context, episode) {
			if (context.state.isPaused && episode.id === context.state.episodeId) {
				context.commit('setPausing', false)
				context.commit('setBuffering', true)
				player.doResume()
			} else {
				context.commit('setPodcastName', '')
				context.commit('setBuffering', true)
				context.commit('setTitle', episode.title)
				if (episode.imgURL) {
					context.commit('setImage', episode.imgURL)
				} else {
					context.commit('setImage', episode.imgurl)
				}
				context.commit('setEpisodeId', episode.id)
				context.commit('setPausing', false)
				context.commit('setPlaying', true)
				context.dispatch('addEpisode', episode)
				if (episode.podcast_id) {
					context.dispatch('setPodcastName', episode.podcast_id)
				} else {
					context.dispatch('setPodcastName', episode.podcastid)
				}
				player.doPlay(episode.enclosure)
			}
		},
		pauseEpisode(context) {
			context.commit('setBuffering', false)
			context.commit('setPlaying', false)
			context.commit('setPausing', true)
			player.doPause()
		},

		setSeek(context, startTime) {
			context.commit('setSeek', startTime)
		},

		togglePlay(context) {
			if (context.state.episodeId === null) {
				return true
			}
			if (context.state.isPaused) {
				context.commit('setPlaying', true)
				context.commit('setBuffering', true)
				context.commit('setPausing', false)
				player.doResume()
			} else {
				context.commit('setBuffering', false)
				context.commit('setPausing', true)
				context.commit('setPausing', true)
				player.doPause()
			}
		},

		setDuration(context, duration) {
			context.commit('setDuration', duration)
		},

		seekEpisode(context, startTime) {
			context.commit('seekEpisode', startTime)
		},

		storePlaybacktime(context, position) {
			const episodeId = context.state.episodeId
			const episode = context.getters.episodeById(episodeId)
			const episodeLastPlayed = episode.lastplayed
			const dateNow = Date.now()
			if (dateNow - episodeLastPlayed >= 5000) {
				context.dispatch('updateEpisode', { episode, playtime: position })
			}
		},

		async setPodcastName(context, podcastId) {
			console.log('podcast_id', podcastId)
			const podcast = await fyydClient.queryPodcast(podcastId)
			context.commit('setPodcastName', podcast.data.title)
		},
	},
}