LibreTube/app/src/main/java/com/github/libretube/fragments/PlayerFragment.kt

1755 lines
68 KiB
Kotlin
Raw Normal View History

2022-06-03 01:33:36 +05:30
package com.github.libretube.fragments
2022-07-26 11:25:07 +05:30
import android.app.ActivityManager
2022-06-01 12:20:02 +05:30
import android.app.NotificationManager
2022-06-26 21:19:42 +05:30
import android.app.PictureInPictureParams
2022-02-13 22:43:26 +05:30
import android.content.Context
2022-03-05 11:56:54 +05:30
import android.content.Intent
2021-12-14 21:45:53 +05:30
import android.content.pm.ActivityInfo
2022-07-14 15:45:58 +05:30
import android.content.res.Configuration
2022-07-10 17:26:17 +05:30
import android.graphics.Color
import android.graphics.Rect
2022-03-15 21:36:42 +05:30
import android.net.Uri
import android.os.Build
2022-02-27 00:27:05 +05:30
import android.os.Build.VERSION.SDK_INT
2022-02-26 22:49:42 +05:30
import android.os.Bundle
2022-07-08 21:19:32 +05:30
import android.os.Handler
import android.os.Looper
2022-06-20 17:52:28 +05:30
import android.os.PowerManager
2022-06-01 11:32:16 +05:30
import android.support.v4.media.session.MediaSessionCompat
import android.text.Html
2022-05-16 15:41:22 +05:30
import android.text.TextUtils
2021-12-18 16:34:14 +05:30
import android.util.Log
2022-02-26 22:49:42 +05:30
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
2022-05-21 13:32:04 +05:30
import android.widget.Toast
2022-02-26 22:49:42 +05:30
import androidx.constraintlayout.motion.widget.MotionLayout
2022-07-08 21:48:31 +05:30
import androidx.constraintlayout.widget.ConstraintLayout
2022-02-26 22:49:42 +05:30
import androidx.core.net.toUri
2022-02-05 00:25:05 +05:30
import androidx.core.os.bundleOf
2022-03-28 04:08:00 +05:30
import androidx.core.view.isVisible
2022-02-26 22:49:42 +05:30
import androidx.fragment.app.Fragment
2021-12-18 16:34:14 +05:30
import androidx.lifecycle.lifecycleScope
import androidx.recyclerview.widget.GridLayoutManager
2022-05-08 16:03:01 +05:30
import androidx.recyclerview.widget.LinearLayoutManager
2022-07-12 20:57:56 +05:30
import com.github.libretube.Globals
2022-06-03 01:33:36 +05:30
import com.github.libretube.R
2022-07-01 20:25:21 +05:30
import com.github.libretube.activities.MainActivity
2022-06-13 19:45:02 +05:30
import com.github.libretube.adapters.ChaptersAdapter
2022-05-08 16:03:01 +05:30
import com.github.libretube.adapters.CommentsAdapter
2022-02-01 21:22:06 +05:30
import com.github.libretube.adapters.TrendingAdapter
2022-07-19 17:38:12 +05:30
import com.github.libretube.databinding.DoubleTapOverlayBinding
2022-07-02 22:01:56 +05:30
import com.github.libretube.databinding.ExoStyledPlayerControlViewBinding
2022-07-01 00:35:31 +05:30
import com.github.libretube.databinding.FragmentPlayerBinding
2022-06-03 00:40:16 +05:30
import com.github.libretube.dialogs.AddtoPlaylistDialog
import com.github.libretube.dialogs.DownloadDialog
2022-06-05 14:22:35 +05:30
import com.github.libretube.dialogs.ShareDialog
2022-06-12 22:56:38 +05:30
import com.github.libretube.obj.ChapterSegment
2022-06-29 12:34:11 +05:30
import com.github.libretube.obj.Playlist
2022-05-16 15:41:22 +05:30
import com.github.libretube.obj.Segment
import com.github.libretube.obj.Segments
2022-06-26 14:06:34 +05:30
import com.github.libretube.obj.SponsorBlockPrefs
2022-06-18 14:02:05 +05:30
import com.github.libretube.obj.StreamItem
2022-06-01 11:55:12 +05:30
import com.github.libretube.obj.Streams
2022-02-13 22:43:26 +05:30
import com.github.libretube.obj.Subscribe
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-26 11:25:07 +05:30
import com.github.libretube.services.BackgroundMode
2022-07-23 19:11:57 +05:30
import com.github.libretube.util.BackgroundHelper
2022-07-16 01:07:44 +05:30
import com.github.libretube.util.ConnectionHelper
import com.github.libretube.util.CronetHelper
2022-06-14 15:30:58 +05:30
import com.github.libretube.util.DescriptionAdapter
2022-07-27 14:47:05 +05:30
import com.github.libretube.util.OnDoubleTapEventListener
2022-07-17 01:01:15 +05:30
import com.github.libretube.util.PlayerHelper
2022-06-03 00:40:16 +05:30
import com.github.libretube.util.RetrofitInstance
2022-06-10 18:33:48 +05:30
import com.github.libretube.util.formatShort
2022-07-24 01:40:03 +05:30
import com.github.libretube.util.hideKeyboard
2022-05-13 19:25:31 +05:30
import com.google.android.exoplayer2.C
2022-06-03 22:13:15 +05:30
import com.google.android.exoplayer2.DefaultLoadControl
2022-02-26 22:49:42 +05:30
import com.google.android.exoplayer2.ExoPlayer
import com.google.android.exoplayer2.MediaItem
import com.google.android.exoplayer2.MediaItem.SubtitleConfiguration
import com.google.android.exoplayer2.MediaItem.fromUri
import com.google.android.exoplayer2.Player
2022-05-13 19:25:31 +05:30
import com.google.android.exoplayer2.audio.AudioAttributes
2022-04-15 12:08:53 +05:30
import com.google.android.exoplayer2.ext.cronet.CronetDataSource
2022-06-01 11:32:16 +05:30
import com.google.android.exoplayer2.ext.mediasession.MediaSessionConnector
2022-02-26 22:49:42 +05:30
import com.google.android.exoplayer2.source.DefaultMediaSourceFactory
import com.google.android.exoplayer2.source.MediaSource
import com.google.android.exoplayer2.source.MergingMediaSource
import com.google.android.exoplayer2.source.ProgressiveMediaSource
2022-07-17 02:19:32 +05:30
import com.google.android.exoplayer2.trackselection.DefaultTrackSelector
import com.google.android.exoplayer2.ui.AspectRatioFrameLayout
import com.google.android.exoplayer2.ui.CaptionStyleCompat
2022-06-01 11:32:16 +05:30
import com.google.android.exoplayer2.ui.PlayerNotificationManager
2022-02-26 22:49:42 +05:30
import com.google.android.exoplayer2.ui.StyledPlayerView
2022-07-08 22:14:38 +05:30
import com.google.android.exoplayer2.ui.TimeBar
2022-02-26 22:49:42 +05:30
import com.google.android.exoplayer2.upstream.DataSource
2022-04-15 12:08:53 +05:30
import com.google.android.exoplayer2.upstream.DefaultDataSource
2022-02-26 22:49:42 +05:30
import com.google.android.exoplayer2.upstream.DefaultHttpDataSource
2022-05-13 10:02:16 +05:30
import com.google.android.exoplayer2.util.RepeatModeUtil
2022-07-08 21:36:48 +05:30
import com.google.android.exoplayer2.video.VideoSize
2022-05-20 20:01:14 +05:30
import com.google.android.material.dialog.MaterialAlertDialogBuilder
2022-06-29 12:34:11 +05:30
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch
2022-06-24 20:56:36 +05:30
import org.chromium.net.CronetEngine
import retrofit2.HttpException
2022-02-26 22:49:42 +05:30
import java.io.IOException
2022-04-15 12:08:53 +05:30
import java.util.concurrent.Executors
2022-02-26 22:49:42 +05:30
import kotlin.math.abs
2022-04-15 12:08:53 +05:30
class PlayerFragment : Fragment() {
2022-02-05 21:20:16 +05:30
2022-02-05 00:25:05 +05:30
private val TAG = "PlayerFragment"
2022-07-01 00:35:31 +05:30
private lateinit var binding: FragmentPlayerBinding
2022-07-02 22:01:56 +05:30
private lateinit var playerBinding: ExoStyledPlayerControlViewBinding
2022-07-19 17:38:12 +05:30
private lateinit var doubleTapOverlayBinding: DoubleTapOverlayBinding
2022-07-01 00:35:31 +05:30
2022-07-17 16:27:01 +05:30
/**
* video information
*/
private var videoId: String? = null
2022-06-29 12:34:11 +05:30
private var playlistId: String? = null
2022-07-27 14:47:05 +05:30
private var channelId: String? = null
2022-07-17 16:27:01 +05:30
private var isSubscribed: Boolean = false
/**
* for the transition
*/
private var sId: Int = 0
private var eId: Int = 0
2022-06-17 16:51:55 +05:30
private var transitioning = false
2022-02-13 22:43:26 +05:30
2022-07-17 16:27:01 +05:30
/**
* for the comments
*/
private var commentsAdapter: CommentsAdapter? = null
2022-05-20 21:15:16 +05:30
private var commentsLoaded: Boolean? = false
private var nextPage: String? = null
private var isLoading = true
2022-07-17 16:27:01 +05:30
/**
* for the player
*/
2021-12-14 21:45:53 +05:30
private lateinit var exoPlayer: ExoPlayer
2022-07-17 02:19:32 +05:30
private lateinit var trackSelector: DefaultTrackSelector
2022-05-16 15:41:22 +05:30
private lateinit var segmentData: Segments
2022-07-17 16:27:01 +05:30
private lateinit var chapters: List<ChapterSegment>
/**
* for the player view
*/
private lateinit var exoPlayerView: StyledPlayerView
private var isPlayerLocked: Boolean = false
private var subtitle = mutableListOf<SubtitleConfiguration>()
2022-06-29 12:52:22 +05:30
2022-07-17 16:27:01 +05:30
/**
* user preferences
*/
private var token = ""
private var relatedStreamsEnabled = true
private var autoplayEnabled = false
private val sponsorBlockPrefs = SponsorBlockPrefs()
private var autoRotationEnabled = true
private var playbackSpeed = "1F"
private var pausePlayerOnScreenOffEnabled = false
private var fullscreenOrientationPref = "ratio"
private var watchHistoryEnabled = true
private var watchPositionsEnabled = true
private var useSystemCaptionStyle = true
private var seekIncrement = 5L
2022-07-24 16:29:15 +05:30
private var videoFormatPreference = "webm"
2022-07-17 16:27:01 +05:30
private var defRes = ""
private var bufferingGoal = 50000
2022-07-20 17:35:17 +05:30
private var seekBarPreview = false
private var defaultSubtitle = ""
2022-07-17 16:27:01 +05:30
/**
* for autoplay
*/
2022-06-29 12:34:11 +05:30
private var relatedStreams: List<StreamItem>? = arrayListOf()
private var nextStreamId: String? = null
private var playlistStreamIds: MutableList<String> = arrayListOf()
2022-06-29 12:52:22 +05:30
private var playlistNextPage: String? = null
2022-07-17 16:27:01 +05:30
/**
* for the player notification
*/
2022-06-01 11:32:16 +05:30
private lateinit var mediaSession: MediaSessionCompat
private lateinit var mediaSessionConnector: MediaSessionConnector
private lateinit var playerNotification: PlayerNotificationManager
2022-07-17 16:27:01 +05:30
/**
* for the media description of the notification
*/
2022-06-14 15:30:58 +05:30
private lateinit var title: String
private lateinit var uploader: String
private lateinit var thumbnailUrl: String
2022-07-14 19:27:20 +05:30
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
arguments?.let {
videoId = it.getString("videoId")
2022-06-29 12:34:11 +05:30
playlistId = it.getString("playlistId")
}
}
override fun onCreateView(
inflater: LayoutInflater,
container: ViewGroup?,
savedInstanceState: Bundle?
2022-07-01 00:55:40 +05:30
): View {
2022-07-01 00:35:31 +05:30
binding = FragmentPlayerBinding.inflate(layoutInflater, container, false)
2022-07-27 15:27:04 +05:30
exoPlayerView = binding.player
2022-07-02 22:01:56 +05:30
playerBinding = binding.player.binding
2022-07-19 17:38:12 +05:30
doubleTapOverlayBinding = binding.doubleTapOverlay.binding
// Inflate the layout for this fragment
2022-07-01 00:35:31 +05:30
return binding.root
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
2022-07-24 15:26:53 +05:30
context?.hideKeyboard(view)
2022-03-28 04:08:00 +05:30
2022-07-17 16:27:01 +05:30
setUserPrefs()
2022-07-27 15:27:04 +05:30
if (autoplayEnabled == true) playerBinding.autoplayIV.setImageResource(R.drawable.ic_toggle_on)
2022-07-14 15:45:58 +05:30
val mainActivity = activity as MainActivity
2022-07-14 19:27:20 +05:30
if (autoRotationEnabled) {
// enable auto rotation
2022-07-17 00:28:28 +05:30
mainActivity.requestedOrientation = ActivityInfo.SCREEN_ORIENTATION_SENSOR
2022-07-14 19:27:20 +05:30
onConfigurationChanged(resources.configuration)
} else {
// go to portrait mode
mainActivity.requestedOrientation = ActivityInfo.SCREEN_ORIENTATION_USER_PORTRAIT
}
2022-07-17 16:27:01 +05:30
setSponsorBlockPrefs()
createExoPlayer()
initializeTransitionLayout()
initializeOnClickActions()
playVideo()
}
private fun setUserPrefs() {
token = PreferenceHelper.getToken()
2022-07-17 16:27:01 +05:30
// save whether auto rotation is enabled
autoRotationEnabled = PreferenceHelper.getBoolean(
2022-07-17 21:48:39 +05:30
PreferenceKeys.AUTO_FULLSCREEN,
2022-07-17 16:27:01 +05:30
false
)
2022-07-14 19:27:20 +05:30
// save whether related streams and autoplay are enabled
2022-07-17 16:27:01 +05:30
autoplayEnabled = PreferenceHelper.getBoolean(
2022-07-17 21:48:39 +05:30
PreferenceKeys.AUTO_PLAY,
2022-07-14 19:27:20 +05:30
false
)
relatedStreamsEnabled = PreferenceHelper.getBoolean(
2022-07-17 21:48:39 +05:30
PreferenceKeys.RELATED_STREAMS,
2022-07-14 19:27:20 +05:30
true
)
2022-07-17 16:27:01 +05:30
playbackSpeed = PreferenceHelper.getString(
2022-07-17 21:48:39 +05:30
PreferenceKeys.PLAYBACK_SPEED,
2022-07-18 17:54:08 +05:30
"1"
).replace("F", "") // due to old way to handle it (with float)
2022-07-17 16:27:01 +05:30
fullscreenOrientationPref = PreferenceHelper.getString(
2022-07-17 21:48:39 +05:30
PreferenceKeys.FULLSCREEN_ORIENTATION,
2022-07-17 16:27:01 +05:30
"ratio"
)
2022-07-17 16:27:01 +05:30
pausePlayerOnScreenOffEnabled = PreferenceHelper.getBoolean(
2022-07-17 21:48:39 +05:30
PreferenceKeys.PAUSE_ON_SCREEN_OFF,
2022-07-17 16:27:01 +05:30
false
)
watchPositionsEnabled = PreferenceHelper.getBoolean(
2022-07-17 21:48:39 +05:30
PreferenceKeys.WATCH_POSITION_TOGGLE,
2022-07-17 16:27:01 +05:30
true
)
watchHistoryEnabled = PreferenceHelper.getBoolean(
2022-07-17 21:48:39 +05:30
PreferenceKeys.WATCH_HISTORY_TOGGLE,
2022-07-17 16:27:01 +05:30
true
)
useSystemCaptionStyle = PreferenceHelper.getBoolean(
2022-07-17 21:48:39 +05:30
PreferenceKeys.SYSTEM_CAPTION_STYLE,
2022-07-17 16:27:01 +05:30
true
)
seekIncrement = PreferenceHelper.getString(
2022-07-17 21:48:39 +05:30
PreferenceKeys.SEEK_INCREMENT,
2022-07-17 16:27:01 +05:30
"5"
).toLong() * 1000
2022-07-17 16:27:01 +05:30
videoFormatPreference = PreferenceHelper.getString(
2022-07-17 21:48:39 +05:30
PreferenceKeys.PLAYER_VIDEO_FORMAT,
2022-07-24 16:29:15 +05:30
"webm"
)
2022-07-17 16:27:01 +05:30
defRes = PreferenceHelper.getString(
2022-07-17 21:48:39 +05:30
PreferenceKeys.DEFAULT_RESOLUTION,
2022-07-17 16:27:01 +05:30
""
)
2022-07-17 16:27:01 +05:30
bufferingGoal = PreferenceHelper.getString(
2022-07-17 21:48:39 +05:30
PreferenceKeys.BUFFERING_GOAL,
2022-07-17 16:27:01 +05:30
"50"
).toInt() * 1000
2022-07-20 17:35:17 +05:30
seekBarPreview = PreferenceHelper.getBoolean(
PreferenceKeys.SEEKBAR_PREVIEW,
false
)
defaultSubtitle = PreferenceHelper.getString(
PreferenceKeys.DEFAULT_SUBTITLE,
""
)
if (defaultSubtitle.contains("-")) {
defaultSubtitle = defaultSubtitle.split("-")[0]
}
}
2022-07-17 16:27:01 +05:30
private fun setSponsorBlockPrefs() {
sponsorBlockPrefs.sponsorBlockEnabled =
PreferenceHelper.getBoolean("sb_enabled_key", true)
2022-07-17 16:27:01 +05:30
sponsorBlockPrefs.sponsorNotificationsEnabled =
PreferenceHelper.getBoolean("sb_notifications_key", true)
2022-07-17 16:27:01 +05:30
sponsorBlockPrefs.introEnabled =
PreferenceHelper.getBoolean("intro_category_key", false)
2022-07-17 16:27:01 +05:30
sponsorBlockPrefs.selfPromoEnabled =
PreferenceHelper.getBoolean("selfpromo_category_key", false)
2022-07-17 16:27:01 +05:30
sponsorBlockPrefs.interactionEnabled =
PreferenceHelper.getBoolean("interaction_category_key", false)
2022-07-17 16:27:01 +05:30
sponsorBlockPrefs.sponsorsEnabled =
PreferenceHelper.getBoolean("sponsors_category_key", true)
2022-07-17 16:27:01 +05:30
sponsorBlockPrefs.outroEnabled =
PreferenceHelper.getBoolean("outro_category_key", false)
2022-07-17 16:27:01 +05:30
sponsorBlockPrefs.fillerEnabled =
PreferenceHelper.getBoolean("filler_category_key", false)
2022-07-17 16:27:01 +05:30
sponsorBlockPrefs.musicOffTopicEnabled =
PreferenceHelper.getBoolean("music_offtopic_category_key", false)
2022-07-17 16:27:01 +05:30
sponsorBlockPrefs.previewEnabled =
PreferenceHelper.getBoolean("preview_category_key", false)
2022-07-17 16:27:01 +05:30
}
private fun initializeTransitionLayout() {
videoId = videoId!!.replace("/watch?v=", "")
2022-07-01 00:35:31 +05:30
val mainActivity = activity as MainActivity
2022-07-01 00:35:31 +05:30
mainActivity.binding.container.visibility = View.VISIBLE
2022-07-01 00:55:40 +05:30
binding.playerMotionLayout.addTransitionListener(object : MotionLayout.TransitionListener {
override fun onTransitionStarted(
motionLayout: MotionLayout?,
startId: Int,
endId: Int
) {
}
2022-04-15 12:08:53 +05:30
override fun onTransitionChange(
motionLayout: MotionLayout?,
startId: Int,
endId: Int,
progress: Float
) {
val mainActivity = activity as MainActivity
2022-04-15 12:08:53 +05:30
val mainMotionLayout =
2022-07-01 00:35:31 +05:30
mainActivity.binding.mainMotionLayout
mainMotionLayout.progress = abs(progress)
2022-06-24 18:46:14 +05:30
exoPlayerView.hideController()
eId = endId
sId = startId
}
override fun onTransitionCompleted(motionLayout: MotionLayout?, currentId: Int) {
println(currentId)
val mainActivity = activity as MainActivity
2022-04-15 12:08:53 +05:30
val mainMotionLayout =
2022-07-01 00:35:31 +05:30
mainActivity.binding.mainMotionLayout
if (currentId == eId) {
2022-07-18 22:59:56 +05:30
Globals.MINI_PLAYER_VISIBLE = true
2022-06-19 17:09:41 +05:30
exoPlayerView.useController = false
2022-06-24 18:46:14 +05:30
mainMotionLayout.progress = 1F
} else if (currentId == sId) {
2022-07-18 22:59:56 +05:30
Globals.MINI_PLAYER_VISIBLE = false
2022-06-19 17:09:41 +05:30
exoPlayerView.useController = true
2022-06-24 18:46:14 +05:30
mainMotionLayout.progress = 0F
}
}
override fun onTransitionTrigger(
2022-07-01 00:55:40 +05:30
MotionLayout: MotionLayout?,
triggerId: Int,
positive: Boolean,
progress: Float
) {
}
})
2022-06-03 22:13:15 +05:30
2022-07-01 00:55:40 +05:30
binding.playerMotionLayout.progress = 1.toFloat()
binding.playerMotionLayout.transitionToStart()
2022-07-17 16:27:01 +05:30
}
2022-07-17 16:27:01 +05:30
// actions that don't depend on video information
private fun initializeOnClickActions() {
2022-07-01 00:35:31 +05:30
binding.closeImageView.setOnClickListener {
2022-07-18 22:59:56 +05:30
Globals.MINI_PLAYER_VISIBLE = false
2022-07-01 00:55:40 +05:30
binding.playerMotionLayout.transitionToEnd()
val mainActivity = activity as MainActivity
mainActivity.supportFragmentManager.beginTransaction()
.remove(this)
.commit()
}
2022-07-02 22:01:56 +05:30
playerBinding.closeImageButton.setOnClickListener {
2022-07-18 22:59:56 +05:30
Globals.MINI_PLAYER_VISIBLE = false
2022-07-01 00:55:40 +05:30
binding.playerMotionLayout.transitionToEnd()
2021-12-14 02:58:17 +05:30
val mainActivity = activity as MainActivity
mainActivity.supportFragmentManager.beginTransaction()
.remove(this)
.commit()
}
2022-07-15 14:57:04 +05:30
// show the advanced player options
playerBinding.toggleOptions.setOnClickListener {
if (playerBinding.advancedOptions.isVisible) {
2022-07-20 17:19:56 +05:30
playerBinding.toggleOptions.animate().rotation(0F).setDuration(250).start()
2022-07-15 14:57:04 +05:30
playerBinding.advancedOptions.visibility = View.GONE
} else {
2022-07-20 17:19:56 +05:30
playerBinding.toggleOptions.animate().rotation(180F).setDuration(250).start()
2022-07-15 14:57:04 +05:30
playerBinding.advancedOptions.visibility = View.VISIBLE
}
}
2022-07-27 15:27:04 +05:30
// autoplay toggle button
playerBinding.autoplayLL.setOnClickListener {
autoplayEnabled = if (autoplayEnabled) {
playerBinding.autoplayIV.setImageResource(R.drawable.ic_toggle_off)
false
} else {
playerBinding.autoplayIV.setImageResource(R.drawable.ic_toggle_on)
true
}
}
2022-07-01 00:35:31 +05:30
binding.playImageView.setOnClickListener {
2022-07-17 16:27:01 +05:30
if (!exoPlayer.isPlaying) {
// start or go on playing
2022-07-01 00:35:31 +05:30
binding.playImageView.setImageResource(R.drawable.ic_pause)
2021-12-14 02:58:17 +05:30
exoPlayer.play()
} else {
2022-07-17 16:27:01 +05:30
// pause the video
2022-07-01 00:35:31 +05:30
binding.playImageView.setImageResource(R.drawable.ic_play)
2021-12-14 02:58:17 +05:30
exoPlayer.pause()
}
}
2022-03-28 04:08:00 +05:30
2022-06-28 20:23:18 +05:30
// video description and chapters toggle
2022-07-01 00:35:31 +05:30
binding.playerTitleLayout.setOnClickListener {
2022-07-10 21:44:15 +05:30
toggleDescription()
2022-03-28 04:08:00 +05:30
}
2022-05-08 16:29:44 +05:30
2022-07-01 18:42:00 +05:30
binding.commentsToggle.setOnClickListener {
2022-07-01 20:25:21 +05:30
toggleComments()
}
2022-05-08 16:29:44 +05:30
2022-06-27 22:32:10 +05:30
// FullScreen button trigger
2022-07-14 19:34:03 +05:30
// hide fullscreen button if auto rotation enabled
playerBinding.fullscreen.visibility = if (autoRotationEnabled) View.GONE else View.VISIBLE
2022-07-02 22:01:56 +05:30
playerBinding.fullscreen.setOnClickListener {
2022-07-08 23:08:10 +05:30
// hide player controller
2022-06-24 18:33:29 +05:30
exoPlayerView.hideController()
2022-07-18 22:59:56 +05:30
if (!Globals.IS_FULL_SCREEN) {
2022-07-03 21:43:52 +05:30
// go to fullscreen mode
2022-07-08 23:08:10 +05:30
setFullscreen()
2022-04-15 12:08:53 +05:30
} else {
2022-07-08 23:08:10 +05:30
// exit fullscreen mode
unsetFullscreen()
2021-12-15 15:54:12 +05:30
}
2021-12-14 21:45:53 +05:30
}
// switching between original aspect ratio (black bars) and zoomed to fill device screen
2022-07-17 21:05:36 +05:30
val aspectRatioModes = arrayOf(
AspectRatioFrameLayout.RESIZE_MODE_FIT,
AspectRatioFrameLayout.RESIZE_MODE_ZOOM,
AspectRatioFrameLayout.RESIZE_MODE_FILL
)
2022-07-02 22:01:56 +05:30
playerBinding.aspectRatioButton.setOnClickListener {
2022-07-17 21:05:36 +05:30
val index = aspectRatioModes.indexOf(exoPlayerView.resizeMode)
val newAspectRatioMode =
if (index + 1 < aspectRatioModes.size) aspectRatioModes[index + 1]
else aspectRatioModes[0]
exoPlayerView.resizeMode = newAspectRatioMode
}
2022-06-24 20:56:36 +05:30
// lock and unlock the player
2022-07-02 22:01:56 +05:30
playerBinding.lockPlayer.setOnClickListener {
2022-06-24 20:56:36 +05:30
// change the locked/unlocked icon
if (!isPlayerLocked) {
2022-07-02 22:01:56 +05:30
playerBinding.lockPlayer.setImageResource(R.drawable.ic_locked)
2022-06-24 20:56:36 +05:30
} else {
2022-07-02 22:01:56 +05:30
playerBinding.lockPlayer.setImageResource(R.drawable.ic_unlocked)
2022-06-24 20:56:36 +05:30
}
// show/hide all the controls
lockPlayer(isPlayerLocked)
// change locked status
isPlayerLocked = !isPlayerLocked
}
2022-07-17 01:01:15 +05:30
// set default playback speed
val playbackSpeeds = context?.resources?.getStringArray(R.array.playbackSpeed)!!
val playbackSpeedValues =
context?.resources?.getStringArray(R.array.playbackSpeedValues)!!
exoPlayer.setPlaybackSpeed(playbackSpeed.toFloat())
2022-07-18 17:54:08 +05:30
Log.e(TAG, playbackSpeed)
2022-07-17 01:01:15 +05:30
val speedIndex = playbackSpeedValues.indexOf(playbackSpeed)
playerBinding.speedText.text = playbackSpeeds[speedIndex]
// change playback speed button
playerBinding.speedText.setOnClickListener {
MaterialAlertDialogBuilder(requireContext())
.setTitle(R.string.change_playback_speed)
.setItems(playbackSpeeds) { _, index ->
// set the new playback speed
val newPlaybackSpeed = playbackSpeedValues[index].toFloat()
exoPlayer.setPlaybackSpeed(newPlaybackSpeed)
playerBinding.speedText.text = playbackSpeeds[index]
}
.show()
}
// repeat toggle button
playerBinding.repeatToggle.setOnClickListener {
if (exoPlayer.repeatMode == RepeatModeUtil.REPEAT_TOGGLE_MODE_ALL) {
// turn off repeat mode
exoPlayer.repeatMode = RepeatModeUtil.REPEAT_TOGGLE_MODE_NONE
playerBinding.repeatToggle.setColorFilter(Color.GRAY)
} else {
exoPlayer.repeatMode = RepeatModeUtil.REPEAT_TOGGLE_MODE_ALL
playerBinding.repeatToggle.setColorFilter(Color.WHITE)
}
}
// share button
binding.relPlayerShare.setOnClickListener {
val shareDialog = ShareDialog(videoId!!, false)
shareDialog.show(childFragmentManager, "ShareDialog")
}
binding.relPlayerBackground.setOnClickListener {
// pause the current player
exoPlayer.pause()
// start the background mode
2022-07-23 19:11:57 +05:30
BackgroundHelper.playOnBackground(requireContext(), videoId!!)
2022-07-17 01:01:15 +05:30
}
2022-07-01 00:55:40 +05:30
binding.playerScrollView.viewTreeObserver
.addOnScrollChangedListener {
2022-07-01 00:55:40 +05:30
if (binding.playerScrollView.getChildAt(0).bottom
== (binding.playerScrollView.height + binding.playerScrollView.scrollY) &&
2022-05-21 13:32:04 +05:30
nextPage != null
) {
fetchNextComments()
}
}
2022-07-17 16:27:01 +05:30
binding.commentsRecView.layoutManager = LinearLayoutManager(view?.context)
2022-07-01 00:55:40 +05:30
binding.commentsRecView.setItemViewCacheSize(20)
2022-05-08 16:03:01 +05:30
2022-07-01 00:55:40 +05:30
binding.relatedRecView.layoutManager =
2022-07-17 16:27:01 +05:30
GridLayoutManager(view?.context, resources.getInteger(R.integer.grid_items))
}
2022-07-08 23:08:10 +05:30
private fun setFullscreen() {
with(binding.playerMotionLayout) {
getConstraintSet(R.id.start).constrainHeight(R.id.player, -1)
enableTransition(R.id.yt_transition, false)
}
binding.mainContainer.isClickable = true
binding.linLayout.visibility = View.GONE
playerBinding.fullscreen.setImageResource(R.drawable.ic_fullscreen_exit)
playerBinding.exoTitle.visibility = View.VISIBLE
2022-07-09 21:25:59 +05:30
scaleControls(1.3F)
2022-07-08 23:08:10 +05:30
2022-07-17 16:27:01 +05:30
val mainActivity = activity as MainActivity
2022-07-14 19:27:20 +05:30
if (!autoRotationEnabled) {
// different orientations of the video are only available when auto rotation is disabled
val orientation = when (fullscreenOrientationPref) {
"ratio" -> {
val videoSize = exoPlayer.videoSize
// probably a youtube shorts video
if (videoSize.height > videoSize.width) ActivityInfo.SCREEN_ORIENTATION_USER_PORTRAIT
// a video with normal aspect ratio
else ActivityInfo.SCREEN_ORIENTATION_USER_LANDSCAPE
}
2022-07-17 00:28:28 +05:30
"auto" -> ActivityInfo.SCREEN_ORIENTATION_SENSOR
2022-07-14 19:27:20 +05:30
"landscape" -> ActivityInfo.SCREEN_ORIENTATION_USER_LANDSCAPE
"portrait" -> ActivityInfo.SCREEN_ORIENTATION_USER_PORTRAIT
else -> ActivityInfo.SCREEN_ORIENTATION_USER_LANDSCAPE
2022-07-08 23:08:10 +05:30
}
2022-07-14 19:27:20 +05:30
mainActivity.requestedOrientation = orientation
2022-07-08 23:08:10 +05:30
}
2022-07-21 01:33:09 +05:30
binding.player.setDoubleTapOverlayLayoutParams(90)
2022-07-08 23:08:10 +05:30
2022-07-18 22:59:56 +05:30
Globals.IS_FULL_SCREEN = true
2022-07-08 23:08:10 +05:30
}
private fun unsetFullscreen() {
// leave fullscreen mode
with(binding.playerMotionLayout) {
getConstraintSet(R.id.start).constrainHeight(R.id.player, 0)
enableTransition(R.id.yt_transition, true)
}
binding.mainContainer.isClickable = false
binding.linLayout.visibility = View.VISIBLE
playerBinding.fullscreen.setImageResource(R.drawable.ic_fullscreen)
playerBinding.exoTitle.visibility = View.INVISIBLE
2022-07-09 21:25:59 +05:30
scaleControls(1F)
2022-07-08 23:08:10 +05:30
2022-07-14 19:27:20 +05:30
if (!autoRotationEnabled) {
// switch back to portrait mode if auto rotation disabled
val mainActivity = activity as MainActivity
mainActivity.requestedOrientation = ActivityInfo.SCREEN_ORIENTATION_USER_PORTRAIT
}
2022-07-08 23:08:10 +05:30
2022-07-18 22:59:56 +05:30
Globals.IS_FULL_SCREEN = false
2022-07-08 23:08:10 +05:30
}
2022-07-09 21:25:59 +05:30
private fun scaleControls(scaleFactor: Float) {
playerBinding.exoPlayPause.scaleX = scaleFactor
playerBinding.exoPlayPause.scaleY = scaleFactor
}
2022-07-10 21:44:15 +05:30
private fun toggleDescription() {
2022-07-20 17:19:56 +05:30
if (binding.descLinLayout.isVisible) {
// hide the description and chapters
binding.playerDescriptionArrow.animate().rotation(0F).setDuration(250).start()
binding.descLinLayout.visibility = View.GONE
} else {
// show the description and chapters
binding.playerDescriptionArrow.animate().rotation(180F).setDuration(250).start()
binding.descLinLayout.visibility = View.VISIBLE
}
2022-07-23 03:28:23 +05:30
if (this::chapters.isInitialized && chapters.isNotEmpty()) {
val chapterIndex = getCurrentChapterIndex()
2022-07-23 01:46:26 +05:30
// scroll to the current chapter in the chapterRecView in the description
val layoutManager = binding.chaptersRecView.layoutManager as LinearLayoutManager
2022-07-23 03:28:23 +05:30
layoutManager.scrollToPositionWithOffset(chapterIndex, 0)
// set selected
val chaptersAdapter = binding.chaptersRecView.adapter as ChaptersAdapter
chaptersAdapter.updateSelectedPosition(chapterIndex)
2022-07-23 01:46:26 +05:30
}
2022-07-10 21:44:15 +05:30
}
2022-06-12 22:56:38 +05:30
private fun toggleComments() {
2022-07-01 00:55:40 +05:30
binding.commentsRecView.visibility =
if (binding.commentsRecView.isVisible) View.GONE else View.VISIBLE
binding.relatedRecView.visibility =
if (binding.relatedRecView.isVisible) View.GONE else View.VISIBLE
2022-06-12 22:56:38 +05:30
if (!commentsLoaded!!) fetchComments()
}
2022-06-20 17:52:28 +05:30
override fun onPause() {
2022-07-17 16:27:01 +05:30
// pauses the player if the screen is turned off
2022-06-20 17:52:28 +05:30
// check whether the screen is on
val pm = context?.getSystemService(Context.POWER_SERVICE) as PowerManager
val isScreenOn = pm.isInteractive
// pause player if screen off and setting enabled
2022-06-29 19:37:58 +05:30
if (
2022-07-01 14:41:24 +05:30
this::exoPlayer.isInitialized && !isScreenOn && pausePlayerOnScreenOffEnabled
2022-06-29 19:37:58 +05:30
) {
2022-06-20 17:52:28 +05:30
exoPlayer.pause()
}
super.onPause()
}
2022-02-06 21:51:37 +05:30
override fun onDestroy() {
super.onDestroy()
2021-12-14 02:58:17 +05:30
try {
2022-07-02 22:34:19 +05:30
saveWatchPosition()
2022-06-05 15:12:33 +05:30
mediaSession.isActive = false
mediaSession.release()
mediaSessionConnector.setPlayer(null)
playerNotification.setPlayer(null)
val notificationManager = context?.getSystemService(
2022-06-01 12:22:38 +05:30
Context.NOTIFICATION_SERVICE
) as NotificationManager
2022-06-06 20:12:46 +05:30
notificationManager.cancel(1)
2022-06-05 15:12:33 +05:30
exoPlayer.release()
2022-07-27 15:27:04 +05:30
activity?.requestedOrientation =
if ((activity as MainActivity).autoRotationEnabled) ActivityInfo.SCREEN_ORIENTATION_USER
else ActivityInfo.SCREEN_ORIENTATION_USER_PORTRAIT
2022-04-15 12:08:53 +05:30
} catch (e: Exception) {
}
}
2022-07-02 22:34:19 +05:30
// save the watch position if video isn't finished and option enabled
private fun saveWatchPosition() {
if (watchPositionsEnabled && exoPlayer.currentPosition != exoPlayer.duration) {
PreferenceHelper.saveWatchPosition(
videoId!!,
exoPlayer.currentPosition
)
} else if (watchPositionsEnabled) {
// delete watch position if video has ended
PreferenceHelper.removeWatchPosition(videoId!!)
2022-07-02 22:34:19 +05:30
}
}
2022-05-20 03:52:10 +05:30
private fun checkForSegments() {
2022-06-26 14:06:34 +05:30
if (!exoPlayer.isPlaying || !sponsorBlockPrefs.sponsorBlockEnabled) return
2022-05-16 15:41:22 +05:30
exoPlayerView.postDelayed(this::checkForSegments, 100)
2022-06-24 20:56:36 +05:30
if (!::segmentData.isInitialized || segmentData.segments.isEmpty()) {
2022-05-16 15:41:22 +05:30
return
2022-06-24 20:56:36 +05:30
}
2022-05-16 15:41:22 +05:30
segmentData.segments.forEach { segment: Segment ->
val segmentStart = (segment.segment!![0] * 1000.0f).toLong()
2022-05-21 13:32:04 +05:30
val segmentEnd = (segment.segment[1] * 1000.0f).toLong()
2022-05-16 15:41:22 +05:30
val currentPosition = exoPlayer.currentPosition
2022-05-20 03:52:10 +05:30
if (currentPosition in segmentStart until segmentEnd) {
2022-06-26 14:06:34 +05:30
if (sponsorBlockPrefs.sponsorNotificationsEnabled) {
2022-05-23 00:07:09 +05:30
Toast.makeText(context, R.string.segment_skipped, Toast.LENGTH_SHORT).show()
}
2022-05-20 03:52:10 +05:30
exoPlayer.seekTo(segmentEnd)
2022-05-16 15:41:22 +05:30
}
}
}
2022-07-17 16:27:01 +05:30
private fun playVideo() {
fun run() {
2021-12-18 16:34:14 +05:30
lifecycleScope.launchWhenCreated {
val response = try {
RetrofitInstance.api.getStreams(videoId!!)
} catch (e: IOException) {
2021-12-18 16:34:14 +05:30
println(e)
Log.e(TAG, "IOException, you might not have internet connection")
2022-04-15 12:08:53 +05:30
Toast.makeText(context, R.string.unknown_error, Toast.LENGTH_SHORT).show()
2021-12-18 16:34:14 +05:30
return@launchWhenCreated
} catch (e: HttpException) {
Log.e(TAG, "HttpException, unexpected response")
2022-04-15 12:08:53 +05:30
Toast.makeText(context, R.string.server_error, Toast.LENGTH_SHORT).show()
2021-12-18 16:34:14 +05:30
return@launchWhenCreated
}
2022-06-14 15:30:58 +05:30
// for the notification description adapter
title = response.title!!
uploader = response.uploader!!
thumbnailUrl = response.thumbnailUrl!!
2022-07-27 14:47:05 +05:30
channelId = response.uploaderUrl?.replace("/channel/", "")
2022-06-14 15:30:58 +05:30
2022-06-17 16:51:55 +05:30
// save related streams for autoplay
relatedStreams = response.relatedStreams
2022-06-29 12:34:11 +05:30
2022-06-14 15:30:58 +05:30
runOnUiThread {
2022-06-26 21:19:42 +05:30
// set media sources for the player
2022-07-12 20:44:10 +05:30
setResolutionAndSubtitles(response)
2022-06-28 20:02:26 +05:30
prepareExoPlayerView()
2022-07-17 16:27:01 +05:30
initializePlayerView(response)
2022-07-02 22:34:19 +05:30
seekToWatchPosition()
2022-07-03 15:43:38 +05:30
exoPlayer.prepare()
2022-06-14 15:30:58 +05:30
exoPlayer.play()
2022-06-26 21:37:51 +05:30
exoPlayerView.useController = true
2022-06-14 15:30:58 +05:30
initializePlayerNotification(requireContext())
fetchSponsorBlockSegments()
2022-06-26 21:19:42 +05:30
// show comments if related streams disabled
2022-06-14 15:30:58 +05:30
if (!relatedStreamsEnabled) toggleComments()
2022-06-29 12:34:11 +05:30
// prepare for autoplay
initAutoPlay()
2022-07-01 23:18:20 +05:30
if (watchHistoryEnabled) {
PreferenceHelper.addToWatchHistory(videoId!!, response)
2022-07-01 23:18:20 +05:30
}
2022-06-29 12:34:11 +05:30
}
}
}
run()
}
2022-07-02 22:34:19 +05:30
private fun seekToWatchPosition() {
2022-07-03 15:43:38 +05:30
// seek to saved watch position if available
val watchPositions = PreferenceHelper.getWatchPositions()
2022-07-07 19:28:51 +05:30
var position: Long? = null
2022-07-02 22:34:19 +05:30
watchPositions.forEach {
2022-07-07 19:28:51 +05:30
if (it.videoId == videoId) position = it.position
2022-07-02 22:34:19 +05:30
}
2022-07-03 15:43:38 +05:30
// support for time stamped links
2022-07-07 19:28:51 +05:30
val timeStamp: Long? = arguments?.getLong("timeStamp")
if (timeStamp != null && timeStamp != 0L) {
position = timeStamp * 1000
2022-07-03 15:43:38 +05:30
}
2022-07-07 19:28:51 +05:30
if (position != null) exoPlayer.seekTo(position!!)
2022-07-02 22:34:19 +05:30
}
2022-06-29 12:59:23 +05:30
// the function is working recursively
2022-06-29 12:34:11 +05:30
private fun initAutoPlay() {
// save related streams for autoplay
2022-07-17 16:27:01 +05:30
if (autoplayEnabled) {
2022-06-29 12:52:22 +05:30
// if it's a playlist use the next video
2022-06-29 12:34:11 +05:30
if (playlistId != null) {
2022-06-29 12:52:22 +05:30
lateinit var playlist: Playlist // var for saving the list in
2022-06-29 12:59:23 +05:30
// runs only the first time when starting a video from a playlist
2022-06-29 12:34:11 +05:30
if (playlistStreamIds.isEmpty()) {
CoroutineScope(Dispatchers.IO).launch {
// fetch the playlists videos
playlist = RetrofitInstance.api.getPlaylist(playlistId!!)
2022-06-29 12:59:23 +05:30
// save the playlist urls in the array
2022-06-29 12:34:11 +05:30
playlist.relatedStreams?.forEach { video ->
playlistStreamIds += video.url?.replace("/watch?v=", "")!!
}
2022-06-29 12:59:23 +05:30
// save playlistNextPage for usage if video is not contained
2022-06-29 12:52:22 +05:30
playlistNextPage = playlist.nextpage
2022-06-29 12:59:23 +05:30
// restart the function after videos are loaded
2022-06-29 12:52:22 +05:30
initAutoPlay()
}
}
// if the playlists contain the video, then save the next video as next stream
else if (playlistStreamIds.contains(videoId)) {
val index = playlistStreamIds.indexOf(videoId)
// check whether there's a next video
if (index + 1 <= playlistStreamIds.size) {
nextStreamId = playlistStreamIds[index + 1]
}
// fetch the next page of the playlist if the video isn't contained
} else if (playlistNextPage != null) {
CoroutineScope(Dispatchers.IO).launch {
RetrofitInstance.api.getPlaylistNextPage(playlistId!!, playlistNextPage!!)
2022-06-29 12:59:23 +05:30
// append all the playlist item urls to the array
2022-06-29 12:52:22 +05:30
playlist.relatedStreams?.forEach { video ->
playlistStreamIds += video.url?.replace("/watch?v=", "")!!
2022-06-29 12:34:11 +05:30
}
2022-06-29 12:59:23 +05:30
// save playlistNextPage for usage if video is not contained
2022-06-29 12:52:22 +05:30
playlistNextPage = playlist.nextpage
2022-06-29 12:59:23 +05:30
// restart the function after videos are loaded
2022-06-29 12:52:22 +05:30
initAutoPlay()
2022-06-29 12:34:11 +05:30
}
}
2022-06-29 12:59:23 +05:30
// else: the video must be the last video of the playlist so nothing happens
2022-06-29 12:52:22 +05:30
// if it's not a playlist then use the next related video
2022-06-29 12:34:11 +05:30
} else if (relatedStreams != null && relatedStreams!!.isNotEmpty()) {
// save next video from related streams for autoplay
2022-07-01 14:41:24 +05:30
nextStreamId = relatedStreams!![0].url!!.replace("/watch?v=", "")
2022-06-29 12:34:11 +05:30
}
}
}
2022-06-29 12:59:23 +05:30
// used for autoplay and skipping to next video
2022-06-29 12:34:11 +05:30
private fun playNextVideo() {
2022-06-29 12:59:23 +05:30
// check whether there is a new video in the queue
// by making sure that the next and the current video aren't the same
if (videoId != nextStreamId) {
// save the id of the next stream as videoId and load the next video
videoId = nextStreamId
2022-07-17 16:27:01 +05:30
playVideo()
2022-06-29 12:59:23 +05:30
}
2022-06-29 12:34:11 +05:30
}
2022-06-14 15:30:58 +05:30
private fun fetchSponsorBlockSegments() {
fun run() {
2022-06-29 19:37:58 +05:30
lifecycleScope.launch(Dispatchers.IO) {
2022-06-26 14:06:34 +05:30
if (sponsorBlockPrefs.sponsorBlockEnabled) {
val categories: ArrayList<String> = arrayListOf()
2022-06-26 14:06:34 +05:30
if (sponsorBlockPrefs.introEnabled) {
categories.add("intro")
}
2022-06-26 14:06:34 +05:30
if (sponsorBlockPrefs.selfPromoEnabled) {
categories.add("selfpromo")
}
2022-06-26 14:06:34 +05:30
if (sponsorBlockPrefs.interactionEnabled) {
categories.add("interaction")
}
2022-06-26 14:06:34 +05:30
if (sponsorBlockPrefs.sponsorsEnabled) {
categories.add("sponsor")
}
2022-06-26 14:06:34 +05:30
if (sponsorBlockPrefs.outroEnabled) {
categories.add("outro")
}
2022-06-26 14:06:34 +05:30
if (sponsorBlockPrefs.fillerEnabled) {
categories.add("filler")
}
2022-06-26 14:06:34 +05:30
if (sponsorBlockPrefs.musicOffTopicEnabled) {
categories.add("music_offtopic")
}
2022-06-26 14:06:34 +05:30
if (sponsorBlockPrefs.previewEnabled) {
categories.add("preview")
}
2022-05-20 03:52:10 +05:30
if (categories.size > 0) {
segmentData = try {
RetrofitInstance.api.getSegments(
videoId!!,
"[\"" + TextUtils.join("\",\"", categories) + "\"]"
)
} catch (e: IOException) {
println(e)
Log.e(TAG, "IOException, you might not have internet connection")
2022-06-29 19:37:58 +05:30
return@launch
} catch (e: HttpException) {
Log.e(TAG, "HttpException, unexpected response")
2022-06-29 19:37:58 +05:30
return@launch
2022-05-16 15:41:22 +05:30
}
}
}
2022-06-01 11:55:12 +05:30
}
}
run()
}
2022-05-16 15:41:22 +05:30
2022-06-03 22:13:15 +05:30
private fun prepareExoPlayerView() {
2022-06-05 15:12:33 +05:30
exoPlayerView.apply {
setShowSubtitleButton(true)
setShowNextButton(false)
setShowPreviousButton(false)
// controllerShowTimeoutMs = 1500
controllerHideOnTouch = true
2022-06-26 21:37:51 +05:30
useController = false
2022-06-05 15:12:33 +05:30
player = exoPlayer
}
if (useSystemCaptionStyle) {
// set the subtitle style
2022-07-17 01:01:15 +05:30
val captionStyle = PlayerHelper.getCaptionStyle(requireContext())
exoPlayerView.subtitleView?.setApplyEmbeddedStyles(captionStyle == CaptionStyleCompat.DEFAULT)
exoPlayerView.subtitleView?.setStyle(captionStyle)
}
2022-06-03 22:13:15 +05:30
}
2022-07-17 16:27:01 +05:30
private fun initializePlayerView(response: Streams) {
2022-07-16 01:07:44 +05:30
binding.apply {
playerViewsInfo.text =
context?.getString(R.string.views, response.views.formatShort()) +
"" + response.uploadDate
textLike.text = response.likes.formatShort()
textDislike.text = response.dislikes.formatShort()
ConnectionHelper.loadImage(response.uploaderAvatar, binding.playerChannelImage)
playerChannelName.text = response.uploader
titleTextView.text = response.title
playerTitle.text = response.title
playerDescription.text = response.description
}
2022-06-03 22:13:15 +05:30
2022-07-02 22:01:56 +05:30
playerBinding.exoTitle.text = response.title
2022-06-27 22:32:10 +05:30
2022-07-20 17:35:17 +05:30
if (seekBarPreview) enableSeekbarPreview()
2022-07-08 20:56:45 +05:30
enableDoubleTapToSeek()
2022-07-03 15:43:38 +05:30
// init the chapters recyclerview
2022-07-09 22:55:06 +05:30
if (response.chapters != null) {
chapters = response.chapters
initializeChapters()
}
2022-07-03 15:43:38 +05:30
2022-06-03 22:13:15 +05:30
// Listener for play and pause icon change
2022-06-14 18:39:47 +05:30
exoPlayer.addListener(object : Player.Listener {
2022-06-03 22:13:15 +05:30
override fun onIsPlayingChanged(isPlaying: Boolean) {
2022-06-26 14:06:34 +05:30
if (isPlaying && sponsorBlockPrefs.sponsorBlockEnabled) {
2022-06-03 22:13:15 +05:30
exoPlayerView.postDelayed(
this@PlayerFragment::checkForSegments,
100
)
2022-06-03 02:24:18 +05:30
}
2022-06-03 22:13:15 +05:30
}
2022-06-16 01:33:32 +05:30
2022-07-03 16:58:24 +05:30
override fun onVideoSizeChanged(
videoSize: VideoSize
) {
// Set new width/height of view
// height or width must be cast to float as int/int will give 0
2022-07-03 21:57:15 +05:30
// Redraw the player container with the new layout height
2022-07-08 21:36:48 +05:30
val params = binding.player.layoutParams
params.height = videoSize.height / videoSize.width * params.width
binding.player.layoutParams = params
binding.player.requestLayout()
2022-07-08 21:49:43 +05:30
(binding.mainContainer.layoutParams as ConstraintLayout.LayoutParams).apply {
2022-07-08 21:48:31 +05:30
matchConstraintPercentHeight = (videoSize.height / videoSize.width).toFloat()
}
2022-07-03 16:58:24 +05:30
}
2022-06-14 18:39:47 +05:30
@Deprecated(message = "Deprecated", level = DeprecationLevel.HIDDEN)
2022-06-03 22:13:15 +05:30
override fun onPlayerStateChanged(
playWhenReady: Boolean,
playbackState: Int
) {
exoPlayerView.keepScreenOn = !(
playbackState == Player.STATE_IDLE ||
playbackState == Player.STATE_ENDED ||
!playWhenReady
)
2022-06-03 02:24:18 +05:30
2022-06-17 16:51:55 +05:30
// check if video has ended, next video is available and autoplay is enabled.
2022-06-17 17:03:10 +05:30
if (
2022-06-17 17:02:00 +05:30
playbackState == Player.STATE_ENDED &&
2022-06-29 12:34:11 +05:30
nextStreamId != null &&
2022-06-17 17:02:00 +05:30
!transitioning &&
2022-07-17 16:27:01 +05:30
autoplayEnabled
2022-06-17 17:02:00 +05:30
) {
2022-06-17 16:51:55 +05:30
transitioning = true
2022-06-29 12:34:11 +05:30
// check whether autoplay is enabled
2022-07-17 16:27:01 +05:30
if (autoplayEnabled) playNextVideo()
2022-06-17 16:51:55 +05:30
}
2022-06-03 22:13:15 +05:30
if (playWhenReady && playbackState == Player.STATE_READY) {
// media actually playing
2022-06-17 16:51:55 +05:30
transitioning = false
2022-07-01 00:55:40 +05:30
binding.playImageView.setImageResource(R.drawable.ic_pause)
2022-06-03 22:13:15 +05:30
} else if (playWhenReady) {
// might be idle (plays after prepare()),
// buffering (plays when data available)
// or ended (plays when seek away from end)
2022-07-01 00:55:40 +05:30
binding.playImageView.setImageResource(R.drawable.ic_play)
2022-06-03 22:13:15 +05:30
} else {
// player paused in any state
2022-07-01 00:55:40 +05:30
binding.playImageView.setImageResource(R.drawable.ic_play)
2022-06-03 02:24:18 +05:30
}
2022-06-03 02:15:45 +05:30
}
2022-06-03 22:13:15 +05:30
})
// check if livestream
if (response.duration!! > 0) {
// download clicked
2022-07-01 00:35:31 +05:30
binding.relPlayerDownload.setOnClickListener {
2022-07-18 22:59:56 +05:30
if (!Globals.IS_DOWNLOAD_RUNNING) {
2022-06-03 22:13:15 +05:30
val newFragment = DownloadDialog()
2022-06-14 18:39:47 +05:30
val bundle = Bundle()
2022-06-03 22:13:15 +05:30
bundle.putString("video_id", videoId)
newFragment.arguments = bundle
2022-07-08 01:50:24 +05:30
newFragment.show(childFragmentManager, "DownloadDialog")
2022-06-03 22:13:15 +05:30
} else {
Toast.makeText(context, R.string.dlisinprogress, Toast.LENGTH_SHORT)
.show()
2022-06-01 11:55:12 +05:30
}
}
2022-06-03 22:13:15 +05:30
} else {
Toast.makeText(context, R.string.cannotDownload, Toast.LENGTH_SHORT).show()
}
2022-06-03 02:15:45 +05:30
2022-06-03 22:13:15 +05:30
if (response.hls != null) {
2022-07-15 13:46:31 +05:30
binding.relPlayerOpen.setOnClickListener {
// start an intent with video as mimetype using the hls stream
val uri: Uri = Uri.parse(response.hls)
val intent = Intent()
intent.action = Intent.ACTION_VIEW
intent.setDataAndType(uri, "video/*")
intent.putExtra(Intent.EXTRA_TITLE, title)
intent.putExtra("title", title)
intent.putExtra("artist", uploader)
intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
2022-07-15 13:46:31 +05:30
try {
startActivity(intent)
} catch (e: Exception) {
Toast.makeText(context, R.string.no_player_found, Toast.LENGTH_SHORT).show()
}
2022-06-03 02:15:45 +05:30
}
2022-06-03 22:13:15 +05:30
}
2022-06-12 22:56:38 +05:30
if (relatedStreamsEnabled) {
// only show related streams if enabled
2022-07-01 00:55:40 +05:30
binding.relatedRecView.adapter = TrendingAdapter(
2022-06-12 22:56:38 +05:30
response.relatedStreams!!,
childFragmentManager
)
}
// set video description
2022-06-03 22:13:15 +05:30
val description = response.description!!
2022-07-01 00:55:40 +05:30
binding.playerDescription.text =
2022-06-03 22:13:15 +05:30
// detect whether the description is html formatted
if (description.contains("<") && description.contains(">")) {
if (SDK_INT >= Build.VERSION_CODES.N) {
Html.fromHtml(description, Html.FROM_HTML_MODE_COMPACT)
.trim()
2022-06-03 02:15:45 +05:30
} else {
2022-06-03 22:13:15 +05:30
Html.fromHtml(description).trim()
2022-06-03 02:15:45 +05:30
}
2022-06-03 22:13:15 +05:30
} else {
description
}
2022-06-03 02:15:45 +05:30
2022-07-01 00:55:40 +05:30
binding.playerChannel.setOnClickListener {
2022-07-17 16:27:01 +05:30
val activity = view?.context as MainActivity
2022-06-03 22:13:15 +05:30
val bundle = bundleOf("channel_id" to response.uploaderUrl)
2022-07-01 21:59:47 +05:30
activity.navController.navigate(R.id.channelFragment, bundle)
2022-07-01 00:55:40 +05:30
activity.binding.mainMotionLayout.transitionToEnd()
binding.playerMotionLayout.transitionToEnd()
2022-06-03 22:13:15 +05:30
}
2022-06-26 14:38:10 +05:30
if (token != "") {
2022-06-03 22:13:15 +05:30
val channelId = response.uploaderUrl?.replace("/channel/", "")
2022-07-27 14:47:05 +05:30
isSubscribed()
2022-07-10 21:34:58 +05:30
binding.relPlayerSave.setOnClickListener {
2022-06-03 22:13:15 +05:30
val newFragment = AddtoPlaylistDialog()
2022-06-14 18:39:47 +05:30
val bundle = Bundle()
2022-06-03 22:13:15 +05:30
bundle.putString("videoId", videoId)
newFragment.arguments = bundle
newFragment.show(childFragmentManager, "AddToPlaylist")
2022-06-01 11:55:12 +05:30
}
2022-07-27 14:47:05 +05:30
} else {
binding.relPlayerSave.setOnClickListener {
Toast.makeText(context, R.string.login_first, Toast.LENGTH_SHORT).show()
}
2022-06-03 02:15:45 +05:30
}
}
2022-07-08 20:56:45 +05:30
private fun enableDoubleTapToSeek() {
2022-07-18 20:25:48 +05:30
// set seek increment text
val seekIncrementText = (seekIncrement / 1000).toString()
2022-07-19 17:38:12 +05:30
doubleTapOverlayBinding.rewindTV.text = seekIncrementText
doubleTapOverlayBinding.forwardTV.text = seekIncrementText
2022-07-27 12:25:44 +05:30
binding.player.setOnDoubleTapListener(
2022-07-27 14:47:05 +05:30
object : OnDoubleTapEventListener {
2022-07-27 12:25:44 +05:30
override fun onEvent(x: Float) {
val width = exoPlayerView.width
when {
2022-07-27 12:35:10 +05:30
width * 0.5 > x -> rewind()
width * 0.5 < x -> forward()
2022-07-27 12:25:44 +05:30
}
2022-07-17 15:09:55 +05:30
}
}
2022-07-08 20:56:45 +05:30
)
}
2022-07-18 20:25:48 +05:30
private fun rewind() {
exoPlayer.seekTo(exoPlayer.currentPosition - seekIncrement)
// show the rewind button
2022-07-19 17:38:12 +05:30
doubleTapOverlayBinding.rewindBTN.apply {
2022-07-18 20:25:48 +05:30
visibility = View.VISIBLE
// clear previous animation
animate().rotation(0F).setDuration(0).start()
// start new animation
animate()
.rotation(-30F)
.setDuration(100)
.withEndAction {
// reset the animation when finished
animate().rotation(0F).setDuration(100).start()
}
.start()
removeCallbacks(hideRewindButtonRunnable)
// start callback to hide the button
postDelayed(hideRewindButtonRunnable, 700)
}
}
private fun forward() {
exoPlayer.seekTo(exoPlayer.currentPosition + seekIncrement)
// show the forward button
2022-07-19 17:38:12 +05:30
doubleTapOverlayBinding.forwardBTN.apply {
2022-07-18 20:25:48 +05:30
visibility = View.VISIBLE
// clear previous animation
animate().rotation(0F).setDuration(0).start()
// start new animation
animate()
.rotation(30F)
.setDuration(100)
.withEndAction {
// reset the animation when finished
animate().rotation(0F).setDuration(100).start()
}
.start()
// start callback to hide the button
removeCallbacks(hideForwardButtonRunnable)
postDelayed(hideForwardButtonRunnable, 700)
}
}
private val hideForwardButtonRunnable = Runnable {
2022-07-19 17:38:12 +05:30
doubleTapOverlayBinding.forwardBTN.apply {
2022-07-18 20:25:48 +05:30
visibility = View.GONE
}
}
private val hideRewindButtonRunnable = Runnable {
2022-07-19 17:38:12 +05:30
doubleTapOverlayBinding.rewindBTN.apply {
2022-07-18 20:25:48 +05:30
visibility = View.GONE
}
}
2022-07-17 15:32:49 +05:30
2022-07-19 18:29:16 +05:30
private fun toggleController() {
if (exoPlayerView.isControllerFullyVisible) exoPlayerView.hideController()
else exoPlayerView.showController()
}
2022-07-08 22:14:38 +05:30
// enable seek bar preview
private fun enableSeekbarPreview() {
playerBinding.exoProgress.addListener(object : TimeBar.OnScrubListener {
override fun onScrubStart(timeBar: TimeBar, position: Long) {
exoPlayer.pause()
}
override fun onScrubMove(timeBar: TimeBar, position: Long) {
2022-07-12 20:44:10 +05:30
val minTimeDiff = 10 * 1000 // 10s
// get the difference between the new and the old position
val diff = abs(exoPlayer.currentPosition - position)
// seek only when the difference is greater than 10 seconds
if (diff >= minTimeDiff) exoPlayer.seekTo(position)
2022-07-08 22:14:38 +05:30
}
override fun onScrubStop(timeBar: TimeBar, position: Long, canceled: Boolean) {
2022-07-12 20:44:10 +05:30
exoPlayer.seekTo(position)
2022-07-08 22:14:38 +05:30
exoPlayer.play()
2022-07-08 22:20:11 +05:30
Handler(Looper.getMainLooper()).postDelayed({
exoPlayerView.hideController()
}, 200)
2022-07-08 22:14:38 +05:30
}
})
}
2022-07-09 22:55:06 +05:30
private fun initializeChapters() {
2022-06-13 19:45:02 +05:30
if (chapters.isNotEmpty()) {
2022-07-09 22:21:09 +05:30
// enable chapters in the video description
2022-07-01 00:55:40 +05:30
binding.chaptersRecView.layoutManager =
2022-07-09 22:21:09 +05:30
LinearLayoutManager(
context,
LinearLayoutManager.HORIZONTAL,
false
)
2022-07-01 00:55:40 +05:30
binding.chaptersRecView.adapter = ChaptersAdapter(chapters, exoPlayer)
binding.chaptersRecView.visibility = View.VISIBLE
2022-07-09 22:21:09 +05:30
2022-07-10 16:31:24 +05:30
// enable the chapters dialog in the player
2022-07-09 22:21:09 +05:30
val titles = mutableListOf<String>()
chapters.forEach {
titles += it.title!!
}
2022-07-10 16:31:24 +05:30
playerBinding.chapterLL.visibility = View.VISIBLE
2022-07-09 22:55:06 +05:30
playerBinding.chapterLL.setOnClickListener {
2022-07-18 22:59:56 +05:30
if (Globals.IS_FULL_SCREEN) {
2022-07-10 21:44:15 +05:30
MaterialAlertDialogBuilder(requireContext())
.setTitle(R.string.chapters)
.setItems(titles.toTypedArray()) { _, index ->
val position = chapters[index].start!! * 1000
exoPlayer.seekTo(position)
}
.show()
} else {
toggleDescription()
}
2022-07-09 22:21:09 +05:30
}
2022-07-09 22:55:06 +05:30
setCurrentChapterName()
}
}
// set the name of the video chapter in the exoPlayerView
private fun setCurrentChapterName() {
// call the function again in 100ms
exoPlayerView.postDelayed(this::setCurrentChapterName, 100)
2022-07-23 01:46:26 +05:30
val chapterIndex = getCurrentChapterIndex()
val chapterName = chapters[chapterIndex].title
2022-07-09 22:55:06 +05:30
// change the chapter name textView text to the chapterName
2022-07-23 01:46:26 +05:30
if (chapterName != playerBinding.chapterName.text) {
2022-07-09 22:55:06 +05:30
playerBinding.chapterName.text = chapterName
2022-07-23 03:28:23 +05:30
// update the selected item
val chaptersAdapter = binding.chaptersRecView.adapter as ChaptersAdapter
chaptersAdapter.updateSelectedPosition(chapterIndex)
2022-07-09 22:55:55 +05:30
}
2022-06-12 22:56:38 +05:30
}
2022-07-11 01:34:52 +05:30
// get the name of the currently played chapter
2022-07-23 01:46:26 +05:30
private fun getCurrentChapterIndex(): Int {
2022-07-11 01:34:52 +05:30
val currentPosition = exoPlayer.currentPosition
2022-07-23 01:46:26 +05:30
var chapterIndex: Int? = null
2022-07-11 01:34:52 +05:30
2022-07-23 01:46:26 +05:30
chapters.forEachIndexed { index, chapter ->
2022-07-11 01:34:52 +05:30
// check whether the chapter start is greater than the current player position
2022-07-23 01:46:26 +05:30
if (currentPosition >= chapter.start!! * 1000) {
2022-07-11 01:34:52 +05:30
// save chapter title if found
2022-07-23 01:46:26 +05:30
chapterIndex = index
2022-07-11 01:34:52 +05:30
}
}
2022-07-23 01:46:26 +05:30
return chapterIndex!!
2022-07-11 01:34:52 +05:30
}
2022-06-16 01:30:36 +05:30
private fun setMediaSource(
2022-06-16 14:08:36 +05:30
videoUri: Uri,
audioUrl: String
2022-06-16 01:30:36 +05:30
) {
val dataSourceFactory: DataSource.Factory =
DefaultHttpDataSource.Factory()
val videoItem: MediaItem = MediaItem.Builder()
.setUri(videoUri)
.setSubtitleConfigurations(subtitle)
.build()
val videoSource: MediaSource =
DefaultMediaSourceFactory(dataSourceFactory)
.createMediaSource(videoItem)
2022-07-01 14:41:24 +05:30
val audioSource: MediaSource =
2022-06-16 01:30:36 +05:30
ProgressiveMediaSource.Factory(dataSourceFactory)
2022-06-16 14:08:36 +05:30
.createMediaSource(fromUri(audioUrl))
2022-06-16 01:30:36 +05:30
val mergeSource: MediaSource =
MergingMediaSource(videoSource, audioSource)
exoPlayer.setMediaSource(mergeSource)
}
2022-07-12 20:44:10 +05:30
private fun setResolutionAndSubtitles(response: Streams) {
2022-06-03 02:15:45 +05:30
var videosNameArray: Array<CharSequence> = arrayOf()
2022-06-16 01:30:36 +05:30
var videosUrlArray: Array<Uri> = arrayOf()
2022-06-16 14:08:36 +05:30
// append hls to list if available
if (response.hls != null) {
2022-07-03 16:58:24 +05:30
videosNameArray += getString(R.string.hls)
2022-06-16 14:08:36 +05:30
videosUrlArray += response.hls.toUri()
}
2022-06-03 02:15:45 +05:30
for (vid in response.videoStreams!!) {
2022-06-16 14:08:36 +05:30
// append quality to list if it has the preferred format (e.g. MPEG)
2022-07-24 16:29:15 +05:30
val preferredMimeType = "video/$videoFormatPreference"
if (vid.url != null && vid.mimeType == preferredMimeType) { // preferred format
2022-07-10 13:14:45 +05:30
videosNameArray += vid.quality.toString()
2022-06-16 01:30:36 +05:30
videosUrlArray += vid.url!!.toUri()
2022-07-14 23:18:00 +05:30
} else if (vid.quality.equals("LBRY") && vid.format.equals("MP4")) { // LBRY MP4 format
2022-06-16 14:08:36 +05:30
videosNameArray += "LBRY MP4"
videosUrlArray += vid.url!!.toUri()
2022-06-16 01:30:36 +05:30
}
2022-06-03 02:15:45 +05:30
}
2022-06-16 01:30:36 +05:30
// create a list of subtitles
2022-07-17 02:19:32 +05:30
subtitle = mutableListOf()
val subtitlesNamesList = mutableListOf(context?.getString(R.string.none)!!)
val subtitleCodesList = mutableListOf("")
2022-06-19 01:14:22 +05:30
response.subtitles!!.forEach {
2022-06-03 02:15:45 +05:30
subtitle.add(
2022-06-19 01:14:22 +05:30
SubtitleConfiguration.Builder(it.url!!.toUri())
.setMimeType(it.mimeType!!) // The correct MIME type (required).
.setLanguage(it.code) // The subtitle language (optional).
2022-06-03 02:15:45 +05:30
.build()
)
2022-07-17 02:19:32 +05:30
subtitlesNamesList += it.name!!
subtitleCodesList += it.code!!
2022-06-03 02:15:45 +05:30
}
2022-07-17 02:19:32 +05:30
// captions selection dialog
// hide caption selection view if no subtitles available
if (response.subtitles.isEmpty()) playerBinding.captions.visibility = View.GONE
playerBinding.captions.setOnClickListener {
MaterialAlertDialogBuilder(requireContext())
.setTitle(R.string.captions)
.setItems(subtitlesNamesList.toTypedArray()) { _, index ->
val newParams = if (index != 0) {
// caption selected
// get the caption name and language
val captionLanguage = subtitlesNamesList[index]
val captionLanguageCode = subtitleCodesList[index]
2022-07-17 15:49:55 +05:30
// update the icon of the captions button
2022-07-17 02:19:32 +05:30
playerBinding.captions.setImageResource(R.drawable.ic_caption)
// select the new caption preference
trackSelector.buildUponParameters()
.setPreferredTextLanguages(
captionLanguage,
captionLanguageCode
)
.setPreferredTextRoleFlags(C.ROLE_FLAG_CAPTION)
} else {
// none selected
playerBinding.captions.setImageResource(R.drawable.ic_caption_outlined)
// disable captions
trackSelector.buildUponParameters()
.setPreferredTextLanguage("")
}
// set the new caption language
trackSelector.setParameters(newParams)
}
.show()
}
2022-07-14 23:18:00 +05:30
// set media source and resolution in the beginning
setStreamSource(
response,
videosNameArray,
videosUrlArray
)
2022-06-03 02:15:45 +05:30
2022-07-10 13:21:40 +05:30
playerBinding.qualityText.setOnClickListener {
2022-06-03 02:15:45 +05:30
// Dialog for quality selection
val builder: MaterialAlertDialogBuilder? = activity?.let {
MaterialAlertDialogBuilder(it)
2021-12-18 16:34:14 +05:30
}
2022-06-14 18:39:47 +05:30
val lastPosition = exoPlayer.currentPosition
2022-06-03 02:15:45 +05:30
builder!!.setTitle(R.string.choose_quality_dialog)
.setItems(
2022-06-14 18:39:47 +05:30
videosNameArray
) { _, which ->
2022-06-16 14:08:36 +05:30
if (
2022-07-03 16:58:24 +05:30
videosNameArray[which] == getString(R.string.hls) ||
2022-06-16 14:08:36 +05:30
videosNameArray[which] == "LBRY HLS"
) {
// no need to merge sources if using hls
2022-06-14 18:39:47 +05:30
val mediaItem: MediaItem = MediaItem.Builder()
2022-06-16 14:08:36 +05:30
.setUri(videosUrlArray[which])
2022-06-14 18:39:47 +05:30
.setSubtitleConfigurations(subtitle)
.build()
exoPlayer.setMediaItem(mediaItem)
} else {
2022-06-16 14:08:36 +05:30
val videoUri = videosUrlArray[which]
2022-07-24 16:29:15 +05:30
val audioUrl = PlayerHelper.getAudioSource(response.audioStreams!!)
2022-07-14 23:18:00 +05:30
setMediaSource(videoUri, audioUrl)
2022-06-03 02:15:45 +05:30
}
2022-06-14 18:39:47 +05:30
exoPlayer.seekTo(lastPosition)
2022-07-02 22:01:56 +05:30
playerBinding.qualityText.text = videosNameArray[which]
2022-06-14 18:39:47 +05:30
}
2022-06-03 02:15:45 +05:30
val dialog = builder.create()
dialog.show()
}
}
2022-02-13 22:43:26 +05:30
2022-07-14 23:18:00 +05:30
private fun setStreamSource(
streams: Streams,
videosNameArray: Array<CharSequence>,
videosUrlArray: Array<Uri>
) {
2022-07-17 02:19:32 +05:30
if (defRes != "") {
2022-07-14 23:18:00 +05:30
videosNameArray.forEachIndexed { index, pipedStream ->
// search for quality preference in the available stream sources
if (pipedStream.contains(defRes)) {
val videoUri = videosUrlArray[index]
2022-07-24 16:29:15 +05:30
val audioUrl = PlayerHelper.getAudioSource(streams.audioStreams!!)
2022-07-14 23:18:00 +05:30
setMediaSource(videoUri, audioUrl)
playerBinding.qualityText.text = videosNameArray[index]
return
}
}
}
2022-07-14 23:22:27 +05:30
2022-07-14 23:18:00 +05:30
// if default resolution isn't set or available, use hls if available
if (streams.hls != null) {
val mediaItem: MediaItem = MediaItem.Builder()
.setUri(streams.hls)
.setSubtitleConfigurations(subtitle)
.build()
exoPlayer.setMediaItem(mediaItem)
playerBinding.qualityText.text = context?.getString(R.string.hls)
return
}
// if nothing found, use the first list entry
if (videosUrlArray.isNotEmpty()) {
val videoUri = videosUrlArray[0]
2022-07-24 16:29:15 +05:30
val audioUrl = PlayerHelper.getAudioSource(streams.audioStreams!!)
2022-07-14 23:18:00 +05:30
setMediaSource(videoUri, audioUrl)
playerBinding.qualityText.text = videosNameArray[0]
}
}
2022-07-17 16:27:01 +05:30
private fun createExoPlayer() {
2022-06-01 11:32:16 +05:30
val cronetEngine: CronetEngine = CronetHelper.getCronetEngine()
val cronetDataSourceFactory: CronetDataSource.Factory =
CronetDataSource.Factory(cronetEngine, Executors.newCachedThreadPool())
val dataSourceFactory = DefaultDataSource.Factory(
requireContext(),
cronetDataSourceFactory
)
2022-06-03 22:13:15 +05:30
// handles the audio focus
2022-06-01 11:32:16 +05:30
val audioAttributes = AudioAttributes.Builder()
.setUsage(C.USAGE_MEDIA)
.setContentType(C.CONTENT_TYPE_MOVIE)
.build()
2022-06-03 22:13:15 +05:30
// handles the duration of media to retain in the buffer prior to the current playback position (for fast backward seeking)
val loadControl = DefaultLoadControl.Builder()
// cache the last three minutes
.setBackBuffer(1000 * 60 * 3, true)
2022-06-14 23:31:27 +05:30
.setBufferDurationsMs(
2022-06-30 17:08:21 +05:30
1000 * 10, // exo default is 50s
2022-06-18 21:51:30 +05:30
bufferingGoal,
2022-06-14 23:31:27 +05:30
DefaultLoadControl.DEFAULT_BUFFER_FOR_PLAYBACK_MS,
DefaultLoadControl.DEFAULT_BUFFER_FOR_PLAYBACK_AFTER_REBUFFER_MS
)
2022-06-03 22:13:15 +05:30
.build()
// set the subtitle if default subtitle selected
2022-07-17 02:19:32 +05:30
trackSelector = DefaultTrackSelector(requireContext())
if (defaultSubtitle != "") trackSelector.buildUponParameters()
.setPreferredTextLanguage(defaultSubtitle)
2022-07-17 02:19:32 +05:30
2022-07-17 16:27:01 +05:30
exoPlayer = ExoPlayer.Builder(requireContext())
2022-06-01 11:32:16 +05:30
.setMediaSourceFactory(DefaultMediaSourceFactory(dataSourceFactory))
2022-06-03 22:13:15 +05:30
.setLoadControl(loadControl)
2022-07-17 02:19:32 +05:30
.setTrackSelector(trackSelector)
2022-06-01 11:32:16 +05:30
.build()
exoPlayer.setAudioAttributes(audioAttributes, true)
}
2022-06-05 15:12:33 +05:30
private fun initializePlayerNotification(c: Context) {
2022-06-01 11:32:16 +05:30
mediaSession = MediaSessionCompat(c, this.javaClass.name)
2022-06-05 15:12:33 +05:30
mediaSession.apply {
isActive = true
}
2022-06-01 11:32:16 +05:30
mediaSessionConnector = MediaSessionConnector(mediaSession)
mediaSessionConnector.setPlayer(exoPlayer)
2022-06-01 15:33:00 +05:30
playerNotification = PlayerNotificationManager
2022-06-06 20:12:46 +05:30
.Builder(c, 1, "background_mode")
2022-06-14 15:30:58 +05:30
.setMediaDescriptionAdapter(
2022-06-19 01:14:22 +05:30
DescriptionAdapter(title, uploader, thumbnailUrl, requireContext())
2022-06-14 15:30:58 +05:30
)
2022-06-01 12:20:02 +05:30
.build()
2022-06-05 15:12:33 +05:30
playerNotification.apply {
setPlayer(exoPlayer)
setUsePreviousAction(false)
2022-06-30 19:32:55 +05:30
setUseStopAction(true)
2022-06-05 15:12:33 +05:30
setMediaSessionToken(mediaSession.sessionToken)
}
2022-06-01 11:32:16 +05:30
}
2022-07-10 16:31:24 +05:30
// lock the player
2022-06-24 20:56:36 +05:30
private fun lockPlayer(isLocked: Boolean) {
2022-07-18 17:54:08 +05:30
// isLocked is the current (old) state of the player lock
2022-07-03 21:43:52 +05:30
val visibility = if (isLocked) View.VISIBLE else View.GONE
2022-07-09 21:25:59 +05:30
2022-07-02 22:01:56 +05:30
playerBinding.exoTopBarRight.visibility = visibility
playerBinding.exoPlayPause.visibility = visibility
playerBinding.exoBottomBar.visibility = visibility
2022-07-03 21:43:52 +05:30
playerBinding.closeImageButton.visibility = visibility
2022-07-15 01:35:35 +05:30
playerBinding.exoTitle.visibility =
2022-07-17 00:28:28 +05:30
if (isLocked &&
2022-07-18 22:59:56 +05:30
Globals.IS_FULL_SCREEN
2022-07-17 00:28:28 +05:30
) View.VISIBLE else View.INVISIBLE
2022-07-09 21:25:59 +05:30
// disable double tap to seek when the player is locked
2022-07-18 17:54:08 +05:30
if (isLocked) {
// enable fast forward and rewind by double tapping
2022-07-27 12:29:44 +05:30
enableDoubleTapToSeek()
2022-07-18 17:54:08 +05:30
} else {
// disable fast forward and rewind by double tapping
2022-07-27 12:29:44 +05:30
binding.player.setOnDoubleTapListener(null)
2022-07-18 17:54:08 +05:30
}
2022-06-24 20:56:36 +05:30
}
2022-07-27 14:47:05 +05:30
private fun isSubscribed() {
2022-02-13 22:43:26 +05:30
fun run() {
lifecycleScope.launchWhenCreated {
val response = try {
RetrofitInstance.authApi.isSubscribed(
2022-07-27 14:47:05 +05:30
channelId!!,
2022-06-26 14:38:10 +05:30
token
2022-04-15 12:08:53 +05:30
)
} catch (e: IOException) {
2022-02-13 22:43:26 +05:30
println(e)
Log.e(TAG, "IOException, you might not have internet connection")
return@launchWhenCreated
} catch (e: HttpException) {
Log.e(TAG, "HttpException, unexpected response")
return@launchWhenCreated
}
2022-02-13 22:43:26 +05:30
runOnUiThread {
if (response.subscribed == true) {
isSubscribed = true
2022-07-27 14:47:05 +05:30
binding.playerSubscribe.text = getString(R.string.unsubscribe)
2022-02-13 22:43:26 +05:30
}
if (response.subscribed != null) {
2022-07-27 14:47:05 +05:30
binding.playerSubscribe.setOnClickListener {
if (isSubscribed) {
2022-07-27 14:47:05 +05:30
unsubscribe(channelId!!)
binding.playerSubscribe.text = getString(R.string.subscribe)
} else {
2022-07-27 14:47:05 +05:30
subscribe(channelId!!)
binding.playerSubscribe.text = getString(R.string.unsubscribe)
}
2022-04-15 12:08:53 +05:30
}
2022-07-27 14:47:05 +05:30
} else {
Toast.makeText(context, R.string.login_first, Toast.LENGTH_SHORT)
.show()
}
2022-02-13 22:43:26 +05:30
}
}
}
run()
}
2022-07-27 14:47:05 +05:30
private fun subscribe(channelId: String) {
2022-02-13 22:43:26 +05:30
fun run() {
lifecycleScope.launchWhenCreated {
2022-07-12 20:44:10 +05:30
try {
RetrofitInstance.authApi.subscribe(
2022-06-26 14:38:10 +05:30
token,
2022-07-27 14:47:05 +05:30
Subscribe(channelId)
2022-04-15 12:08:53 +05:30
)
} catch (e: IOException) {
2022-02-13 22:43:26 +05:30
println(e)
Log.e(TAG, "IOException, you might not have internet connection")
return@launchWhenCreated
} catch (e: HttpException) {
Log.e(TAG, "HttpException, unexpected response$e")
return@launchWhenCreated
}
isSubscribed = true
2022-02-13 22:43:26 +05:30
}
}
run()
}
2022-04-15 12:08:53 +05:30
private fun unsubscribe(channel_id: String) {
2022-02-13 22:43:26 +05:30
fun run() {
lifecycleScope.launchWhenCreated {
2022-07-12 20:44:10 +05:30
try {
RetrofitInstance.authApi.unsubscribe(
2022-06-26 14:38:10 +05:30
token,
2022-04-15 12:08:53 +05:30
Subscribe(channel_id)
)
} catch (e: IOException) {
2022-02-13 22:43:26 +05:30
println(e)
Log.e(TAG, "IOException, you might not have internet connection")
return@launchWhenCreated
} catch (e: HttpException) {
Log.e(TAG, "HttpException, unexpected response")
return@launchWhenCreated
}
isSubscribed = false
2022-02-13 22:43:26 +05:30
}
}
run()
}
2021-12-18 16:34:14 +05:30
private fun Fragment?.runOnUiThread(action: () -> Unit) {
this ?: return
if (!isAdded) return // Fragment not attached to an Activity
activity?.runOnUiThread(action)
}
2021-12-14 02:58:17 +05:30
2022-05-20 21:15:16 +05:30
private fun fetchComments() {
lifecycleScope.launchWhenCreated {
val commentsResponse = try {
RetrofitInstance.api.getComments(videoId!!)
} catch (e: IOException) {
println(e)
Log.e(TAG, "IOException, you might not have internet connection")
Toast.makeText(context, R.string.unknown_error, Toast.LENGTH_SHORT).show()
return@launchWhenCreated
} catch (e: HttpException) {
Log.e(TAG, "HttpException, unexpected response")
return@launchWhenCreated
}
2022-06-05 19:12:51 +05:30
commentsAdapter = CommentsAdapter(videoId!!, commentsResponse.comments)
2022-07-01 00:55:40 +05:30
binding.commentsRecView.adapter = commentsAdapter
2022-05-20 21:15:16 +05:30
nextPage = commentsResponse.nextpage
commentsLoaded = true
2022-06-03 22:13:15 +05:30
isLoading = false
2022-05-20 21:15:16 +05:30
}
}
2022-05-20 03:52:10 +05:30
private fun fetchNextComments() {
lifecycleScope.launchWhenCreated {
if (!isLoading) {
isLoading = true
val response = try {
RetrofitInstance.api.getCommentsNextPage(videoId!!, nextPage!!)
} catch (e: IOException) {
println(e)
Log.e(TAG, "IOException, you might not have internet connection")
return@launchWhenCreated
} catch (e: HttpException) {
Log.e(TAG, "HttpException, unexpected response," + e.response())
return@launchWhenCreated
}
2022-05-20 03:52:10 +05:30
nextPage = response.nextpage
2022-05-21 13:32:04 +05:30
commentsAdapter?.updateItems(response.comments)
2022-05-20 03:52:10 +05:30
isLoading = false
}
2022-05-20 03:52:10 +05:30
}
}
override fun onPictureInPictureModeChanged(isInPictureInPictureMode: Boolean) {
super.onPictureInPictureModeChanged(isInPictureInPictureMode)
if (isInPictureInPictureMode) {
2022-07-09 21:25:59 +05:30
// hide and disable exoPlayer controls
exoPlayerView.hideController()
2022-06-19 17:09:41 +05:30
exoPlayerView.useController = false
2022-07-09 21:25:59 +05:30
2022-07-17 00:28:28 +05:30
// set portrait mode
2022-07-14 19:27:20 +05:30
unsetFullscreen()
2022-07-05 00:49:16 +05:30
2022-07-17 15:49:55 +05:30
with(binding.playerMotionLayout) {
getConstraintSet(R.id.start).constrainHeight(R.id.player, -1)
enableTransition(R.id.yt_transition, false)
}
binding.linLayout.visibility = View.GONE
2022-07-18 22:59:56 +05:30
Globals.IS_FULL_SCREEN = false
} else {
2022-07-09 21:25:59 +05:30
// enable exoPlayer controls again
2022-06-19 17:09:41 +05:30
exoPlayerView.useController = true
2022-07-17 15:49:55 +05:30
with(binding.playerMotionLayout) {
getConstraintSet(R.id.start).constrainHeight(R.id.player, 0)
enableTransition(R.id.yt_transition, true)
}
binding.linLayout.visibility = View.VISIBLE
}
}
fun onUserLeaveHint() {
2022-07-26 11:25:07 +05:30
if (SDK_INT >= Build.VERSION_CODES.O && shouldStartPiP()) {
activity?.enterPictureInPictureMode(updatePipParams())
}
}
private fun shouldStartPiP(): Boolean {
val bounds = Rect()
2022-07-01 00:55:40 +05:30
binding.playerScrollView.getHitRect(bounds)
2022-07-26 11:25:07 +05:30
val backgroundModeRunning = isServiceRunning(requireContext(), BackgroundMode::class.java)
return (binding.playerScrollView.getLocalVisibleRect(bounds) || Globals.IS_FULL_SCREEN) &&
(exoPlayer.isPlaying || !backgroundModeRunning)
}
private fun isServiceRunning(context: Context, serviceClass: Class<*>): Boolean {
val manager = context.getSystemService(Context.ACTIVITY_SERVICE) as ActivityManager
for (service in manager.getRunningServices(Int.MAX_VALUE)) {
if (serviceClass.name == service.service.className) {
return true
}
2022-05-20 03:52:10 +05:30
}
2022-07-26 11:25:07 +05:30
return false
2021-12-14 21:45:53 +05:30
}
2022-06-26 21:19:42 +05:30
private fun updatePipParams() = PictureInPictureParams.Builder()
.setActions(emptyList())
.build()
2022-07-14 15:45:58 +05:30
override fun onConfigurationChanged(newConfig: Configuration) {
super.onConfigurationChanged(newConfig)
2022-07-14 19:27:20 +05:30
if (autoRotationEnabled) {
val orientation = newConfig.orientation
if (orientation == Configuration.ORIENTATION_LANDSCAPE) {
// go to fullscreen mode
setFullscreen()
} else {
// exit fullscreen if not landscape
unsetFullscreen()
}
2022-07-14 15:45:58 +05:30
}
}
}