LibreTube/app/src/main/java/com/github/libretube/services/BackgroundMode.kt

394 lines
13 KiB
Kotlin
Raw Normal View History

2022-07-21 16:40:27 +05:30
package com.github.libretube.services
2022-07-23 19:11:57 +05:30
import android.app.Notification
import android.app.NotificationChannel
2022-06-30 19:32:55 +05:30
import android.app.NotificationManager
2022-07-21 16:40:27 +05:30
import android.app.Service
import android.content.Intent
2022-07-23 19:11:57 +05:30
import android.os.Build
2022-08-02 15:04:42 +05:30
import android.os.Handler
2022-07-21 16:40:27 +05:30
import android.os.IBinder
2022-08-02 15:04:42 +05:30
import android.os.Looper
2022-08-08 15:31:25 +05:30
import android.widget.Toast
2022-08-02 15:04:42 +05:30
import com.fasterxml.jackson.databind.ObjectMapper
2022-07-23 19:11:57 +05:30
import com.github.libretube.R
2022-08-14 13:25:28 +05:30
import com.github.libretube.api.RetrofitInstance
import com.github.libretube.api.obj.Segment
2022-10-29 03:09:25 +05:30
import com.github.libretube.api.obj.SegmentData
import com.github.libretube.api.obj.Streams
2022-09-08 22:12:52 +05:30
import com.github.libretube.constants.BACKGROUND_CHANNEL_ID
2022-09-08 23:49:44 +05:30
import com.github.libretube.constants.IntentData
2022-09-08 22:12:52 +05:30
import com.github.libretube.constants.PLAYER_NOTIFICATION_ID
2022-09-08 21:59:00 +05:30
import com.github.libretube.constants.PreferenceKeys
2022-11-18 23:12:59 +05:30
import com.github.libretube.db.DatabaseHolder.Companion.Database
import com.github.libretube.db.obj.WatchPosition
import com.github.libretube.extensions.awaitQuery
2022-11-18 23:12:59 +05:30
import com.github.libretube.extensions.query
2022-11-06 16:20:04 +05:30
import com.github.libretube.extensions.toID
2022-10-23 17:09:15 +05:30
import com.github.libretube.extensions.toStreamItem
2022-09-22 21:31:03 +05:30
import com.github.libretube.util.NowPlayingNotification
import com.github.libretube.util.PlayerHelper
import com.github.libretube.util.PlayingQueue
import com.github.libretube.util.PreferenceHelper
2022-05-27 22:49:08 +05:30
import com.google.android.exoplayer2.C
import com.google.android.exoplayer2.ExoPlayer
import com.google.android.exoplayer2.MediaItem
2022-09-26 22:46:13 +05:30
import com.google.android.exoplayer2.PlaybackException
2022-06-30 19:32:55 +05:30
import com.google.android.exoplayer2.Player
2022-05-27 22:49:08 +05:30
import com.google.android.exoplayer2.audio.AudioAttributes
2022-08-02 15:04:42 +05:30
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch
/**
2022-07-21 16:40:27 +05:30
* Loads the selected videos audio in background mode with a notification area.
*/
2022-07-21 16:40:27 +05:30
class BackgroundMode : Service() {
2022-08-02 15:04:42 +05:30
/**
* VideoId of the video
*/
private lateinit var videoId: String
2022-08-08 14:13:46 +05:30
/**
* PlaylistId/ChannelId for autoplay
2022-08-08 14:13:46 +05:30
*/
private var playlistId: String? = null
private var channelId: String? = null
2022-08-08 14:13:46 +05:30
/**
* 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)
*/
private var player: ExoPlayer? = null
private var playWhenReadyPlayer = true
2022-06-14 22:38:02 +05:30
/**
* The [AudioAttributes] handle the audio focus of the [player]
*/
private lateinit var audioAttributes: AudioAttributes
2022-08-02 15:04:42 +05:30
/**
* SponsorBlock Segment data
*/
2022-10-29 03:09:25 +05:30
private var segmentData: SegmentData? = null
2022-08-02 15:04:42 +05:30
2022-08-07 21:52:40 +05:30
/**
2022-08-08 14:13:46 +05:30
* [Notification] for the player
2022-08-07 21:52:40 +05:30
*/
private lateinit var nowPlayingNotification: NowPlayingNotification
2022-08-07 22:45:23 +05:30
/**
2022-08-10 19:53:57 +05:30
* Autoplay Preference
*/
private val handler = Handler(Looper.getMainLooper())
2022-08-10 19:53:57 +05:30
/**
* Setting the required [Notification] for running as a foreground service
2022-08-07 22:45:23 +05:30
*/
2022-07-23 19:11:57 +05:30
override fun onCreate() {
super.onCreate()
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
2022-07-23 19:11:57 +05:30
val channel = NotificationChannel(
BACKGROUND_CHANNEL_ID,
2022-08-01 12:25:38 +05:30
"Background Service",
2022-07-23 19:11:57 +05:30
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)
2022-07-23 19:11:57 +05:30
.setContentTitle(getString(R.string.app_name))
.setContentText(getString(R.string.playingOnBackground))
.build()
2022-08-01 12:25:38 +05:30
startForeground(PLAYER_NOTIFICATION_ID, notification)
2022-07-23 19:11:57 +05:30
}
}
/**
* Initializes the [player] with the [MediaItem].
*/
2022-07-21 16:40:27 +05:30
override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
2022-08-07 22:31:03 +05:30
try {
2022-08-10 19:23:34 +05:30
// clear the playing queue
2022-11-19 19:48:05 +05:30
PlayingQueue.resetToDefaults()
2022-08-10 19:23:34 +05:30
2022-08-07 22:31:03 +05:30
// get the intent arguments
2022-09-08 23:49:44 +05:30
videoId = intent?.getStringExtra(IntentData.videoId)!!
playlistId = intent.getStringExtra(IntentData.playlistId)
val position = intent.getLongExtra(IntentData.position, 0L)
2022-08-07 22:31:03 +05:30
// play the audio in the background
loadAudio(videoId, position)
2022-11-06 16:20:04 +05:30
PlayingQueue.setOnQueueTapListener { streamItem ->
streamItem.url?.toID()?.let { playNextVideo(it) }
}
2022-11-21 20:04:43 +05:30
if (PlayerHelper.watchPositionsEnabled) updateWatchPosition()
2022-08-07 22:31:03 +05:30
} catch (e: Exception) {
2022-08-27 18:43:24 +05:30
onDestroy()
2022-08-07 22:31:03 +05:30
}
2022-07-21 16:40:27 +05:30
return super.onStartCommand(intent, flags, startId)
}
private fun updateWatchPosition() {
2022-10-23 17:09:15 +05:30
player?.currentPosition?.let {
2022-11-18 23:12:59 +05:30
query {
Database.watchPositionDao().insertAll(WatchPosition(videoId, it))
}
2022-10-23 17:09:15 +05:30
}
handler.postDelayed(this::updateWatchPosition, 500)
}
2022-07-21 16:40:27 +05:30
/**
* Gets the video data and prepares the [player].
*/
private fun loadAudio(
2022-07-21 16:40:27 +05:30
videoId: String,
seekToPosition: Long = 0
) {
CoroutineScope(Dispatchers.IO).launch {
try {
2022-08-08 14:13:46 +05:30
streams = RetrofitInstance.api.getStreams(videoId)
} catch (e: Exception) {
return@launch
2022-07-21 16:40:27 +05:30
}
2022-08-07 21:52:40 +05:30
// add the playlist video to the queue
if (PlayingQueue.isEmpty() && playlistId != null) {
streams?.toStreamItem(videoId)?.let {
PlayingQueue.insertPlaylist(playlistId!!, it)
}
} else if (PlayingQueue.isEmpty() && channelId != null) {
streams?.toStreamItem(videoId)?.let {
PlayingQueue.insertChannel(channelId!!, it)
}
} else {
streams?.toStreamItem(videoId)?.let {
PlayingQueue.updateCurrent(it)
}
2022-10-23 19:34:15 +05:30
streams?.relatedStreams?.toTypedArray()?.let {
if (PlayerHelper.autoInsertRelatedVideos) PlayingQueue.add(*it)
2022-10-23 19:34:15 +05:30
}
}
2022-10-23 17:09:15 +05:30
handler.post {
playAudio(seekToPosition)
2022-08-07 22:31:03 +05:30
}
}
}
2022-07-21 16:40:27 +05:30
private fun playAudio(
seekToPosition: Long
) {
initializePlayer()
setMediaItem()
2022-07-21 16:40:27 +05:30
// create the notification
if (!this@BackgroundMode::nowPlayingNotification.isInitialized) {
nowPlayingNotification = NowPlayingNotification(this@BackgroundMode, player!!, true)
}
nowPlayingNotification.updatePlayerNotification(videoId, streams!!)
2022-08-02 15:04:42 +05:30
player?.apply {
playWhenReady = playWhenReadyPlayer
prepare()
}
2022-08-09 18:37:12 +05:30
// seek to the previous position if available
if (seekToPosition != 0L) {
player?.seekTo(seekToPosition)
} else if (PlayerHelper.watchPositionsEnabled) {
try {
val watchPosition = awaitQuery {
2022-11-19 19:48:05 +05:30
Database.watchPositionDao().findById(videoId)
}
streams?.duration?.let {
if (watchPosition != null && watchPosition.position < it * 1000 * 0.9) {
player?.seekTo(watchPosition.position)
}
}
} catch (e: Exception) {
e.printStackTrace()
}
}
2022-08-08 14:38:44 +05:30
// set the playback speed
val playbackSpeed = PreferenceHelper.getString(
PreferenceKeys.BACKGROUND_PLAYBACK_SPEED,
"1"
).toFloat()
player?.setPlaybackSpeed(playbackSpeed)
fetchSponsorBlockSegments()
2022-07-21 16:40:27 +05:30
}
/**
* create the player
*/
2022-07-23 19:11:57 +05:30
private fun initializePlayer() {
2022-08-08 14:13:46 +05:30
if (player != null) return
2022-06-14 22:38:02 +05:30
audioAttributes = AudioAttributes.Builder()
2022-05-27 22:49:08 +05:30
.setUsage(C.USAGE_MEDIA)
2022-09-09 21:44:23 +05:30
.setContentType(C.AUDIO_CONTENT_TYPE_MUSIC)
2022-05-27 22:49:08 +05:30
.build()
2022-08-08 14:13:46 +05:30
player = ExoPlayer.Builder(this)
2022-09-09 21:44:23 +05:30
.setHandleAudioBecomingNoisy(true)
2022-08-08 14:13:46 +05:30
.setAudioAttributes(audioAttributes, true)
.build()
2022-06-30 19:32:55 +05:30
/**
* Listens for changed playbackStates (e.g. pause, end)
* Plays the next video when the current one ended
*/
2022-09-15 19:11:01 +05:30
player?.addListener(object : Player.Listener {
2022-09-26 22:46:13 +05:30
override fun onPlaybackStateChanged(state: Int) {
2022-07-27 14:59:16 +05:30
when (state) {
Player.STATE_ENDED -> {
if (PlayerHelper.autoPlayEnabled) playNextVideo()
2022-07-27 14:59:16 +05:30
}
Player.STATE_IDLE -> {
2022-08-07 22:45:23 +05:30
onDestroy()
2022-07-27 14:59:16 +05:30
}
2022-09-26 22:46:13 +05:30
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()
2022-06-30 19:32:55 +05:30
}
}
})
}
2022-06-30 19:32:55 +05:30
/**
* Plays the first related video to the current (used when the playback of the current video ended)
*/
2022-11-06 16:20:04 +05:30
private fun playNextVideo(nextId: String? = null) {
val nextVideo = nextId ?: PlayingQueue.getNext()
2022-08-08 14:13:46 +05:30
// play new video on background
if (nextVideo != null) {
this.videoId = nextVideo
}
2022-08-08 14:13:46 +05:30
this.segmentData = null
loadAudio(videoId)
2022-06-30 19:32:55 +05:30
}
/**
2022-08-10 19:53:57 +05:30
* Sets the [MediaItem] with the [streams] into the [player]
*/
2022-07-23 19:11:57 +05:30
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)
}
2022-08-02 15:04:42 +05:30
/**
* fetch the segments for SponsorBlock
*/
private fun fetchSponsorBlockSegments() {
CoroutineScope(Dispatchers.IO).launch {
2022-11-12 23:34:40 +05:30
runCatching {
2022-08-02 15:04:42 +05:30
val categories = PlayerHelper.getSponsorBlockCategories()
2022-11-12 23:34:40 +05:30
if (categories.isEmpty()) return@runCatching
segmentData =
RetrofitInstance.api.getSegments(
videoId,
ObjectMapper().writeValueAsString(categories)
)
checkForSegments()
2022-08-02 15:04:42 +05:30
}
}
}
/**
* 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 ->
2022-10-29 03:09:25 +05:30
val segmentStart = (segment.segment[0] * 1000f).toLong()
2022-08-02 15:04:42 +05:30
val segmentEnd = (segment.segment[1] * 1000f).toLong()
val currentPosition = player?.currentPosition
if (currentPosition in segmentStart until segmentEnd) {
if (PlayerHelper.sponsorBlockNotifications) {
2022-08-08 15:31:25 +05:30
try {
Toast.makeText(this, R.string.segment_skipped, Toast.LENGTH_SHORT)
.show()
} catch (e: Exception) {
// Do nothing.
}
}
2022-08-02 15:04:42 +05:30
player?.seekTo(segmentEnd)
}
}
}
/**
* Stop the service when app is removed from the task manager.
*/
override fun onTaskRemoved(rootIntent: Intent?) {
super.onTaskRemoved(rootIntent)
onDestroy()
}
2022-08-07 22:45:23 +05:30
/**
* destroy the [BackgroundMode] foreground service
*/
override fun onDestroy() {
2022-09-20 01:13:13 +05:30
// clear the playing queue
2022-11-19 19:48:05 +05:30
PlayingQueue.resetToDefaults()
2022-09-20 01:13:13 +05:30
if (this::nowPlayingNotification.isInitialized) nowPlayingNotification.destroySelfAndPlayer()
2022-08-07 22:45:23 +05:30
// called when the user pressed stop in the notification
// stop the service from being in the foreground and remove the notification
2022-08-27 18:43:24 +05:30
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
stopForeground(STOP_FOREGROUND_REMOVE)
} else {
@Suppress("DEPRECATION")
stopForeground(true)
}
2022-08-07 22:45:23 +05:30
// destroy the service
stopSelf()
2022-08-07 22:45:23 +05:30
super.onDestroy()
}
2022-07-21 16:40:27 +05:30
override fun onBind(p0: Intent?): IBinder? {
2022-08-09 18:37:12 +05:30
return null
}
}