-
Notifications
You must be signed in to change notification settings - Fork 36
/
PlayerUI.kt
283 lines (235 loc) · 9.1 KB
/
PlayerUI.kt
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
package com.bitmovin.player.samples.custom.ui
import android.annotation.SuppressLint
import android.content.Context
import android.graphics.drawable.Drawable
import android.view.LayoutInflater
import android.view.MotionEvent
import android.view.View
import android.view.View.OnClickListener
import android.view.View.OnTouchListener
import android.view.ViewGroup
import android.widget.RelativeLayout
import android.widget.SeekBar
import androidx.core.content.ContextCompat
import com.bitmovin.analytics.api.AnalyticsConfig
import com.bitmovin.player.PlayerView
import com.bitmovin.player.api.Player
import com.bitmovin.player.api.PlayerConfig
import com.bitmovin.player.api.analytics.AnalyticsPlayerConfig
import com.bitmovin.player.api.event.*
import com.bitmovin.player.api.source.Source
import com.bitmovin.player.api.ui.FullscreenHandler
import com.bitmovin.player.api.ui.PlayerViewConfig
import com.bitmovin.player.api.ui.UiConfig
import com.bitmovin.player.samples.custom.ui.databinding.PlayerUiBinding
import java.util.*
private const val LIVE = "Live"
private const val UI_HIDE_TIMER = 5000
class PlayerUI(
context: Context,
playerConfig: PlayerConfig
) : RelativeLayout(context) {
// Create new Player with our PlayerConfig
private val analyticsKey = "{ANALYTICS_LICENSE_KEY}"
private val player = Player(
context,
playerConfig,
AnalyticsPlayerConfig.Enabled(AnalyticsConfig(analyticsKey))
)
private var binding: PlayerUiBinding = PlayerUiBinding.inflate(
LayoutInflater.from(context), this, true
)
/**
* Create a new PlayerViewConfig with a disabled UI
*/
private val viewConfig = PlayerViewConfig(uiConfig = UiConfig.Disabled)
// Create new PlayerView with our Player
private val playerView: PlayerView = PlayerView(context, player, viewConfig).apply {
layoutParams = ViewGroup.LayoutParams(
ViewGroup.LayoutParams.MATCH_PARENT,
ViewGroup.LayoutParams.MATCH_PARENT
)
keepScreenOn = true
}
private var playDrawable: Drawable? = null
private var pauseDrawable: Drawable? = null
private var lastUiInteraction: Long = 0
private var uiHideTimer: Timer = Timer()
private var uiHideTask: TimerTask? = null
private var live: Boolean = false
private val seekBarChangeListener = object : SeekBar.OnSeekBarChangeListener {
override fun onProgressChanged(seekBar: SeekBar, progress: Int, fromUser: Boolean) {
// Only seek/timeShift when the user changes the progress (and not the PlayerEvent.TimeChanged )
if (fromUser) player.seekOrTimeShift(progress, seekBar)
}
override fun onStartTrackingTouch(seekBar: SeekBar) {}
override fun onStopTrackingTouch(seekBar: SeekBar) {}
}
private val onClickListener = OnClickListener { view ->
when {
view === binding.playButton || view === this@PlayerUI -> player.togglePlayback()
(view === binding.fullscreenButton) -> playerView.toggleFullscreen()
}
}
@SuppressLint("ClickableViewAccessibility")
private val onTouchListener = OnTouchListener { _, event ->
lastUiInteraction = System.currentTimeMillis()
if (event.action == MotionEvent.ACTION_UP) {
// Start the hider task, when the UI is not touched
startUiHiderTask()
} else {
// When the view is touched, the UI should be visible
setControlsVisible(true)
}
false
}
init {
playDrawable = ContextCompat.getDrawable(context, R.drawable.ic_play_arrow_black_24dp)
pauseDrawable = ContextCompat.getDrawable(context, R.drawable.ic_pause_black_24dp)
binding.apply {
seekbar.setOnSeekBarChangeListener(seekBarChangeListener)
playButton.setOnClickListener(onClickListener)
fullscreenButton.setOnClickListener(onClickListener)
playButton.setOnTouchListener(onTouchListener)
seekbar.setOnTouchListener(onTouchListener)
}
setOnTouchListener(onTouchListener)
// Add PlayerView to the layout
addView(playerView, 0)
addPlayerListener()
updateUi()
}
fun load(source: Source) {
source.next<SourceEvent.Loaded>(::updateUi)
player.load(source)
}
private fun addPlayerListener() {
player.on<PlayerEvent.TimeChanged>(::updateUi)
player.on<PlayerEvent.Play>(::updateUi)
player.on<PlayerEvent.Paused>(::updateUi)
player.on<PlayerEvent.StallEnded>(::updateUi)
player.on<PlayerEvent.Seeked>(::updateUi)
player.on<PlayerEvent.PlaybackFinished>(::updateUi)
}
private fun removePlayerListener() {
player.off(::updateUi)
}
private fun startUiHiderTask() {
stopUiHiderTask()
// Create Task which hides the UI after a specified time (UiHideTimer)
uiHideTask = object : TimerTask() {
override fun run() {
val timeSincelastUiInteraction = System.currentTimeMillis() - lastUiInteraction
if (timeSincelastUiInteraction > UI_HIDE_TIMER) {
setControlsVisible(false)
}
}
}
// Schedule the hider task, so it checks the state every 100ms
uiHideTimer.scheduleAtFixedRate(uiHideTask, 0, 100)
}
private fun stopUiHiderTask() {
uiHideTask?.cancel()
uiHideTask = null
}
fun setVisible(visible: Boolean) {
lastUiInteraction = System.currentTimeMillis()
setControlsVisible(visible)
}
private fun setControlsVisible(visible: Boolean) {
post {
if (visible) {
startUiHiderTask()
} else {
stopUiHiderTask()
}
val visibility = if (visible) View.VISIBLE else View.INVISIBLE
binding.controlView.visibility = visibility
}
}
fun setFullscreenHandler(fullscreenHandler: FullscreenHandler) {
playerView.setFullscreenHandler(fullscreenHandler)
}
fun onStart() = playerView.onStart()
fun onResume() = playerView.onResume()
fun onPause() = playerView.onPause()
fun onStop() = playerView.onStop()
fun onDestroy() {
playerView.onDestroy()
destroy()
}
private fun destroy() {
player.source?.off(::updateUi)
removePlayerListener()
uiHideTimer.cancel()
}
/**
* UI Listeners
*/
override fun onTouchEvent(event: MotionEvent): Boolean = true
/**
* Methods for UI update
*/
private fun updateUi(event: Event? = null) {
binding.seekbar.post {
// if the live state of the player changed, the UI should change it's mode
val positionMs: Int
val durationMs: Int
if (live != player.isLive) {
live = player.isLive
if (live) {
binding.positionView.visibility = View.GONE
binding.durationView.text = LIVE
} else {
binding.positionView.visibility = View.VISIBLE
}
}
if (live) {
// The Seekbar does not support negative values
// so the seekable range is shifted to the positive
durationMs = (-player.maxTimeShift * 1000).toInt()
positionMs = (durationMs + player.timeShift * 1000).toInt()
} else {
// Converting to milliseconds
positionMs = (player.currentTime * 1000).toInt()
durationMs = (player.duration * 1000).toInt()
// Update the TextViews displaying the current position and duration
binding.positionView.text = millisecondsToTimeString(positionMs)
binding.durationView.text = millisecondsToTimeString(durationMs)
}
// Update the values of the Seekbar
binding.seekbar.progress = positionMs
binding.seekbar.max = durationMs
// Update the image of the playback button
if (player.isPlaying) {
binding.playButton.setImageDrawable(pauseDrawable)
} else {
binding.playButton.setImageDrawable(playDrawable)
}
}
}
private fun millisecondsToTimeString(milliseconds: Int): String {
val second = milliseconds / 1000 % 60
val minute = milliseconds / (1000 * 60) % 60
val hour = milliseconds / (1000 * 60 * 60) % 24
return if (hour > 0) {
String.format("%02d:%02d:%02d", hour, minute, second)
} else {
String.format("%02d:%02d", minute, second)
}
}
}
private fun Player.togglePlayback() = if (isPlaying) pause() else play()
private fun PlayerView.toggleFullscreen() = if (isFullscreen) {
exitFullscreen()
} else {
enterFullscreen()
}
// If the current stream is a live stream, we have to use the timeShift method
private fun Player.seekOrTimeShift(progress: Int, seekBar: SeekBar) {
if (!isLive) {
seek(progress / 1000.0)
} else {
timeShift((progress - seekBar.max) / 1000.0)
}
}