[ui-compose] Add API 34 fix for SurfaceView wrapped in AndroidView

A similar fix was done on PlayerView for the cases when it needs to be
wrapped in AndroidView: 968f72f
This fix ensures that the PlayerSurface composable can also be resized
correctly on API 34 (API 33/Android 13 didn't have this problem,
API 35/Android 15 had it fixed in the platform).

Issue: #2811
PiperOrigin-RevId: 819276595

Author: oceanjules

RELEASENOTES.md

@@ -281,6 +281,12 @@
     *   Add `ContentFrame` Composable to `media3-ui-compose` which combines
         `PlayerSurface` management with aspect ratio resizing and covering with
         a shutter.
+    *   Work around a known API 34 platform bug causing stretched/cropped videos
+        when using `SurfaceView` inside a Compose `AndroidView` and hence
+        affecting `ContentFrame` and `PlayerSurface` Composables with
+        `SURFACE_TYPE_SURFACE_VIEW`
+        ([#1237](https://github.com/androidx/media/issues/1237),
+        [#2811](https://github.com/androidx/media/issues/2811)).
     *   Create a new `media3-ui-compose-material3` module and add
         Material3-themed Composables (PlayPauseButton, NextButton,
         PreviousButton, SeekBackButton, SeekForwardButton, RepeatButton,

libraries/ui_compose/src/main/java/androidx/media3/ui/compose/PlayerSurface.kt

@@ -17,21 +17,28 @@
 package androidx.media3.ui.compose
 
 import android.content.Context
+import android.graphics.Canvas
+import android.os.Build.VERSION.SDK_INT
+import android.view.SurfaceControl
 import android.view.SurfaceView
 import android.view.TextureView
 import android.view.View
+import android.window.SurfaceSyncGroup
 import androidx.annotation.IntDef
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.DisposableEffect
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.viewinterop.AndroidView
 import androidx.media3.common.Player
 import androidx.media3.common.util.UnstableApi
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
 
 /**
@@ -55,14 +62,51 @@ fun PlayerSurface(
   surfaceType: @SurfaceType Int = SURFACE_TYPE_SURFACE_VIEW,
 ) {
   when (surfaceType) {
-    SURFACE_TYPE_SURFACE_VIEW ->
+    SURFACE_TYPE_SURFACE_VIEW -> {
+      var surfaceSyncGroup: SurfaceSyncGroup? by remember { mutableStateOf(null) }
+
+      val createSurfaceView: (Context) -> SurfaceView = { context ->
+        object : SurfaceView(context) {
+          override fun dispatchDraw(canvas: Canvas) {
+            super.dispatchDraw(canvas)
+            if (SDK_INT == 34) {
+              surfaceSyncGroup?.markSyncReady()
+              surfaceSyncGroup = null
+            }
+          }
+        }
+      }
+
+      val coroutineScope = rememberCoroutineScope()
+      val onSurfaceSizeChanged: (SurfaceView) -> Unit = { surfaceView ->
+        if (SDK_INT == 34) {
+          coroutineScope.launch(Dispatchers.Main) {
+            surfaceView.rootSurfaceControl?.let { rootSurfaceControl ->
+              // Register a SurfaceSyncGroup to work around
+              // https://github.com/androidx/media/issues/1237
+              // (only present on API 34, fixed on API 35).
+              surfaceSyncGroup =
+                SurfaceSyncGroup("exo-sync-b-334901521").apply {
+                  check(add(rootSurfaceControl) {}) {
+                    "Failed to add rootSurfaceControl to SurfaceSyncGroup"
+                  }
+                }
+              surfaceView.invalidate()
+              rootSurfaceControl.applyTransactionOnDraw(SurfaceControl.Transaction())
+            }
+          }
+        }
+      }
+
       PlayerSurfaceInternal(
         player,
         modifier,
-        createView = ::SurfaceView,
+        createView = createSurfaceView,
         setVideoView = Player::setVideoSurfaceView,
         clearVideoView = Player::clearVideoSurfaceView,
+        onSurfaceSizeChanged = onSurfaceSizeChanged,
       )
+    }
     SURFACE_TYPE_TEXTURE_VIEW ->
       PlayerSurfaceInternal(
         player,
@@ -82,6 +126,7 @@ private fun <T : View> PlayerSurfaceInternal(
   createView: (Context) -> T,
   setVideoView: Player.(T) -> Unit,
   clearVideoView: Player.(T) -> Unit,
+  onSurfaceSizeChanged: (T) -> Unit = {},
 ) {
   var view by remember { mutableStateOf<T?>(null) }
 
@@ -93,14 +138,29 @@ private fun <T : View> PlayerSurfaceInternal(
   )
 
   view?.let { view ->
+    DisposableEffect(view, player) {
+      val listener =
+        if (player != null) {
+          object : Player.Listener {
+              override fun onSurfaceSizeChanged(width: Int, height: Int) {
+                onSurfaceSizeChanged(view)
+              }
+            }
+            .also { player.addListener(it) }
+        } else null
+
+      onDispose { listener?.let { player?.removeListener(it) } }
+    }
+
     LaunchedEffect(view, player) {
       if (player != null) {
         view.attachedPlayer?.let { previousPlayer ->
           if (
             previousPlayer != player &&
               previousPlayer.isCommandAvailable(Player.COMMAND_SET_VIDEO_SURFACE)
-          )
+          ) {
             previousPlayer.clearVideoView(view)
+          }
         }
         if (player.isCommandAvailable(Player.COMMAND_SET_VIDEO_SURFACE)) {
           player.setVideoView(view)
@@ -113,8 +173,9 @@ private fun <T : View> PlayerSurfaceInternal(
         // unnecessarily creating a Surface placeholder.
         withContext(Dispatchers.Main) {
           view.attachedPlayer?.let { previousPlayer ->
-            if (previousPlayer.isCommandAvailable(Player.COMMAND_SET_VIDEO_SURFACE))
+            if (previousPlayer.isCommandAvailable(Player.COMMAND_SET_VIDEO_SURFACE)) {
               previousPlayer.clearVideoView(view)
+            }
             view.attachedPlayer = null
           }
         }