mirror of
https://github.com/libre-tube/LibreTube.git
synced 2024-12-16 15:20:31 +05:30
420 lines
13 KiB
Kotlin
420 lines
13 KiB
Kotlin
package com.github.libretube.services
|
|
|
|
import android.app.Notification
|
|
import android.app.NotificationChannel
|
|
import android.app.NotificationManager
|
|
import android.app.Service
|
|
import android.content.Intent
|
|
import android.os.Binder
|
|
import android.os.Build
|
|
import android.os.Handler
|
|
import android.os.IBinder
|
|
import android.os.Looper
|
|
import android.util.Log
|
|
import android.widget.Toast
|
|
import androidx.core.app.ServiceCompat
|
|
import com.github.libretube.R
|
|
import com.github.libretube.api.JsonHelper
|
|
import com.github.libretube.api.RetrofitInstance
|
|
import com.github.libretube.api.obj.Segment
|
|
import com.github.libretube.api.obj.SegmentData
|
|
import com.github.libretube.api.obj.Streams
|
|
import com.github.libretube.constants.BACKGROUND_CHANNEL_ID
|
|
import com.github.libretube.constants.IntentData
|
|
import com.github.libretube.constants.PLAYER_NOTIFICATION_ID
|
|
import com.github.libretube.db.DatabaseHolder.Companion.Database
|
|
import com.github.libretube.db.obj.WatchPosition
|
|
import com.github.libretube.extensions.TAG
|
|
import com.github.libretube.extensions.awaitQuery
|
|
import com.github.libretube.extensions.query
|
|
import com.github.libretube.extensions.toID
|
|
import com.github.libretube.extensions.toStreamItem
|
|
import com.github.libretube.helpers.PlayerHelper
|
|
import com.github.libretube.helpers.PlayerHelper.loadPlaybackParams
|
|
import com.github.libretube.util.NowPlayingNotification
|
|
import com.github.libretube.util.PlayingQueue
|
|
import com.google.android.exoplayer2.ExoPlayer
|
|
import com.google.android.exoplayer2.MediaItem
|
|
import com.google.android.exoplayer2.PlaybackException
|
|
import com.google.android.exoplayer2.Player
|
|
import kotlinx.coroutines.CoroutineScope
|
|
import kotlinx.coroutines.Dispatchers
|
|
import kotlinx.coroutines.launch
|
|
import kotlinx.serialization.encodeToString
|
|
|
|
/**
|
|
* Loads the selected videos audio in background mode with a notification area.
|
|
*/
|
|
class BackgroundMode : Service() {
|
|
/**
|
|
* VideoId of the video
|
|
*/
|
|
private lateinit var videoId: String
|
|
|
|
/**
|
|
* PlaylistId/ChannelId for autoplay
|
|
*/
|
|
private var playlistId: String? = null
|
|
private var channelId: String? = null
|
|
|
|
/**
|
|
* The response that gets when called the Api.
|
|
*/
|
|
private var streams: Streams? = null
|
|
|
|
/**
|
|
* The [ExoPlayer] player. Followed tutorial [here](https://developer.android.com/codelabs/exoplayer-intro)
|
|
*/
|
|
var player: ExoPlayer? = null
|
|
private var playWhenReadyPlayer = true
|
|
|
|
/**
|
|
* SponsorBlock Segment data
|
|
*/
|
|
private var segmentData: SegmentData? = null
|
|
|
|
/**
|
|
* [Notification] for the player
|
|
*/
|
|
private lateinit var nowPlayingNotification: NowPlayingNotification
|
|
|
|
/**
|
|
* Autoplay Preference
|
|
*/
|
|
private val handler = Handler(Looper.getMainLooper())
|
|
|
|
/**
|
|
* Used for connecting to the AudioPlayerFragment
|
|
*/
|
|
private val binder = LocalBinder()
|
|
|
|
/**
|
|
* Listener for passing playback state changes to the AudioPlayerFragment
|
|
*/
|
|
var onIsPlayingChanged: ((isPlaying: Boolean) -> Unit)? = null
|
|
|
|
/**
|
|
* Setting the required [Notification] for running as a foreground service
|
|
*/
|
|
override fun onCreate() {
|
|
super.onCreate()
|
|
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
|
|
val channel = NotificationChannel(
|
|
BACKGROUND_CHANNEL_ID,
|
|
getString(R.string.background_mode),
|
|
NotificationManager.IMPORTANCE_DEFAULT
|
|
)
|
|
val notificationManager = getSystemService(NOTIFICATION_SERVICE) as NotificationManager
|
|
notificationManager.createNotificationChannel(channel)
|
|
|
|
// see https://developer.android.com/reference/android/app/Service#startForeground(int,%20android.app.Notification)
|
|
val notification: Notification = Notification.Builder(this, BACKGROUND_CHANNEL_ID)
|
|
.setContentTitle(getString(R.string.app_name))
|
|
.setContentText(getString(R.string.playingOnBackground))
|
|
.build()
|
|
|
|
startForeground(PLAYER_NOTIFICATION_ID, notification)
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Initializes the [player] with the [MediaItem].
|
|
*/
|
|
override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
|
|
try {
|
|
// reset the playing queue listeners
|
|
PlayingQueue.resetToDefaults()
|
|
|
|
// get the intent arguments
|
|
videoId = intent?.getStringExtra(IntentData.videoId)!!
|
|
playlistId = intent.getStringExtra(IntentData.playlistId)
|
|
val position = intent.getLongExtra(IntentData.position, 0L)
|
|
val keepQueue = intent.getBooleanExtra(IntentData.keepQueue, false)
|
|
|
|
// play the audio in the background
|
|
loadAudio(videoId, position, keepQueue)
|
|
|
|
PlayingQueue.setOnQueueTapListener { streamItem ->
|
|
streamItem.url?.toID()?.let { playNextVideo(it) }
|
|
}
|
|
|
|
if (PlayerHelper.watchPositionsEnabled) updateWatchPosition()
|
|
} catch (e: Exception) {
|
|
Log.e(TAG(), e.toString())
|
|
onDestroy()
|
|
}
|
|
return super.onStartCommand(intent, flags, startId)
|
|
}
|
|
|
|
private fun updateWatchPosition() {
|
|
player?.currentPosition?.let {
|
|
val watchPosition = WatchPosition(videoId, it)
|
|
|
|
// indicator that a new video is getting loaded
|
|
this.streams ?: return@let
|
|
|
|
query {
|
|
Database.watchPositionDao().insertAll(watchPosition)
|
|
}
|
|
}
|
|
handler.postDelayed(this::updateWatchPosition, 500)
|
|
}
|
|
|
|
/**
|
|
* Gets the video data and prepares the [player].
|
|
* @param videoId The id of the video to play
|
|
* @param seekToPosition The position of the video to seek to
|
|
* @param keepQueue Whether to keep the queue or clear it instead
|
|
*/
|
|
private fun loadAudio(
|
|
videoId: String,
|
|
seekToPosition: Long = 0,
|
|
keepQueue: Boolean = false
|
|
) {
|
|
CoroutineScope(Dispatchers.IO).launch {
|
|
streams = runCatching {
|
|
RetrofitInstance.api.getStreams(videoId)
|
|
}.getOrNull() ?: return@launch
|
|
|
|
// clear the queue if it shouldn't be kept explicitly
|
|
if (!keepQueue) PlayingQueue.clear()
|
|
|
|
if (PlayingQueue.isEmpty()) updateQueue()
|
|
|
|
// save the current stream to the queue
|
|
streams?.toStreamItem(videoId)?.let {
|
|
PlayingQueue.updateCurrent(it)
|
|
}
|
|
|
|
handler.post {
|
|
playAudio(seekToPosition)
|
|
}
|
|
}
|
|
}
|
|
|
|
private fun playAudio(seekToPosition: Long) {
|
|
initializePlayer()
|
|
setMediaItem()
|
|
|
|
// create the notification
|
|
if (!this@BackgroundMode::nowPlayingNotification.isInitialized) {
|
|
nowPlayingNotification = NowPlayingNotification(this@BackgroundMode, player!!, true)
|
|
}
|
|
nowPlayingNotification.updatePlayerNotification(videoId, streams!!)
|
|
|
|
player?.apply {
|
|
playWhenReady = playWhenReadyPlayer
|
|
prepare()
|
|
}
|
|
|
|
// seek to the previous position if available
|
|
if (seekToPosition != 0L) {
|
|
player?.seekTo(seekToPosition)
|
|
} else if (PlayerHelper.watchPositionsEnabled) {
|
|
runCatching {
|
|
val watchPosition = awaitQuery {
|
|
Database.watchPositionDao().findById(videoId)
|
|
}
|
|
streams?.duration?.let {
|
|
if (watchPosition != null && watchPosition.position < it * 1000 * 0.9) {
|
|
player?.seekTo(watchPosition.position)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fetchSponsorBlockSegments()
|
|
}
|
|
|
|
/**
|
|
* create the player
|
|
*/
|
|
private fun initializePlayer() {
|
|
if (player != null) return
|
|
|
|
player = ExoPlayer.Builder(this)
|
|
.setHandleAudioBecomingNoisy(true)
|
|
.setAudioAttributes(PlayerHelper.getAudioAttributes(), true)
|
|
.setLoadControl(PlayerHelper.getLoadControl())
|
|
.build()
|
|
.loadPlaybackParams()
|
|
|
|
/**
|
|
* Listens for changed playbackStates (e.g. pause, end)
|
|
* Plays the next video when the current one ended
|
|
*/
|
|
player?.addListener(object : Player.Listener {
|
|
override fun onIsPlayingChanged(isPlaying: Boolean) {
|
|
super.onIsPlayingChanged(isPlaying)
|
|
onIsPlayingChanged?.invoke(isPlaying)
|
|
}
|
|
|
|
override fun onPlaybackStateChanged(state: Int) {
|
|
when (state) {
|
|
Player.STATE_ENDED -> {
|
|
if (PlayerHelper.autoPlayEnabled) playNextVideo()
|
|
}
|
|
Player.STATE_IDLE -> {
|
|
onDestroy()
|
|
}
|
|
Player.STATE_BUFFERING -> {}
|
|
Player.STATE_READY -> {}
|
|
}
|
|
}
|
|
|
|
override fun onPlayerError(error: PlaybackException) {
|
|
// show a toast on errors
|
|
Handler(Looper.getMainLooper()).post {
|
|
Toast.makeText(
|
|
this@BackgroundMode.applicationContext,
|
|
error.localizedMessage,
|
|
Toast.LENGTH_SHORT
|
|
).show()
|
|
}
|
|
}
|
|
})
|
|
}
|
|
|
|
/**
|
|
* Plays the next video from the queue
|
|
*/
|
|
private fun playNextVideo(nextId: String? = null) {
|
|
val nextVideo = nextId ?: PlayingQueue.getNext() ?: return
|
|
|
|
// play new video on background
|
|
this.videoId = nextVideo
|
|
this.streams = null
|
|
this.segmentData = null
|
|
loadAudio(videoId, keepQueue = true)
|
|
}
|
|
|
|
/**
|
|
* Sets the [MediaItem] with the [streams] into the [player]
|
|
*/
|
|
private fun setMediaItem() {
|
|
streams ?: return
|
|
|
|
val uri = if (streams!!.audioStreams.orEmpty().isNotEmpty()) {
|
|
PlayerHelper.getAudioSource(
|
|
this,
|
|
streams!!.audioStreams!!
|
|
)
|
|
} else if (streams!!.hls != null) {
|
|
streams!!.hls
|
|
} else {
|
|
return
|
|
}
|
|
|
|
val mediaItem = MediaItem.Builder()
|
|
.setUri(uri)
|
|
.build()
|
|
player?.setMediaItem(mediaItem)
|
|
}
|
|
|
|
/**
|
|
* fetch the segments for SponsorBlock
|
|
*/
|
|
private fun fetchSponsorBlockSegments() {
|
|
CoroutineScope(Dispatchers.IO).launch {
|
|
runCatching {
|
|
val categories = PlayerHelper.getSponsorBlockCategories()
|
|
if (categories.isEmpty()) return@runCatching
|
|
segmentData = RetrofitInstance.api.getSegments(
|
|
videoId,
|
|
JsonHelper.json.encodeToString(categories)
|
|
)
|
|
checkForSegments()
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* check for SponsorBlock segments
|
|
*/
|
|
private fun checkForSegments() {
|
|
Handler(Looper.getMainLooper()).postDelayed(this::checkForSegments, 100)
|
|
|
|
if (segmentData == null || segmentData!!.segments.isEmpty()) return
|
|
|
|
segmentData!!.segments.forEach { segment: Segment ->
|
|
val segmentStart = (segment.segment[0] * 1000f).toLong()
|
|
val segmentEnd = (segment.segment[1] * 1000f).toLong()
|
|
val currentPosition = player?.currentPosition
|
|
if (currentPosition in segmentStart until segmentEnd) {
|
|
if (PlayerHelper.sponsorBlockNotifications) {
|
|
runCatching {
|
|
Toast.makeText(this, R.string.segment_skipped, Toast.LENGTH_SHORT)
|
|
.show()
|
|
}
|
|
}
|
|
player?.seekTo(segmentEnd)
|
|
}
|
|
}
|
|
}
|
|
|
|
private fun updateQueue() {
|
|
if (playlistId != null) {
|
|
streams?.toStreamItem(videoId)?.let {
|
|
PlayingQueue.insertPlaylist(playlistId!!, it)
|
|
}
|
|
} else if (channelId != null) {
|
|
streams?.toStreamItem(videoId)?.let {
|
|
PlayingQueue.insertChannel(channelId!!, it)
|
|
}
|
|
} else {
|
|
streams?.relatedStreams?.toTypedArray()?.let {
|
|
if (PlayerHelper.autoInsertRelatedVideos) PlayingQueue.add(*it)
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Stop the service when app is removed from the task manager.
|
|
*/
|
|
override fun onTaskRemoved(rootIntent: Intent?) {
|
|
super.onTaskRemoved(rootIntent)
|
|
onDestroy()
|
|
}
|
|
|
|
/**
|
|
* destroy the [BackgroundMode] foreground service
|
|
*/
|
|
override fun onDestroy() {
|
|
// clear the playing queue
|
|
PlayingQueue.resetToDefaults()
|
|
|
|
if (this::nowPlayingNotification.isInitialized) nowPlayingNotification.destroySelfAndPlayer()
|
|
|
|
// called when the user pressed stop in the notification
|
|
// stop the service from being in the foreground and remove the notification
|
|
ServiceCompat.stopForeground(this, ServiceCompat.STOP_FOREGROUND_REMOVE)
|
|
// destroy the service
|
|
stopSelf()
|
|
|
|
super.onDestroy()
|
|
}
|
|
|
|
inner class LocalBinder : Binder() {
|
|
// Return this instance of [BackgroundMode] so clients can call public methods
|
|
fun getService(): BackgroundMode = this@BackgroundMode
|
|
}
|
|
|
|
override fun onBind(p0: Intent?): IBinder {
|
|
return binder
|
|
}
|
|
|
|
fun getCurrentPosition() = player?.currentPosition
|
|
|
|
fun getDuration() = player?.duration
|
|
|
|
fun seekToPosition(position: Long) = player?.seekTo(position)
|
|
|
|
fun pause() {
|
|
player?.pause()
|
|
}
|
|
|
|
fun play() {
|
|
player?.play()
|
|
}
|
|
}
|