Add new experimental picture viewer

app/src/main/AndroidManifest.xml

@@ -179,6 +179,8 @@
             android:name=".ui.itemdetail.PhotoPlayerActivity"
             android:screenOrientation="landscape" />
 
+        <activity android:name=".ui.picture.PictureViewerActivity" />
+
         <activity
             android:name=".ui.itemdetail.ItemListActivity"
             android:screenOrientation="landscape" />

app/src/main/java/org/jellyfin/androidtv/di/AppModule.kt

@@ -10,6 +10,7 @@ import org.jellyfin.androidtv.data.repository.NotificationsRepositoryImpl
 import org.jellyfin.androidtv.data.repository.UserViewsRepository
 import org.jellyfin.androidtv.data.repository.UserViewsRepositoryImpl
 import org.jellyfin.androidtv.data.service.BackgroundService
+import org.jellyfin.androidtv.ui.picture.PictureViewerViewModel
 import org.jellyfin.androidtv.ui.playback.MediaManager
 import org.jellyfin.androidtv.ui.playback.PlaybackControllerContainer
 import org.jellyfin.androidtv.ui.playback.nextup.NextUpViewModel
@@ -89,6 +90,7 @@ val appModule = module {
 	viewModel { UserLoginViewModel(get(), get(), get()) }
 	viewModel { ServerAddViewModel(get()) }
 	viewModel { NextUpViewModel(get(), get(), get(), get()) }
+	viewModel { PictureViewerViewModel(get()) }
 
 	single { BackgroundService(get(), get(), get(), get()) }
 

app/src/main/java/org/jellyfin/androidtv/preference/UserPreferences.kt

@@ -163,6 +163,11 @@ class UserPreferences(context: Context) : SharedPreferenceStore(
 		 */
 		var playbackRewriteEnabled = booleanPreference("playback_new", false)
 
+		/**
+		 * Use PictureViewer rewrite
+		 */
+		var pictureViewerRewriteEnabled = booleanPreference("picture_viewer_new", false)
+
 		/**
 		 * When to show the clock.
 		 */

app/src/main/java/org/jellyfin/androidtv/ui/itemdetail/PhotoPlayerActivity.java

@@ -3,6 +3,7 @@
 import static org.koin.java.KoinJavaComponent.inject;
 
 import android.animation.Animator;
+import android.content.Intent;
 import android.graphics.drawable.Drawable;
 import android.os.Bundle;
 import android.os.Handler;
@@ -34,7 +35,9 @@
 
 import org.jellyfin.androidtv.R;
 import org.jellyfin.androidtv.databinding.ActivityPhotoPlayerBinding;
+import org.jellyfin.androidtv.preference.UserPreferences;
 import org.jellyfin.androidtv.ui.itemhandling.BaseRowItem;
+import org.jellyfin.androidtv.ui.picture.PictureViewerActivity;
 import org.jellyfin.androidtv.ui.playback.MediaManager;
 import org.jellyfin.androidtv.ui.presentation.PositionableListRowPresenter;
 import org.jellyfin.androidtv.util.ImageHelper;
@@ -71,11 +74,20 @@ public class PhotoPlayerActivity extends FragmentActivity {
     Handler handler;
     private Lazy<ImageHelper> imageHelper = inject(ImageHelper.class);
     private Lazy<MediaManager> mediaManager = inject(MediaManager.class);
+    private Lazy<UserPreferences> userPreferences = inject(UserPreferences.class);
 
     @Override
     public void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
 
+        boolean pictureViewerRewriteEnabled = userPreferences.getValue().get(UserPreferences.Companion.getPictureViewerRewriteEnabled());
+        if (pictureViewerRewriteEnabled) {
+            Intent intent = PictureViewerActivity.Companion.createIntent(this, ModelCompat.asSdk(mediaManager.getValue().getCurrentMediaItem().getBaseItem()), getIntent().getBooleanExtra("Play", false));
+            startActivity(intent);
+            finishAfterTransition();
+            return;
+        }
+
         ActivityPhotoPlayerBinding binding = ActivityPhotoPlayerBinding.inflate(getLayoutInflater());
         setContentView(binding.getRoot());
 

app/src/main/java/org/jellyfin/androidtv/ui/picture/PictureViewerActivity.kt

@@ -0,0 +1,65 @@
+package org.jellyfin.androidtv.ui.picture
+
+import android.content.Context
+import android.content.Intent
+import android.os.Bundle
+import android.view.KeyEvent
+import android.view.View
+import androidx.fragment.app.FragmentActivity
+import androidx.fragment.app.add
+import androidx.fragment.app.commit
+import androidx.lifecycle.lifecycleScope
+import kotlinx.coroutines.launch
+import org.jellyfin.androidtv.R
+import org.jellyfin.sdk.model.api.BaseItemDto
+import org.jellyfin.sdk.model.api.BaseItemKind
+import org.jellyfin.sdk.model.serializer.toUUIDOrNull
+import org.koin.androidx.viewmodel.ext.android.viewModel
+
+class PictureViewerActivity : FragmentActivity(R.layout.fragment_content_view) {
+	companion object {
+		const val EXTRA_ITEM_ID = "item_id"
+		const val EXTRA_AUTO_PLAY = "auto_play"
+
+		fun createIntent(context: Context, item: BaseItemDto, autoPlay: Boolean): Intent {
+			require(item.type == BaseItemKind.PHOTO) { "Expected item of type PHOTO but got ${item.type}" }
+
+			return Intent(context, PictureViewerActivity::class.java).apply {
+				putExtra(EXTRA_ITEM_ID, item.id.toString())
+				putExtra(EXTRA_AUTO_PLAY, autoPlay)
+			}
+		}
+	}
+
+	private val pictureViewerViewModel by viewModel<PictureViewerViewModel>()
+
+	override fun onCreate(savedInstanceState: Bundle?) {
+		super.onCreate(savedInstanceState)
+
+		// Load requested item in viewmodel
+		lifecycleScope.launch {
+			val itemId = requireNotNull(intent.extras?.getString(EXTRA_ITEM_ID)?.toUUIDOrNull())
+			pictureViewerViewModel.loadItem(itemId)
+
+			val autoPlay = intent.extras?.getBoolean(EXTRA_AUTO_PLAY) == true
+			if (autoPlay) pictureViewerViewModel.startPresentation()
+		}
+
+		// Show fragment
+		supportFragmentManager.commit {
+			add<PictureViewerFragment>(R.id.content_view)
+		}
+	}
+
+	// Forward key events to fragments
+	private fun onKeyEvent(keyCode: Int, event: KeyEvent?): Boolean = supportFragmentManager.fragments
+		.filter { it.isVisible }
+		.filterIsInstance<View.OnKeyListener>()
+		.any { it.onKey(currentFocus, keyCode, event) }
+
+	override fun onKeyDown(keyCode: Int, event: KeyEvent?): Boolean =
+		onKeyEvent(keyCode, event) || super.onKeyDown(keyCode, event)
+
+	override fun onKeyUp(keyCode: Int, event: KeyEvent?): Boolean =
+		onKeyEvent(keyCode, event) || super.onKeyUp(keyCode, event)
+}

app/src/main/java/org/jellyfin/androidtv/ui/picture/PictureViewerFragment.kt

@@ -0,0 +1,159 @@
+package org.jellyfin.androidtv.ui.picture
+
+import android.os.Bundle
+import android.view.KeyEvent
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import android.view.animation.Animation
+import android.view.animation.AnimationUtils
+import androidx.core.view.isGone
+import androidx.core.view.isVisible
+import androidx.fragment.app.Fragment
+import androidx.lifecycle.lifecycleScope
+import kotlinx.coroutines.flow.filterNotNull
+import kotlinx.coroutines.launch
+import org.jellyfin.androidtv.R
+import org.jellyfin.androidtv.databinding.FragmentPictureViewerBinding
+import org.jellyfin.androidtv.ui.AsyncImageView
+import org.jellyfin.androidtv.util.createKeyHandler
+import org.jellyfin.sdk.api.client.ApiClient
+import org.jellyfin.sdk.api.client.extensions.imageApi
+import org.jellyfin.sdk.api.client.extensions.libraryApi
+import org.jellyfin.sdk.model.api.BaseItemDto
+import org.jellyfin.sdk.model.api.ImageType
+import org.koin.android.ext.android.inject
+import org.koin.androidx.viewmodel.ext.android.sharedViewModel
+
+class PictureViewerFragment : Fragment(), View.OnKeyListener {
+	companion object {
+		/**
+		 * The download API is used by jellyfin-web when loading images. Unfortunately with our
+		 * current code it doesn't work for the app. Larger files (gifs, large photos etc.) can
+		 * cause the app to go out of memory. This is mostly caught by Glide but it ends up
+		 * never displaying the picture in those cases.
+		 *
+		 * This toggle is left in the code in case we migrate to a different image processor that
+		 * potentially fixes the issue.
+		 */
+		const val USE_DOWNLOAD_API = false
+	}
+
+	private val pictureViewerViewModel by sharedViewModel<PictureViewerViewModel>()
+	private val api by inject<ApiClient>()
+	private lateinit var binding: FragmentPictureViewerBinding
+
+	override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View {
+		binding = FragmentPictureViewerBinding.inflate(inflater, container, false)
+		binding.actionPrevious.setOnClickListener { pictureViewerViewModel.showPrevious() }
+		binding.actionNext.setOnClickListener { pictureViewerViewModel.showNext() }
+		binding.actionPlayPause.setOnClickListener { pictureViewerViewModel.togglePresentation() }
+		binding.root.setOnClickListener { toggleActions() }
+		return binding.root
+	}
+
+	override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
+		super.onViewCreated(view, savedInstanceState)
+
+		lifecycleScope.launch {
+			pictureViewerViewModel.currentItem.filterNotNull().collect { item ->
+				binding.itemSwitcher.getNextView<AsyncImageView>().load(item)
+				binding.itemSwitcher.showNextView()
+			}
+		}
+
+		lifecycleScope.launch {
+			pictureViewerViewModel.presentationActive.collect { active ->
+				binding.actionPlayPause.isActivated = active
+			}
+		}
+	}
+
+	private val keyHandler = createKeyHandler {
+		keyDown(KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE, KeyEvent.KEYCODE_MEDIA_PLAY, KeyEvent.KEYCODE_MEDIA_PAUSE)
+			.body { pictureViewerViewModel.togglePresentation() }
+
+		keyDown(KeyEvent.KEYCODE_DPAD_LEFT)
+			.condition { !binding.actions.isVisible }
+			.body { pictureViewerViewModel.showPrevious() }
+
+		keyDown(KeyEvent.KEYCODE_MEDIA_SKIP_BACKWARD, KeyEvent.KEYCODE_MEDIA_PREVIOUS)
+			.body { pictureViewerViewModel.showPrevious() }
+
+		keyDown(KeyEvent.KEYCODE_DPAD_RIGHT)
+			.condition { !binding.actions.isVisible }
+			.body { pictureViewerViewModel.showNext() }
+
+		keyDown(KeyEvent.KEYCODE_MEDIA_SKIP_FORWARD, KeyEvent.KEYCODE_MEDIA_NEXT)
+			.body { pictureViewerViewModel.showNext() }
+
+		keyDown(
+			KeyEvent.KEYCODE_DPAD_UP, KeyEvent.KEYCODE_DPAD_DOWN,
+			KeyEvent.KEYCODE_ENTER, KeyEvent.KEYCODE_DPAD_CENTER,
+		)
+			.condition { !binding.actions.isVisible }
+			.body { showActions() }
+
+		keyDown(KeyEvent.KEYCODE_DPAD_DOWN, KeyEvent.KEYCODE_BACK)
+			.condition { binding.actions.isVisible }
+			.body { hideActions() }
+	}
+
+	override fun onKey(v: View?, keyCode: Int, event: KeyEvent?): Boolean = keyHandler.onKey(event)
+
+	private var focusedActionView: View? = null
+	fun showActions(): Boolean {
+		if (binding.actions.isVisible) return false
+
+		binding.actions.isVisible = true
+		if (focusedActionView?.requestFocus() != true) binding.actionPlayPause.requestFocus()
+		binding.actions.startAnimation(AnimationUtils.loadAnimation(context, R.anim.fade_in))
+		return true
+	}
+
+	fun hideActions(): Boolean {
+		if (!binding.actions.isVisible) return false
+		binding.actions.startAnimation(AnimationUtils.loadAnimation(context, R.anim.fade_out).apply {
+			setAnimationListener(object : Animation.AnimationListener {
+				override fun onAnimationStart(animation: Animation?) = Unit
+
+				override fun onAnimationEnd(animation: Animation?) {
+					focusedActionView = binding.actions.findFocus()
+					binding.actions.isGone = true
+				}
+
+				override fun onAnimationRepeat(animation: Animation?) = Unit
+			})
+		})
+		return true
+	}
+
+	fun toggleActions(): Boolean {
+		return if (binding.actions.isVisible) hideActions()
+		else showActions()
+	}
+
+	private fun AsyncImageView.load(item: BaseItemDto) {
+		val url = when (USE_DOWNLOAD_API) {
+			true -> api.libraryApi.getDownloadUrl(
+				itemId = item.id,
+				includeCredentials = true, // TODO send authentication via header
+			)
+			false -> api.imageApi.getItemImageUrl(
+				itemId = item.id,
+				imageType = ImageType.PRIMARY,
+				tag = item.imageTags?.get(ImageType.PRIMARY),
+				// Ask the server to downscale the image to avoid the app going out of memory
+				// unfortunately this can be a bit slow for larger files
+				maxWidth = context.resources.displayMetrics.widthPixels,
+				maxHeight = context.resources.displayMetrics.heightPixels,
+			)
+		}
+
+		load(
+			url = url,
+			blurHash = item.imageBlurHashes?.get(ImageType.PRIMARY)?.get(item.imageTags?.get(ImageType.PRIMARY)),
+			aspectRatio = item.primaryImageAspectRatio ?: 1.0,
+		)
+	}
+}