Initial video support in playback rewrite

app/src/main/java/org/jellyfin/androidtv/ui/playback/PlaybackLauncher.kt

@@ -51,7 +51,7 @@ class RewritePlaybackLauncher : PlaybackLauncher {
 		if (item == null) return false
 
 		val intent = Intent(context, PlaybackForwardingActivity::class.java)
-		intent.putExtra(PlaybackForwardingActivity.EXTRA_ITEM_ID, item.id)
+		intent.putExtra(PlaybackForwardingActivity.EXTRA_ITEM_ID, item.id.toString())
 		context.startActivity(intent)
 
 		return true

app/src/main/java/org/jellyfin/androidtv/ui/playback/rewrite/PlaybackForwardingActivity.kt

@@ -2,26 +2,33 @@
 
 import android.os.Bundle
 import android.widget.Toast
-import androidx.fragment.app.FragmentActivity
+import androidx.activity.ComponentActivity
 import androidx.lifecycle.Lifecycle
 import androidx.lifecycle.lifecycleScope
 import androidx.lifecycle.repeatOnLifecycle
 import kotlinx.coroutines.launch
 import org.jellyfin.androidtv.ui.playback.VideoQueueManager
+import org.jellyfin.playback.core.PlaybackManager
+import org.jellyfin.playback.core.queue.Queue
+import org.jellyfin.playback.core.queue.QueueEntry
+import org.jellyfin.playback.core.ui.PlayerSurfaceView
+import org.jellyfin.playback.jellyfin.queue.createBaseItemQueueEntry
 import org.jellyfin.sdk.api.client.ApiClient
 import org.jellyfin.sdk.api.client.extensions.userLibraryApi
+import org.jellyfin.sdk.model.api.BaseItemDto
 import org.jellyfin.sdk.model.api.BaseItemKind
 import org.jellyfin.sdk.model.serializer.toUUIDOrNull
 import org.koin.android.ext.android.inject
 import timber.log.Timber
 import java.util.UUID
 
-class PlaybackForwardingActivity : FragmentActivity() {
+class PlaybackForwardingActivity : ComponentActivity() {
 	companion object {
 		const val EXTRA_ITEM_ID: String = "item_id"
 	}
 
 	private val videoQueueManager by inject<VideoQueueManager>()
+	private val playbackManager by inject<PlaybackManager>()
 	private val api by inject<ApiClient>()
 
 	override fun onCreate(savedInstanceState: Bundle?) {
@@ -53,17 +60,30 @@
 				).show()
 				Timber.i(item.toString())
 
-				// TODO: Create queue, send to new playback manager, start new player UI
-				finishAfterTransition()
+				// TODO: Dirty hack to create a single item queue
+				val queueEntry = createBaseItemQueueEntry(api, item)
+				playbackManager.state.queue.replaceQueue(object : Queue {
+					override val size: Int = 1
+
+					override suspend fun getItem(index: Int): QueueEntry? {
+						if (index == 0) return queueEntry
+						return null
+					}
+				})
 			}
 		}
+
+		// TODO: Dirty hack to display surface
+		val view = PlayerSurfaceView(this)
+		view.playbackManager = playbackManager
+		setContentView(view)
 	}
 
 	private fun findItemId(): UUID? {
 		val extra = intent.getStringExtra(EXTRA_ITEM_ID)?.toUUIDOrNull()
 
-		var first: org.jellyfin.sdk.model.api.BaseItemDto? = null
-		var best: org.jellyfin.sdk.model.api.BaseItemDto? = null
+		var first: BaseItemDto? = null
+		var best: BaseItemDto? = null
 
 		for (item in videoQueueManager.getCurrentVideoQueue()) {
 			if (first == null) first = item

playback/core/src/main/kotlin/PlaybackManager.kt

@@ -18,7 +18,7 @@ class PlaybackManager internal constructor(
 	val options: PlaybackManagerOptions,
 	parentJob: Job? = null,
 ) {
-	private val backendService = BackendService().also { service ->
+	internal val backendService = BackendService().also { service ->
 		service.switchBackend(backend)
 	}
 

playback/core/src/main/kotlin/backend/BackendService.kt

@@ -1,26 +1,51 @@
 package org.jellyfin.playback.core.backend
 
+import android.view.SurfaceView
+import androidx.core.view.doOnDetach
 import org.jellyfin.playback.core.mediastream.PlayableMediaStream
 import org.jellyfin.playback.core.model.PlayState
 
 /**
- * Service keeping track of the current playback backend.
+ * Service keeping track of the current playback backend and its related surface view.
  */
 class BackendService {
 	private var _backend: PlayerBackend? = null
 	val backend get() = _backend
 
 	private var listeners = mutableListOf<PlayerBackendEventListener>()
+	private var _surfaceView: SurfaceView? = null
 
 	fun switchBackend(backend: PlayerBackend) {
 		_backend?.stop()
 		_backend?.setListener(null)
+		_backend?.setSurface(null)
 
 		_backend = backend.apply {
+			_surfaceView?.let(::setSurface)
 			setListener(BackendEventListener())
 		}
 	}
 
+	fun attachSurfaceView(surfaceView: SurfaceView) {
+		// Remove existing surface view
+		if (_surfaceView != null) {
+			_backend?.setSurface(null)
+		}
+
+		// Apply new surface view
+		_surfaceView = surfaceView.apply {
+			_backend?.setSurface(surfaceView)
+
+			// Automatically detach
+			doOnDetach {
+				if (surfaceView == _surfaceView) {
+					_surfaceView = null
+					_backend?.setSurface(null)
+				}
+			}
+		}
+	}
+
 	fun addListener(listener: PlayerBackendEventListener) {
 		listeners.add(listener)
 	}

playback/core/src/main/kotlin/backend/PlayerBackend.kt

@@ -1,5 +1,6 @@
 package org.jellyfin.playback.core.backend
 
+import android.view.SurfaceView
 import org.jellyfin.playback.core.mediastream.MediaStream
 import org.jellyfin.playback.core.mediastream.PlayableMediaStream
 import org.jellyfin.playback.core.model.PositionInfo
@@ -14,6 +15,9 @@ interface PlayerBackend {
 	// Testing
 	fun supportsStream(stream: MediaStream): PlaySupportReport
 
+	// UI
+	fun setSurface(surfaceView: SurfaceView?)
+
 	// Data retrieval
 
 	fun setListener(eventListener: PlayerBackendEventListener?)

playback/core/src/main/kotlin/ui/PlayerSurfaceView.kt

@@ -0,0 +1,34 @@
+package org.jellyfin.playback.core.ui
+
+import android.content.Context
+import android.util.AttributeSet
+import android.view.SurfaceView
+import android.view.ViewGroup
+import android.widget.FrameLayout
+import org.jellyfin.playback.core.PlaybackManager
+
+/**
+ * A view that is used to display the video output of the playing media.
+ * The [playbackManager] must be set when the view is initialized.
+ */
+class PlayerSurfaceView @JvmOverloads constructor(
+	context: Context,
+	attrs: AttributeSet? = null,
+	defStyleAttr: Int = 0,
+	defStyleRes: Int = 0,
+) : FrameLayout(context, attrs, defStyleAttr, defStyleRes) {
+	lateinit var playbackManager: PlaybackManager
+
+	val surface = SurfaceView(context, attrs).apply {
+		addView(this, ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT)
+	}
+
+	override fun onAttachedToWindow() {
+		super.onAttachedToWindow()
+
+		if (!isInEditMode) {
+			playbackManager.backendService.attachSurfaceView(surface)
+		}
+	}
+}
+

playback/exoplayer/build.gradle.kts

@@ -34,6 +34,7 @@ dependencies {
 
 	// ExoPlayer
 	implementation(libs.androidx.media3.exoplayer)
+	implementation(libs.androidx.media3.exoplayer.hls)
 	implementation(libs.jellyfin.androidx.media3.ffmpeg.decoder)
 
 	// Logging

playback/exoplayer/src/main/kotlin/ExoPlayerBackend.kt

@@ -2,6 +2,7 @@ package org.jellyfin.playback.exoplayer
 
 import android.app.ActivityManager
 import android.content.Context
+import android.view.SurfaceView
 import androidx.annotation.OptIn
 import androidx.core.content.getSystemService
 import androidx.media3.common.C
@@ -103,6 +104,10 @@ class ExoPlayerBackend(
 		stream: MediaStream
 	): PlaySupportReport = exoPlayer.getPlaySupportReport(stream.toFormat())
 
+	override fun setSurface(surfaceView: SurfaceView?) {
+		exoPlayer.setVideoSurfaceView(surfaceView)
+	}
+
 	override fun prepareStream(stream: PlayableMediaStream) {
 		val mediaItem = MediaItem.Builder().apply {
 			setTag(stream)

playback/jellyfin/src/main/kotlin/JellyfinPlugin.kt

@@ -2,6 +2,7 @@ package org.jellyfin.playback.jellyfin
 
 import org.jellyfin.playback.core.plugin.playbackPlugin
 import org.jellyfin.playback.jellyfin.mediastream.AudioMediaStreamResolver
+import org.jellyfin.playback.jellyfin.mediastream.VideoMediaStreamResolver
 import org.jellyfin.playback.jellyfin.playsession.PlaySessionService
 import org.jellyfin.playback.jellyfin.playsession.PlaySessionSocketService
 import org.jellyfin.sdk.api.client.ApiClient
@@ -40,6 +41,7 @@ fun jellyfinPlugin(
 		xmlRootAttributes = emptyList(),
 	)
 	provide(AudioMediaStreamResolver(api, profile))
+	provide(VideoMediaStreamResolver(api, profile))
 
 	val playSessionService = PlaySessionService(api)
 	provide(playSessionService)

playback/jellyfin/src/main/kotlin/mediastream/AudioMediaStreamResolver.kt

@@ -11,8 +11,8 @@ import org.jellyfin.playback.jellyfin.queue.baseItem
 import org.jellyfin.sdk.api.client.ApiClient
 import org.jellyfin.sdk.api.client.extensions.audioApi
 import org.jellyfin.sdk.api.client.extensions.dynamicHlsApi
-import org.jellyfin.sdk.model.api.BaseItemKind
 import org.jellyfin.sdk.model.api.DeviceProfile
+import org.jellyfin.sdk.model.constant.MediaType
 
 class AudioMediaStreamResolver(
 	val api: ApiClient,
@@ -42,7 +42,7 @@ class AudioMediaStreamResolver(
 	private fun MediaInfo.getTranscodeStream() = BasicMediaStream(
 		identifier = playSessionId,
 		conversionMethod = MediaConversionMethod.Transcode,
-		// The server doesn't provide us with the transcode information os we return mock data
+		// The server doesn't provide us with the transcode information so we return mock data
 		container = MediaStreamContainer(format = "unknown"),
 		tracks = emptyList()
 	)
@@ -52,7 +52,7 @@ class AudioMediaStreamResolver(
 		testStream: (stream: MediaStream) -> PlaySupportReport,
 	): PlayableMediaStream? {
 		val baseItem = queueEntry.baseItem
-		if (baseItem == null || baseItem.type != BaseItemKind.AUDIO) return null
+		if (baseItem == null || baseItem.mediaType != MediaType.Audio) return null
 
 		val mediaInfo = getPlaybackInfo(baseItem)
 

playback/jellyfin/src/main/kotlin/mediastream/VideoMediaStreamResolver.kt

@@ -0,0 +1,111 @@
+package org.jellyfin.playback.jellyfin.mediastream
+
+import org.jellyfin.playback.core.mediastream.BasicMediaStream
+import org.jellyfin.playback.core.mediastream.MediaConversionMethod
+import org.jellyfin.playback.core.mediastream.MediaStream
+import org.jellyfin.playback.core.mediastream.MediaStreamContainer
+import org.jellyfin.playback.core.mediastream.PlayableMediaStream
+import org.jellyfin.playback.core.queue.QueueEntry
+import org.jellyfin.playback.core.support.PlaySupportReport
+import org.jellyfin.playback.jellyfin.queue.baseItem
+import org.jellyfin.sdk.api.client.ApiClient
+import org.jellyfin.sdk.api.client.extensions.dynamicHlsApi
+import org.jellyfin.sdk.api.client.extensions.videosApi
+import org.jellyfin.sdk.model.api.DeviceProfile
+import org.jellyfin.sdk.model.constant.MediaType
+
+class VideoMediaStreamResolver(
+	val api: ApiClient,
+	val profile: DeviceProfile,
+) : JellyfinStreamResolver(api, profile) {
+	companion object {
+		private val REMUX_CONTAINERS = arrayOf("mp4", "mkv")
+		private const val REMUX_SEGMENT_CONTAINER = "mp4"
+	}
+
+	private fun MediaInfo.getDirectPlayStream() = BasicMediaStream(
+		identifier = playSessionId,
+		conversionMethod = MediaConversionMethod.None,
+		container = getMediaStreamContainer(),
+		tracks = getTracks()
+	)
+
+	private fun MediaInfo.getRemuxStream(container: String) = BasicMediaStream(
+		identifier = playSessionId,
+		conversionMethod = MediaConversionMethod.Remux,
+		container = MediaStreamContainer(
+			format = container
+		),
+		tracks = getTracks()
+	)
+
+	private fun MediaInfo.getTranscodeStream() = BasicMediaStream(
+		identifier = playSessionId,
+		conversionMethod = MediaConversionMethod.Transcode,
+		// The server doesn't provide us with the transcode information so we return mock data
+		container = MediaStreamContainer(format = "unknown"),
+		tracks = emptyList()
+	)
+
+	override suspend fun getStream(
+		queueEntry: QueueEntry,
+		testStream: (stream: MediaStream) -> PlaySupportReport,
+	): PlayableMediaStream? {
+		val baseItem = queueEntry.baseItem
+		if (baseItem == null || baseItem.mediaType != MediaType.Video) return null
+
+		val mediaInfo = getPlaybackInfo(baseItem)
+
+		// Test for direct play support
+		val directPlayStream = mediaInfo.getDirectPlayStream()
+		if (testStream(directPlayStream).canPlay) {
+			return directPlayStream.toPlayableMediaStream(
+				queueEntry = queueEntry,
+				url = api.videosApi.getVideoStreamUrl(
+					itemId = baseItem.id,
+					mediaSourceId = mediaInfo.mediaSource.id,
+					playSessionId = mediaInfo.playSessionId,
+					static = true,
+				)
+			)
+		}
+
+		// Try remuxing
+		if (mediaInfo.mediaSource.supportsDirectStream) {
+			for (container in REMUX_CONTAINERS) {
+				val remuxStream = mediaInfo.getRemuxStream(container)
+				if (testStream(remuxStream).canPlay) {
+					return remuxStream.toPlayableMediaStream(
+						queueEntry = queueEntry,
+						url = api.videosApi.getVideoStreamByContainerUrl(
+							itemId = baseItem.id,
+							mediaSourceId = mediaInfo.mediaSource.id,
+							playSessionId = mediaInfo.playSessionId,
+							container = container,
+						)
+					)
+				}
+			}
+		}
+
+		// Fallback to provided transcode
+		if (mediaInfo.mediaSource.supportsTranscoding) {
+			val transcodeStream = mediaInfo.getTranscodeStream()
+
+			// Skip testing transcode stream because we lack the information to do so
+			return transcodeStream.toPlayableMediaStream(
+				queueEntry = queueEntry,
+				url = api.dynamicHlsApi.getMasterHlsVideoPlaylistUrl(
+					itemId = baseItem.id,
+					mediaSourceId = requireNotNull(mediaInfo.mediaSource.id),
+					playSessionId = mediaInfo.playSessionId,
+					tag = mediaInfo.mediaSource.eTag,
+					segmentContainer = REMUX_SEGMENT_CONTAINER,
+				)
+			)
+		}
+
+		// Unable to find a suitable stream, return
+		return null
+	}
+}