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

240 lines
7.9 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.Context
2022-07-21 16:40:27 +05:30
import android.content.Intent
2022-07-23 19:11:57 +05:30
import android.os.Build
2022-07-21 16:40:27 +05:30
import android.os.IBinder
import android.support.v4.media.session.MediaSessionCompat
2022-07-30 14:51:18 +05:30
import com.github.libretube.BACKGROUND_CHANNEL_ID
import com.github.libretube.PLAYER_NOTIFICATION_ID
2022-07-23 19:11:57 +05:30
import com.github.libretube.R
import com.github.libretube.obj.Streams
2022-07-02 21:53:24 +05:30
import com.github.libretube.preferences.PreferenceHelper
2022-07-17 21:48:39 +05:30
import com.github.libretube.preferences.PreferenceKeys
2022-07-21 16:40:27 +05:30
import com.github.libretube.util.DescriptionAdapter
import com.github.libretube.util.RetrofitInstance
2022-07-29 12:30:13 +05:30
import com.github.libretube.util.toID
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-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
import com.google.android.exoplayer2.ext.mediasession.MediaSessionConnector
import com.google.android.exoplayer2.ui.PlayerNotificationManager
import kotlinx.coroutines.launch
import kotlinx.coroutines.runBlocking
/**
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() {
/**
* The response that gets when called the Api.
*/
private var response: Streams? = null
/**
* The [ExoPlayer] player. Followed tutorial [here](https://developer.android.com/codelabs/exoplayer-intro)
*/
private var player: ExoPlayer? = null
private var playWhenReadyPlayer = true
/**
* The [MediaSessionCompat] for the [response].
*/
private lateinit var mediaSession: MediaSessionCompat
/**
* The [MediaSessionConnector] to connect with the [mediaSession] and implement it with the [player].
*/
private lateinit var mediaSessionConnector: MediaSessionConnector
/**
* The [PlayerNotificationManager] to load the [mediaSession] content on it.
*/
2022-06-30 19:32:55 +05:30
private var playerNotification: PlayerNotificationManager? = null
2022-06-14 22:38:02 +05:30
/**
* The [AudioAttributes] handle the audio focus of the [player]
*/
private lateinit var audioAttributes: AudioAttributes
2022-07-23 19:11:57 +05:30
override fun onCreate() {
super.onCreate()
if (Build.VERSION.SDK_INT >= 26) {
val channelId = "background service"
val channel = NotificationChannel(
channelId,
"BackgroundPlay Service",
NotificationManager.IMPORTANCE_DEFAULT
)
val notificationManager = getSystemService(NOTIFICATION_SERVICE) as NotificationManager
notificationManager.createNotificationChannel(channel)
val notification: Notification = Notification.Builder(this, channelId)
.setContentTitle(getString(R.string.app_name))
.setContentText(getString(R.string.playingOnBackground)).build()
startForeground(1, notification)
}
}
/**
* 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-07-23 19:11:57 +05:30
// destroy the old player
destroyPlayer()
// get the intent arguments
val videoId = intent?.getStringExtra("videoId")!!
val position = intent.getLongExtra("position", 0L)
// play the audio in the background
playAudio(videoId, position)
2022-07-21 16:40:27 +05:30
return super.onStartCommand(intent, flags, startId)
}
/**
* Gets the video data and prepares the [player].
*/
2022-07-23 19:11:57 +05:30
private fun playAudio(
2022-07-21 16:40:27 +05:30
videoId: String,
seekToPosition: Long = 0
) {
runBlocking {
val job = launch {
response = RetrofitInstance.api.getStreams(videoId)
}
// Wait until the job is done, to load correctly later in the player
job.join()
2022-07-23 19:11:57 +05:30
initializePlayer()
initializePlayerNotification()
2022-07-21 16:40:27 +05:30
player?.apply {
playWhenReady = playWhenReadyPlayer
prepare()
}
2022-07-23 19:11:57 +05:30
// seek to the previous position if available
2022-07-21 16:40:27 +05:30
if (seekToPosition != 0L) player?.seekTo(seekToPosition)
}
}
/**
* create the player
*/
2022-07-23 19:11:57 +05:30
private fun initializePlayer() {
2022-06-14 22:38:02 +05:30
audioAttributes = AudioAttributes.Builder()
2022-05-27 22:49:08 +05:30
.setUsage(C.USAGE_MEDIA)
.setContentType(C.CONTENT_TYPE_MUSIC)
.build()
if (player == null) {
2022-07-23 19:11:57 +05:30
player = ExoPlayer.Builder(this)
2022-05-27 22:49:08 +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
*/
player!!.addListener(object : Player.Listener {
override fun onPlaybackStateChanged(@Player.State state: Int) {
2022-07-27 14:59:16 +05:30
when (state) {
Player.STATE_ENDED -> {
val autoplay = PreferenceHelper.getBoolean(PreferenceKeys.AUTO_PLAY, true)
if (autoplay) playNextVideo()
}
Player.STATE_IDLE -> {
// called when the user pressed stop in the notification
// stop the service from being in the foreground and remove the notification
stopForeground(true)
// destroy the service
stopSelf()
}
2022-06-30 19:32:55 +05:30
}
}
})
2022-07-23 19:11:57 +05:30
setMediaItem()
}
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-07-23 19:11:57 +05:30
private fun playNextVideo() {
2022-06-30 19:32:55 +05:30
if (response!!.relatedStreams!!.isNotEmpty()) {
val videoId = response!!
2022-07-29 12:30:13 +05:30
.relatedStreams!![0].url.toID()
2022-06-30 19:32:55 +05:30
2022-07-23 19:11:57 +05:30
// destroy previous notification and player
destroyPlayer()
2022-06-30 19:32:55 +05:30
// play new video on background
2022-07-23 19:11:57 +05:30
playAudio(videoId)
2022-06-30 19:32:55 +05:30
}
}
/**
* Initializes the [playerNotification] attached to the [player] and shows it.
*/
2022-07-23 19:11:57 +05:30
private fun initializePlayerNotification() {
2022-06-01 15:33:00 +05:30
playerNotification = PlayerNotificationManager
2022-07-30 14:51:18 +05:30
.Builder(this, PLAYER_NOTIFICATION_ID, BACKGROUND_CHANNEL_ID)
// set the description of the notification
.setMediaDescriptionAdapter(
2022-06-14 22:38:02 +05:30
DescriptionAdapter(
response?.title!!,
response?.uploader!!,
2022-06-19 01:14:22 +05:30
response?.thumbnailUrl!!,
2022-07-23 19:11:57 +05:30
this
2022-06-14 22:38:02 +05:30
)
)
.build()
2022-06-30 19:32:55 +05:30
playerNotification?.apply {
setPlayer(player)
setUseNextAction(false)
2022-06-30 19:32:55 +05:30
setUsePreviousAction(false)
setUseStopAction(true)
setColorized(true)
setMediaSessionToken(mediaSession.sessionToken)
}
}
/**
* Sets the [MediaItem] with the [response] into the [player]. Also creates a [MediaSessionConnector]
* with the [mediaSession] and attach it to the [player].
*/
2022-07-23 19:11:57 +05:30
private fun setMediaItem() {
response?.let {
val mediaItem = MediaItem.Builder().setUri(it.hls!!).build()
player?.setMediaItem(mediaItem)
}
2022-07-23 19:11:57 +05:30
mediaSession = MediaSessionCompat(this, this.javaClass.name)
mediaSession.isActive = true
mediaSessionConnector = MediaSessionConnector(mediaSession)
mediaSessionConnector.setPlayer(player)
}
2022-07-23 19:11:57 +05:30
private fun destroyPlayer() {
// clear old player and its notification
playerNotification = null
player = null
// kill old notification
val notificationManager = getSystemService(Context.NOTIFICATION_SERVICE)
as NotificationManager
notificationManager.cancel(1)
}
2022-07-21 16:40:27 +05:30
override fun onBind(p0: Intent?): IBinder? {
TODO("Not yet implemented")
}
}