LibreTube/app/src/main/java/com/github/libretube/helpers/PlayerHelper.kt

517 lines
16 KiB
Kotlin
Raw Normal View History

package com.github.libretube.helpers
2022-07-17 01:01:15 +05:30
2023-01-09 21:38:05 +05:30
import android.app.Activity
import android.app.PendingIntent
2022-07-17 01:01:15 +05:30
import android.content.Context
2023-01-09 21:38:05 +05:30
import android.content.Intent
import android.content.pm.ActivityInfo
2022-07-17 01:01:15 +05:30
import android.view.accessibility.CaptioningManager
import android.widget.Toast
2023-01-09 21:38:05 +05:30
import androidx.annotation.StringRes
import androidx.core.app.PendingIntentCompat
2023-02-03 17:09:08 +05:30
import androidx.core.app.RemoteActionCompat
2023-03-31 06:09:38 +05:30
import androidx.core.content.getSystemService
2023-02-03 17:09:08 +05:30
import androidx.core.graphics.drawable.IconCompat
2023-01-09 21:38:05 +05:30
import com.github.libretube.R
2022-11-16 15:30:39 +05:30
import com.github.libretube.api.obj.PipedStream
import com.github.libretube.api.obj.Segment
2022-09-20 23:30:51 +05:30
import com.github.libretube.constants.PreferenceKeys
2023-01-08 20:36:29 +05:30
import com.github.libretube.enums.AudioQuality
2023-01-09 21:38:05 +05:30
import com.github.libretube.enums.PlayerEvent
import com.google.android.exoplayer2.C
import com.google.android.exoplayer2.DefaultLoadControl
2023-01-21 16:37:28 +05:30
import com.google.android.exoplayer2.ExoPlayer
import com.google.android.exoplayer2.LoadControl
2023-01-21 16:37:28 +05:30
import com.google.android.exoplayer2.PlaybackParameters
import com.google.android.exoplayer2.audio.AudioAttributes
2022-07-17 01:01:15 +05:30
import com.google.android.exoplayer2.ui.CaptionStyleCompat
import kotlin.math.absoluteValue
import kotlin.math.roundToInt
2022-07-17 01:01:15 +05:30
object PlayerHelper {
2023-01-09 21:38:05 +05:30
private const val ACTION_MEDIA_CONTROL = "media_control"
const val CONTROL_TYPE = "control_type"
2023-01-08 20:36:29 +05:30
/**
* Get the audio source following the users preferences
*/
fun getAudioSource(context: Context, audios: List<PipedStream>): String {
2022-07-24 16:29:15 +05:30
val audioFormat = PreferenceHelper.getString(PreferenceKeys.PLAYER_AUDIO_FORMAT, "all")
val audioPrefKey = if (NetworkHelper.isNetworkMetered(context)) {
2023-01-08 20:36:29 +05:30
PreferenceKeys.PLAYER_AUDIO_QUALITY_MOBILE
2022-09-11 21:24:04 +05:30
} else {
2023-01-08 20:36:29 +05:30
PreferenceKeys.PLAYER_AUDIO_QUALITY
2022-09-11 21:24:04 +05:30
}
2022-07-24 16:29:15 +05:30
2023-01-08 20:36:29 +05:30
val audioQuality = PreferenceHelper.getString(audioPrefKey, "best")
2022-07-24 16:29:15 +05:30
2023-01-08 20:36:29 +05:30
val filteredAudios = audios.filter {
val audioMimeType = "audio/$audioFormat"
it.mimeType != audioMimeType || audioFormat == "all"
2022-07-24 16:29:15 +05:30
}
2023-01-08 20:36:29 +05:30
return getBitRate(
filteredAudios,
if (audioQuality == "best") AudioQuality.BEST else AudioQuality.WORST
)
2022-07-17 01:01:15 +05:30
}
2023-01-08 20:36:29 +05:30
/**
* Get the best or worst bitrate from a list of audio streams
* @param audios list of the audio streams
2023-01-09 21:38:05 +05:30
* @param quality Whether to use the best or worst quality available
2023-01-08 20:36:29 +05:30
* @return Url of the audio source
*/
private fun getBitRate(audios: List<PipedStream>, quality: AudioQuality): String {
val filteredAudios = audios.filter {
it.bitrate != null
}.sortedBy {
it.bitrate
2022-07-24 16:29:15 +05:30
}
2023-01-08 20:36:29 +05:30
return when (quality) {
AudioQuality.BEST -> filteredAudios.last()
AudioQuality.WORST -> filteredAudios.first()
}.url!!
2022-07-24 16:29:15 +05:30
}
2022-07-17 01:01:15 +05:30
// get the system default caption style
fun getCaptionStyle(context: Context): CaptionStyleCompat {
2023-03-31 06:09:38 +05:30
val captioningManager = context.getSystemService<CaptioningManager>()!!
2022-07-17 01:01:15 +05:30
return if (!captioningManager.isEnabled) {
// system captions are disabled, using android default captions style
CaptionStyleCompat.DEFAULT
} else {
// system captions are enabled
CaptionStyleCompat.createFromCaptionStyle(captioningManager.userStyle)
}
}
2022-08-02 14:47:15 +05:30
/**
* get the categories for sponsorBlock
*/
fun getSponsorBlockCategories(): ArrayList<String> {
val categories: ArrayList<String> = arrayListOf()
if (PreferenceHelper.getBoolean(
"intro_category_key",
false
)
) {
categories.add("intro")
}
if (PreferenceHelper.getBoolean(
"selfpromo_category_key",
false
)
) {
categories.add("selfpromo")
}
if (PreferenceHelper.getBoolean(
"interaction_category_key",
false
)
) {
categories.add("interaction")
}
if (PreferenceHelper.getBoolean(
"sponsors_category_key",
true
)
) {
categories.add("sponsor")
}
if (PreferenceHelper.getBoolean(
"outro_category_key",
false
)
) {
categories.add("outro")
}
if (PreferenceHelper.getBoolean(
"filler_category_key",
false
)
) {
categories.add("filler")
}
if (PreferenceHelper.getBoolean(
"music_offtopic_category_key",
false
)
) {
categories.add("music_offtopic")
}
if (PreferenceHelper.getBoolean(
"preview_category_key",
false
)
) {
categories.add("preview")
}
return categories
}
2023-03-24 20:32:56 +05:30
fun getOrientation(videoWidth: Int, videoHeight: Int): Int {
val fullscreenOrientationPref = PreferenceHelper.getString(
PreferenceKeys.FULLSCREEN_ORIENTATION,
"ratio"
)
return when (fullscreenOrientationPref) {
"ratio" -> {
// probably a youtube shorts video
2023-03-24 20:32:56 +05:30
if (videoHeight > videoWidth) {
ActivityInfo.SCREEN_ORIENTATION_USER_PORTRAIT
} // a video with normal aspect ratio
else {
ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE
}
}
"auto" -> ActivityInfo.SCREEN_ORIENTATION_SENSOR
"landscape" -> ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE
"portrait" -> ActivityInfo.SCREEN_ORIENTATION_USER_PORTRAIT
else -> ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE
}
}
2022-10-07 23:00:59 +05:30
val autoRotationEnabled: Boolean
get() = PreferenceHelper.getBoolean(
PreferenceKeys.AUTO_FULLSCREEN,
false
)
val relatedStreamsEnabled: Boolean
get() = PreferenceHelper.getBoolean(
PreferenceKeys.RELATED_STREAMS,
true
)
val pausePlayerOnScreenOffEnabled: Boolean
get() = PreferenceHelper.getBoolean(
PreferenceKeys.PAUSE_ON_SCREEN_OFF,
false
)
private val watchPositionsPref: String
get() = PreferenceHelper.getString(
PreferenceKeys.WATCH_POSITIONS,
"always"
2022-10-07 23:00:59 +05:30
)
val watchPositionsVideo: Boolean
get() = watchPositionsPref in listOf("always", "videos")
val watchPositionsAudio: Boolean
get() = watchPositionsPref == "always"
2022-10-07 23:00:59 +05:30
val watchHistoryEnabled: Boolean
get() = PreferenceHelper.getBoolean(
PreferenceKeys.WATCH_HISTORY_TOGGLE,
true
)
val useSystemCaptionStyle: Boolean
get() = PreferenceHelper.getBoolean(
PreferenceKeys.SYSTEM_CAPTION_STYLE,
true
)
private val bufferingGoal: Int
2022-10-07 23:00:59 +05:30
get() = PreferenceHelper.getString(
PreferenceKeys.BUFFERING_GOAL,
"50"
).toInt() * 1000
val sponsorBlockEnabled: Boolean
get() = PreferenceHelper.getBoolean(
"sb_enabled_key",
true
)
private val sponsorBlockNotifications: Boolean
2022-10-07 23:00:59 +05:30
get() = PreferenceHelper.getBoolean(
"sb_notifications_key",
true
)
2022-12-22 15:47:34 +05:30
val defaultSubtitleCode: String?
2022-10-07 23:00:59 +05:30
get() {
val code = PreferenceHelper.getString(
PreferenceKeys.DEFAULT_SUBTITLE,
""
)
2022-12-22 15:47:34 +05:30
if (code == "") return null
2022-10-07 23:00:59 +05:30
if (code.contains("-")) {
return code.split("-")[0]
}
return code
}
val skipButtonsEnabled: Boolean
get() = PreferenceHelper.getBoolean(
PreferenceKeys.SKIP_BUTTONS,
false
)
2022-10-19 23:23:18 +05:30
val pipEnabled: Boolean
get() = PreferenceHelper.getBoolean(
PreferenceKeys.PICTURE_IN_PICTURE,
true
)
2022-10-07 23:00:59 +05:30
val skipSegmentsManually: Boolean
get() = PreferenceHelper.getBoolean(
PreferenceKeys.SB_SKIP_MANUALLY,
false
)
val autoPlayEnabled: Boolean
get() = PreferenceHelper.getBoolean(
PreferenceKeys.AUTO_PLAY,
true
)
val autoPlayCountdown: Boolean
get() = PreferenceHelper.getBoolean(
PreferenceKeys.AUTOPLAY_COUNTDOWN,
false
)
val seekIncrement: Long
get() = PreferenceHelper.getString(
PreferenceKeys.SEEK_INCREMENT,
"10.0"
).toFloat()
.roundToInt()
.toLong() * 1000
private val playbackSpeed: Float
get() = PreferenceHelper.getString(
PreferenceKeys.PLAYBACK_SPEED,
"1"
).replace("F", "").toFloat()
private val backgroundSpeed: Float
get() = when (PreferenceHelper.getBoolean(PreferenceKeys.CUSTOM_PLAYBACK_SPEED, false)) {
true -> PreferenceHelper.getString(PreferenceKeys.BACKGROUND_PLAYBACK_SPEED, "1").toFloat()
else -> playbackSpeed
}
val resizeModePref: String
get() = PreferenceHelper.getString(
PreferenceKeys.PLAYER_RESIZE_MODE,
"fit"
)
2022-11-12 23:34:40 +05:30
val alternativeVideoLayout: Boolean
get() = PreferenceHelper.getBoolean(
PreferenceKeys.ALTERNATIVE_PLAYER_LAYOUT,
false
)
val autoInsertRelatedVideos: Boolean
get() = PreferenceHelper.getBoolean(
PreferenceKeys.QUEUE_AUTO_INSERT_RELATED,
true
)
val swipeGestureEnabled: Boolean
get() = PreferenceHelper.getBoolean(
PreferenceKeys.PLAYER_SWIPE_CONTROLS,
true
)
val pinchGestureEnabled: Boolean
get() = PreferenceHelper.getBoolean(
PreferenceKeys.PLAYER_PINCH_CONTROL,
true
)
val captionsTextSize: Float
get() = PreferenceHelper.getString(
PreferenceKeys.CAPTIONS_SIZE,
"18"
).toFloat()
2022-11-27 23:11:34 +05:30
val doubleTapToSeek: Boolean
get() = PreferenceHelper.getBoolean(
PreferenceKeys.DOUBLE_TAP_TO_SEEK,
true
)
2022-12-27 23:18:09 +05:30
val pauseOnQuit: Boolean
get() = PreferenceHelper.getBoolean(
PreferenceKeys.PAUSE_ON_QUIT,
false
)
private val alternativePiPControls: Boolean
get() = PreferenceHelper.getBoolean(
PreferenceKeys.ALTERNATIVE_PIP_CONTROLS,
false
)
2023-01-21 16:37:28 +05:30
private val skipSilence: Boolean
get() = PreferenceHelper.getBoolean(
PreferenceKeys.SKIP_SILENCE,
false
)
2023-02-08 14:11:59 +05:30
val enabledVideoCodecs: String
get() = PreferenceHelper.getString(
PreferenceKeys.ENABLED_VIDEO_CODECS,
"all"
)
2022-10-07 23:00:59 +05:30
fun getDefaultResolution(context: Context): String {
val prefKey = if (NetworkHelper.isNetworkMetered(context)) {
PreferenceKeys.DEFAULT_RESOLUTION_MOBILE
2022-10-07 23:00:59 +05:30
} else {
PreferenceKeys.DEFAULT_RESOLUTION
2022-10-07 23:00:59 +05:30
}
return PreferenceHelper.getString(prefKey, "")
2022-10-07 23:00:59 +05:30
}
2023-01-09 21:38:05 +05:30
fun getIntentActon(context: Context): String {
return context.packageName + "." + ACTION_MEDIA_CONTROL
}
private fun getPendingIntent(activity: Activity, code: Int): PendingIntent {
val intent = Intent(getIntentActon(activity)).putExtra(CONTROL_TYPE, code)
return PendingIntentCompat.getBroadcast(activity, code, intent, 0, false)
2023-01-09 21:38:05 +05:30
}
private fun getRemoteAction(
activity: Activity,
id: Int,
@StringRes title: Int,
event: PlayerEvent
2023-02-03 17:09:08 +05:30
): RemoteActionCompat {
2023-01-09 21:38:05 +05:30
val text = activity.getString(title)
2023-02-03 17:09:08 +05:30
return RemoteActionCompat(
IconCompat.createWithResource(activity, id),
2023-01-09 21:38:05 +05:30
text,
text,
getPendingIntent(activity, event.value)
)
}
/**
* Create controls to use in the PiP window
*/
2023-02-03 17:09:08 +05:30
fun getPiPModeActions(activity: Activity, isPlaying: Boolean): List<RemoteActionCompat> {
2023-01-15 17:56:16 +05:30
val audioModeAction = getRemoteAction(
activity,
R.drawable.ic_headphones,
R.string.background_mode,
PlayerEvent.Background
2023-01-09 21:38:05 +05:30
)
2023-01-15 17:56:16 +05:30
val rewindAction = getRemoteAction(
activity,
R.drawable.ic_rewind,
R.string.rewind,
PlayerEvent.Rewind
2023-01-09 21:38:05 +05:30
)
2023-01-15 17:56:16 +05:30
val playPauseAction = getRemoteAction(
activity,
if (isPlaying) R.drawable.ic_pause else R.drawable.ic_play,
R.string.pause,
if (isPlaying) PlayerEvent.Pause else PlayerEvent.Play
)
val skipNextAction = getRemoteAction(
activity,
R.drawable.ic_next,
R.string.play_next,
PlayerEvent.Next
2023-01-09 21:38:05 +05:30
)
2023-01-15 17:56:16 +05:30
val forwardAction = getRemoteAction(
activity,
R.drawable.ic_forward,
R.string.forward,
PlayerEvent.Forward
)
2023-02-03 17:09:08 +05:30
return if (alternativePiPControls) {
listOf(audioModeAction, playPauseAction, skipNextAction)
2023-01-15 17:56:16 +05:30
} else {
2023-02-03 17:09:08 +05:30
listOf(rewindAction, playPauseAction, forwardAction)
2023-01-15 17:56:16 +05:30
}
2023-01-09 21:38:05 +05:30
}
/**
* Get the audio attributes to use for the player
*/
fun getAudioAttributes(): AudioAttributes {
return AudioAttributes.Builder()
.setUsage(C.USAGE_MEDIA)
.setContentType(C.AUDIO_CONTENT_TYPE_MOVIE)
.build()
}
/**
* Get the load controls for the player (buffering, etc)
*/
fun getLoadControl(): LoadControl {
return DefaultLoadControl.Builder()
// cache the last three minutes
.setBackBuffer(1000 * 60 * 3, true)
.setBufferDurationsMs(
1000 * 10, // exo default is 50s
bufferingGoal,
DefaultLoadControl.DEFAULT_BUFFER_FOR_PLAYBACK_MS,
DefaultLoadControl.DEFAULT_BUFFER_FOR_PLAYBACK_AFTER_REBUFFER_MS
)
.build()
}
2023-01-21 16:37:28 +05:30
/**
* Load playback parameters such as speed and skip silence
*/
fun ExoPlayer.loadPlaybackParams(isBackgroundMode: Boolean = false): ExoPlayer {
2023-01-21 16:37:28 +05:30
skipSilenceEnabled = skipSilence
val speed = if (isBackgroundMode) backgroundSpeed else playbackSpeed
playbackParameters = PlaybackParameters(speed, 1.0f)
2023-01-21 16:37:28 +05:30
return this
}
/**
* Check for SponsorBlock segments matching the current player position
* @param context A main dispatcher context
* @param segments List of the SponsorBlock segments
* @param skipManually Whether the event gets handled by the function caller
* @return If segment found and [skipManually] is true, the end position of the segment in ms, otherwise null
*/
fun ExoPlayer.checkForSegments(
context: Context,
segments: List<Segment>,
skipManually: Boolean = false
): Long? {
for (segment in segments) {
val segmentStart = (segment.segment[0] * 1000f).toLong()
val segmentEnd = (segment.segment[1] * 1000f).toLong()
// avoid seeking to the same segment multiple times, e.g. when the SB segment is at the end of the video
if ((duration - currentPosition).absoluteValue < 500) continue
if (currentPosition in segmentStart until segmentEnd) {
if (!skipManually) {
if (sponsorBlockNotifications) {
runCatching {
Toast.makeText(context, R.string.segment_skipped, Toast.LENGTH_SHORT)
.show()
}
}
seekTo(segmentEnd)
} else {
return segmentEnd
}
}
}
return null
}
2022-07-17 02:19:32 +05:30
}