reis-mobile 0.3.6 → 0.5.0

package/skills/mobile-android/references/media/media3-cast-integration/GUIDE.md

@@ -0,0 +1,213 @@
+> Adapted from the `media3-cast-integration` skill in [android/skills](https://github.com/android/skills) (Apache-2.0). See `THIRD_PARTY_NOTICES.md`.
+
+## Prerequisites
+
+- Jetpack Media3 version must be `>= 1.9.0`. Cast isn't available in lower versions.
+
+## Glossary
+
+- **`CastPlayer`** : Media3 `Player` that controls playback on both local and remote Cast devices.
+- **`RemoteCastPlayer`** : Media3 `Player` that communicates with a Cast receiver, only used for remote playback.
+- **Google Cast SDK**: Legacy casting SDK in maintenance mode, superseded by Jetpack Media3.
+- **`OptionsProvider`** : Interface providing configuration options to initialize GMS `CastContext`.
+
+## Common guidelines
+
+- Legacy [Google Cast SDK](https://developers.google.com/cast) is in maintenance mode.
+- For new Cast setups:
+  - You must use [Jetpack Media3 Cast](references/android/media/media3/cast/index.md).
+  - You mustn't use legacy Cast SDK unless explicitly requested.
+
+## Step 1: Set up dependencies
+
+To complete this step, you **MUST** ensure the following:
+
+- In the app-level build file, declare the `media3-cast` dependency version
+  1.9.0 or higher.
+
+      implementation("androidx.media3:media3-cast:1.11.0")
+
+- Ensure required Media3 dependencies are present:
+
+  - `androidx.media3:media3-exoplayer`
+  - `androidx.media3:media3-session`
+  - `androidx.media3:media3-ui-compose`
+- If the application uses legacy Views, add `media3-ui`.
+
+- Enforce the same versions across all Media3 dependencies.
+
+- Use configurations in "Add build dependencies" section of [Getting started
+  with CastPlayer](references/android/media/media3/cast/create-castplayer.md) as the source of
+  truth.
+
+- **For apps without an existing Cast integration:**
+
+  - Verify legacy Cast SDK (`libs.play.services.cast.framework`) is absent.
+- **If Migrating from Legacy Cast SDK:**
+
+  - Add Media3 Cast dependencies first.
+  - Keep existing legacy dependencies untouched at this stage to prevent compilation errors.
+
+## Step 2: Update the manifest
+
+To complete this step, you **MUST** ensure the following:
+
+- Inside the manifest's `<application>` tag, declare the Cast options provider.
+- Use `DefaultCastOptionsProvider` by default. See the "OptionsProvider" section in [Getting started with
+  CastPlayer](references/android/media/media3/cast/create-castplayer.md).
+- Declare a custom `OptionsProvider` only if explicitly requested. See [Customize CastOptions](references/android/media/media3/cast/customize-castoptions.md).
+- Ensure `INTERNET` permission is present. Don't add any unnecessary permissions.
+- **If Migrating from Legacy Cast SDK:**
+  - Don't delete existing custom options provider files or manifest entries.
+
+## Step 3: Implement the player and service
+
+### Architecture baseline
+
+Before integrating Media3 Cast, an existing app follows one of two setups:
+
+- **Local-only playback:** Uses Media3 `ExoPlayer` only to support local playback.
+- **Legacy Cast setup:** Uses `ExoPlayer` for local playback, alongside a `Player` wrapper over the legacy `RemoteMediaClient` for remote playback. The UI interfaces with a `MediaSession` interacting with a `ForwardingPlayer`, which finally routes controls to either local or remote playback.
+
+To complete this step, you **MUST** ensure the following:
+
+- Inside the application's `MediaSessionService` (or `MediaLibraryService`) `onCreate()` method, initialize `ExoPlayer` and `CastPlayer`.
+- Use `CastPlayer` by default unless `RemoteCastPlayer` is explicitly requested. See the "Build a CastPlayer" section in [Getting started with
+  CastPlayer](references/android/media/media3/cast/create-castplayer.md).
+- For `CastPlayer`, pass the instance directly to `MediaSession.Builder`.
+- Replace all legacy forwarding player wrappers.
+- Don't delete legacy class files yet to prevent compilation errors during migration.
+
+### Advanced: `RemoteCastPlayer`
+
+- Use `RemoteCastPlayer` only if explicitly requested by user.
+- Initialize `MediaSession` with `localPlayer` and set a `SessionAvailabilityListener` on `RemoteCastPlayer` to transfer playback state on Cast session availability changes:
+
+    class PlaybackService : MediaSessionService() {
+      private var mediaSession: MediaSession? = null
+      private lateinit var localPlayer: ExoPlayer
+      private lateinit var remotePlayer: RemoteCastPlayer
+
+      override fun onCreate() {
+        super.onCreate()
+
+        localPlayer = ExoPlayer.Builder(this).build()
+        remotePlayer = RemoteCastPlayer.Builder(this).build()
+        mediaSession = MediaSession.Builder(this, localPlayer).build()
+
+        remotePlayer.setSessionAvailabilityListener(
+          object : SessionAvailabilityListener {
+            override fun onCastSessionAvailable() {
+              transferPlaybackState(localPlayer, remotePlayer)
+            }
+
+            override fun onCastSessionUnavailable() {
+              transferPlaybackState(remotePlayer, localPlayer)
+            }
+          }
+        )
+      }
+
+      private fun transferPlaybackState(previousPlayer: Player, newPlayer: Player) {
+        if (previousPlayer.mediaItemCount > 0) {
+          val transferStateBuilder = PlayerTransferState.builderFromPlayer(previousPlayer)
+          if (previousPlayer.playbackState == Player.STATE_ENDED ||
+              previousPlayer.currentPosition == C.TIME_END_OF_SOURCE) {
+            transferStateBuilder.setCurrentMediaItemIndex(0)
+            transferStateBuilder.setCurrentPosition(0)
+          }
+          transferStateBuilder.build().setToPlayer(newPlayer)
+        }
+
+        previousPlayer.stop()
+        previousPlayer.clearMediaItems()
+        newPlayer.prepare()
+        mediaSession?.setPlayer(newPlayer)
+      }
+    }
+
+## Step 4: Set up the UI
+
+### Compose-based UI
+
+To complete this step, you **MUST** ensure the following:
+
+- See the "Add a MediaRouteButton Composable to the Player" section in [Getting started with CastPlayer](references/android/media/media3/cast/create-castplayer.md) for Compose integration guidelines.
+- Use the [`MediaRouteButton` composable](https://developer.android.com/reference/kotlin/androidx/media3/cast/MediaRouteButton.composable) from `androidx.media3.cast` package.
+- Don't use `AndroidView` in the Compose UI hierarchy.
+- Place `MediaRouteButton` in an area next to playback controls. Don't hide it behind system UI.
+- Don't use `PlayerSurface` for custom player UI. Use the Material3 [`Player`
+  composable](https://developer.android.com/reference/kotlin/androidx/media3/ui/compose/material3/Player.composable).
+- Force recomposition on playback location shifts to ensure UI sync. Use key
+  constraints on `DeviceInfo` changes:
+
+      @OptIn(UnstableApi::class)
+      @Composable
+      fun MainScreen() {
+         val player = rememberMediaController()
+         val deviceInfo = rememberDeviceInfo(player)
+         player?.let { activePlayer -> key(deviceInfo) { PlayerScreen(player = activePlayer) } }
+      }
+
+      @Composable
+      private fun rememberMediaController(): Player? {
+         // Logic to connect MediaController to MediaSession and release it
+      }
+
+      @Composable
+      private fun rememberDeviceInfo(player: Player?): DeviceInfo? {
+         var deviceInfo by remember(player) { mutableStateOf(player?.deviceInfo) }
+         DisposableEffect(player) {
+             val activePlayer = player ?: return@DisposableEffect onDispose {}
+             deviceInfo = activePlayer.deviceInfo
+             val listener = object : Player.Listener {
+                 override fun onDeviceInfoChanged(info: DeviceInfo) {
+                     deviceInfo = info
+                 }
+             }
+            activePlayer.addListener(listener)
+            onDispose { activePlayer.removeListener(listener) }
+         }
+         return deviceInfo
+      }
+
+### View-based UI
+
+To complete this step, you **MUST** ensure the following:
+
+- For View-based UI setups, see the "Add UI elements" section in [Getting
+  started with CastPlayer](references/android/media/media3/cast/create-castplayer.md).
+- Casting Activities must extend `AppCompatActivity` or `FragmentActivity` and use a `Theme.AppCompat` descendant.
+- Ensure the `AppCompat` theme has a visible `ActionBar` if adding `MediaRouteButton` to the options menu.
+- Replace all instances and imports of `CastButtonFactory` with `MediaRouteButtonFactory`.
+- Rebind `PlayerView.player` references upon `onDeviceInfoChanged` events to
+  prevent black screens or UI freezes:
+
+      private val playerListener: Player.Listener =
+        object : Player.Listener {
+          override fun onDeviceInfoChanged(deviceInfo: DeviceInfo) {
+            // Resetting to null bypasses PlayerView.setPlayer()'s instance equality check
+            // (this.player == player), forcing it to re-bind the video surface to the controller.
+            playerView.player = null
+            playerView.player = controller
+          }
+        }
+
+- **Migration to Compose:**
+
+  - Don't use `AndroidView` to wrap the legacy `PlayerView`.
+  - Implement Material3 [`Player` composable](https://developer.android.com/reference/kotlin/androidx/media3/ui/compose/material3/Player.composable) and [`MediaRouteButton` composable](https://developer.android.com/reference/kotlin/androidx/media3/cast/MediaRouteButton.composable) as per [Getting started with CastPlayer](references/android/media/media3/cast/create-castplayer.md).
+  - Remove legacy XML layout declarations, menu files, and View component references.
+
+## Step 5: Clean up legacy Cast SDK code
+
+> [!WARNING]
+> **Warning:** Don't perform cleanup directly. Remove legacy files and dependencies only when explicitly requested by the user.
+
+To complete this step, you **MUST** ensure the following:
+
+- Remove legacy GMS Cast SDK (`libs.play.services.cast.framework`) and MediaRouter (`libs.androidx.mediarouter`) dependencies.
+- Delete custom `OptionsProvider` classes and manifest entries if `DefaultCastOptionsProvider` is adopted.
+- Remove legacy `MediaTransferReceiver` manifest declarations if present.
+- Remove all references to legacy Cast SDK components such as legacy helper wrappers, forwarding players, and `RemoteMediaClient` interfaces.
+- Delete legacy View XML layouts, menu files, and references to `PlayerView` if the migration to Compose is complete.

package/skills/mobile-android/references/media/media3-cast-integration/references/android/media/media3/cast/create-castplayer.md

@@ -0,0 +1,390 @@
+The [`CastPlayer`](https://developer.android.com/reference/androidx/media3/cast/CastPlayer) is a Jetpack Media3 [Player](https://developer.android.com/reference/kotlin/androidx/media3/common/Player) implementation that supports
+both local playback and casting to a remote Cast-enabled device. [`CastPlayer`](https://developer.android.com/reference/androidx/media3/cast/CastPlayer)
+simplifies adding cast functionality to your app and provides rich features to
+seamlessly switch between local and remote playback. This guide shows you how to
+integrate [`CastPlayer`](https://developer.android.com/reference/androidx/media3/cast/CastPlayer) into your media app.
+
+To integrate Cast with other platforms, see the [Cast SDK](https://developers.google.com/cast/docs/developers).
+
+## Get a Cast-enabled device
+
+To test `CastPlayer`, you need a [Cast-enabled device](https://store.google.com/gb/category/connected_home?hl=en-GB). Choices include Android
+TV, Chromecast, smart speakers, and smart displays. Verify that your device is
+set up and connected to the same Wi-Fi network as your development mobile for
+discovery.
+
+## Add build dependencies
+
+To start using `CastPlayer`, add the AndroidX Media3 and `CastPlayer`
+dependencies to the `build.gradle` file of your app module.
+
+### Kotlin
+
+    implementation("androidx.media3:media3-exoplayer:1.11.0")
+    implementation("androidx.media3:media3-ui:1.11.0")
+    implementation("androidx.media3:media3-session:1.11.0")
+    implementation("androidx.media3:media3-cast:1.11.0")
+
+### Groovy
+
+    implementation "androidx.media3:media3-exoplayer:1.11.0"
+    implementation "androidx.media3:media3-ui:1.11.0"
+    implementation "androidx.media3:media3-session:1.11.0"
+    implementation "androidx.media3:media3-cast:1.11.0"
+
+## Configure your CastPlayer
+
+To configure the [`CastPlayer`](https://developer.android.com/reference/androidx/media3/cast/CastPlayer), update your `AndroidManifest.xml` file with an
+options provider.
+
+### Options provider
+
+The [`CastPlayer`](https://developer.android.com/reference/androidx/media3/cast/CastPlayer) requires an options provider to configure its behavior. For a
+basic setup, you can use the [`DefaultCastOptionsProvider`](https://developer.android.com/reference/androidx/media3/cast/DefaultCastOptionsProvider) by adding it to your
+`AndroidManifest.xml` file. This uses default settings, including the default
+receiver application.
+
+    <application>
+      ...
+      <meta-data
+        android:name="com.google.android.gms.cast.framework.OPTIONS_PROVIDER_CLASS_NAME"
+        android:value="androidx.media3.cast.DefaultCastOptionsProvider" />
+      ...
+    </application>
+
+To customize the configuration, implement your own custom `OptionsProvider`. See
+the [CastOptions](https://developer.android.com/media/media3/cast/customize-castoptions) guide to learn how.
+
+### Add a receiver for media transfers
+
+Adding a `MediaTransferReceiver` to your manifest enables the System UI to
+discover Cast-enabled devices on the network and reroute media without opening
+the app activity. For example, a user can change the device playing your app's
+media from the [media notification](https://developer.android.com/media/implement/surfaces/mobile).
+
+    <application>
+      ...
+      <receiver android:name="androidx.mediarouter.media.MediaTransferReceiver" />
+      ...
+    </application>
+
+## Build a CastPlayer
+
+For remote playback with Cast, your app should be able to manage playback even
+when the user isn't interacting with an Activity from your app, such as through
+the system media notification. For this reason, you should create your
+`ExoPlayer` (for local playback) and `CastPlayer` (for remote playback)
+instances in a service, such as [MediaSessionService](https://developer.android.com/media/media3/session/background-playback#service-lifecycle) or [MediaLibraryService](https://developer.android.com/guide/topics/media/session/medialibraryservice).
+First, create your `ExoPlayer` instance and then when building your
+[`CastPlayer`](https://developer.android.com/reference/androidx/media3/cast/CastPlayer) instance, set `ExoPlayer` as the local player instance. You can
+then switch media playback between your mobile and the Cast-enabled device from
+the media notification or the lock screen notification. Media3 uses the **Output
+Switcher** feature to handle player transfers when the output route changes from
+local to remote or from remote to local.
+![Screenshot showing the Output Switcher UI in notifications.](https://developer.android.com/static/media/media3/cast/images/output_switcher.jpeg) Figure 1: (a) Device chip on Media notification (b) Cast-enabled devices shown on tapping the device chip (c) Device chip on Lock screen notification
+
+
+### Kotlin
+
+```kotlin
+override fun onCreate() {
+  super.onCreate()
+
+  val exoPlayer = ExoPlayer.Builder(context).build()
+  val castPlayer = CastPlayer.Builder(context).setLocalPlayer(exoPlayer).build()
+
+  mediaSession = MediaSession.Builder(context, castPlayer).build()
+}
+```
+
+### Java
+
+```java
+@Override
+public void onCreate() {
+  super.onCreate();
+
+  ExoPlayer exoPlayer = new ExoPlayer.Builder(context).build();
+  CastPlayer castPlayer = new CastPlayer.Builder(context).setLocalPlayer(exoPlayer).build();
+
+  mediaSession =
+      new MediaSession.Builder(/* context= */ context, /* player= */ castPlayer).build();
+}
+```
+
+<br />
+
+> [!IMPORTANT]
+> **Important:** The preceding code snippet shows the `onCreate` method of a `MediaSessionService`. In an `Activity`, players should be created in `onStart` or `onResume`.
+
+## Add UI elements
+
+Add a [`MediaRouteButton`](https://developer.android.com/reference/androidx/mediarouter/app/MediaRouteButton) to your app's UI. Tapping the [`MediaRouteButton`](https://developer.android.com/reference/androidx/mediarouter/app/MediaRouteButton)
+opens a dialog displaying a list of available Cast-enabled devices on the
+network. When the user selects a device, the media playback is transferred from
+the mobile to the selected receiver device. This section shows you how to add
+the button and listen for events to update your UI when playback switches
+between local and remote devices.
+
+### Set the MediaRouteButton
+
+There are four ways to add the [`MediaRouteButton`](https://developer.android.com/reference/androidx/mediarouter/app/MediaRouteButton) to your activity's UI. The
+best choice depends on your app's design and requirements.
+
+- **Compose UI**: Add a button composable.
+- **Views UI** :
+  - Add the button to the app bar menu.
+  - Add the button inside `PlayerView`.
+  - Add the button as a standard `View`.
+
+![Screenshot showing the MediaRouteButton in the UI.](https://developer.android.com/static/media/media3/cast/images/cast.jpeg) Figure 2: (a) MediaRouteButton in menu bar, (b) as a View, (c) in PlayerView, and (d) Dialog of Cast-enabled devices.
+
+> [!IMPORTANT]
+> **Important:** To use the [`MediaRouteButton`](https://developer.android.com/reference/androidx/mediarouter/app/MediaRouteButton) in Views UI, the containing activity must be a subclass of `FragmentActivity`.
+
+> [!TIP]
+> **Tip:** These screenshots are from the [demo-session](https://github.com/androidx/media/tree/release/demos/session) apps in Media3. You can checkout the app to see an example of `CastPlayer` implementation.
+
+#### Add a Composable `MediaRouteButton` to the Player
+
+You can add the [`MediaRouteButton`](https://developer.android.com/reference/androidx/mediarouter/app/MediaRouteButton) Composable to your player's UI. For more
+information, see the [Compose](https://developer.android.com/media/media3/ui/compose) guide.
+
+
+```kotlin
+@Composable
+fun PlayerComposeView(player: Player, modifier: Modifier = Modifier) {
+  var controlsVisible by remember { mutableStateOf(false) }
+
+  Box(
+    modifier = modifier.clickable { controlsVisible = true },
+    contentAlignment = Alignment.Center,
+  ) {
+    PlayerSurface(player = player, modifier = modifier)
+    AnimatedVisibility(visible = controlsVisible, enter = fadeIn(), exit = fadeOut()) {
+      Box(modifier = Modifier.fillMaxSize()) {
+        MediaRouteButton(modifier = Modifier.align(Alignment.TopEnd))
+        PrimaryControls(player = player, modifier = Modifier.align(Alignment.Center))
+      }
+    }
+  }
+}
+
+@Composable
+fun PrimaryControls(player: Player, modifier: Modifier = Modifier) {
+  // ...
+}
+```
+
+<br />
+
+#### Add the `MediaRouteButton` to the PlayerView
+
+You can add the [`MediaRouteButton`](https://developer.android.com/reference/androidx/mediarouter/app/MediaRouteButton) directly within the [PlayerView](https://developer.android.com/guide/topics/media/ui/playerview)'s UI
+controls. After setting the [MediaController](https://developer.android.com/guide/topics/media/session/mediacontroller) as the player for your
+`PlayerView`, provide a `MediaRouteButtonViewProvider` to display the Cast
+button on the Player.
+
+
+### Kotlin
+
+```kotlin
+override fun onStart() {
+  super.onStart()
+
+  playerView.player = mediaController
+  playerView.setMediaRouteButtonViewProvider(MediaRouteButtonViewProvider())
+}
+```
+
+### Java
+
+```java
+@Override
+public void onStart() {
+  super.onStart();
+
+  playerView.setPlayer(mediaController);
+  playerView.setMediaRouteButtonViewProvider(new MediaRouteButtonViewProvider());
+}
+```
+
+<br />
+
+#### Add the `MediaRouteButton` to the app bar menu
+
+To set up a [`MediaRouteButton`](https://developer.android.com/reference/androidx/mediarouter/app/MediaRouteButton) in the app bar menu, create an XML menu and
+override `onCreateOptionsMenu` in your `Activity`.
+
+    <menu xmlns:android="http://schemas.android.com/apk/res/android"
+             xmlns:app="http://schemas.android.com/apk/res-auto">
+      <item android:id="@+id/media_route_menu_item"
+        android:title="@string/media_route_menu_title"
+        app:showAsAction="always"
+        app:actionProviderClass="androidx.mediarouter.app.MediaRouteActionProvider"/>
+    </menu>
+
+
+### Kotlin
+
+```kotlin
+override fun onCreateOptionsMenu(menu: Menu): Boolean {
+  // ...
+  menuInflater.inflate(R.menu.sample_media_route_button_menu, menu)
+  val menuItemFuture: ListenableFuture<MenuItem> =
+    MediaRouteButtonFactory.setUpMediaRouteButton(context, menu, R.id.media_route_menu_item)
+  Futures.addCallback(
+    menuItemFuture,
+    object : FutureCallback<MenuItem> {
+      override fun onSuccess(menuItem: MenuItem?) {
+        // Do something with the menu item.
+      }
+
+      override fun onFailure(t: Throwable) {
+        // Handle the failure.
+      }
+    },
+    executor,
+  )
+  // ...
+  return true
+}
+```
+
+### Java
+
+```java
+@Override
+public boolean onCreateOptionsMenu(Menu menu) {
+  // ...
+  getMenuInflater().inflate(R.menu.sample_media_route_button_menu, menu);
+  ListenableFuture<MenuItem> menuItemFuture =
+      MediaRouteButtonFactory.setUpMediaRouteButton(context, menu, R.id.media_route_menu_item);
+  Futures.addCallback(
+      menuItemFuture,
+      new FutureCallback<MenuItem>() {
+        @Override
+        public void onSuccess(MenuItem menuItem) {
+          // Do something with the menu item.
+        }
+
+        @Override
+        public void onFailure(Throwable t) {
+          // Handle the failure.
+        }
+      },
+      executor);
+  // ...
+  return true;
+}
+```
+
+<br />
+
+#### Add the `MediaRouteButton` as a View
+
+You can set up a [`MediaRouteButton`](https://developer.android.com/reference/androidx/mediarouter/app/MediaRouteButton) in your activity layout.xml.
+
+      <androidx.mediarouter.app.MediaRouteButton
+          android:id="@+id/media_route_button"
+          android:layout_width="wrap_content"
+          android:layout_height="wrap_content"
+          app:mediaRouteButtonTint="@android:color/white" />
+
+To complete the setup for the [`MediaRouteButton`](https://developer.android.com/reference/androidx/mediarouter/app/MediaRouteButton), use the Media3 Cast
+`MediaRouteButtonFactory` in your `Activity` code.
+
+
+### Kotlin
+
+```kotlin
+override fun onCreate(savedInstanceState: Bundle?) {
+  super.onCreate(savedInstanceState)
+
+  findViewById<MediaRouteButton>(R.id.media_route_button)?.also {
+    val unused = MediaRouteButtonFactory.setUpMediaRouteButton(context, it)
+  }
+}
+```
+
+### Java
+
+```java
+@Override
+public void onCreate(Bundle savedInstanceState) {
+  super.onCreate(savedInstanceState);
+  // ...
+  MediaRouteButton button = findViewById(R.id.media_route_button);
+  ListenableFuture<Void> setUpFuture =
+      MediaRouteButtonFactory.setUpMediaRouteButton(context, button);
+}
+```
+
+<br />
+
+### Activity Listener
+
+Create a `Player.Listener` in your `Activity` to listen for changes to media
+playback location. When the `playbackType` changes between `PLAYBACK_TYPE_LOCAL`
+and `PLAYBACK_TYPE_REMOTE`, you can adjust your UI as needed. To prevent memory
+leaks and to confine listener activity to only when your app is visible,
+register the listener in `onStart` and unregister it in `onStop`:
+
+
+### Kotlin
+
+```kotlin
+private val playerListener: Player.Listener =
+  object : Player.Listener {
+    override fun onDeviceInfoChanged(deviceInfo: DeviceInfo) {
+      if (deviceInfo.playbackType == DeviceInfo.PLAYBACK_TYPE_LOCAL) {
+        // Add UI changes for local playback.
+      } else if (deviceInfo.playbackType == DeviceInfo.PLAYBACK_TYPE_REMOTE) {
+        // Add UI changes for remote playback.
+      }
+    }
+  }
+
+override fun onStart() {
+  super.onStart()
+  mediaController.addListener(playerListener)
+}
+
+override fun onStop() {
+  super.onStop()
+  mediaController.removeListener(playerListener)
+}
+```
+
+### Java
+
+```java
+private final Player.Listener playerListener =
+    new Player.Listener() {
+      @Override
+      public void onDeviceInfoChanged(DeviceInfo deviceInfo) {
+        if (deviceInfo.playbackType == DeviceInfo.PLAYBACK_TYPE_LOCAL) {
+          // Add UI changes for local playback.
+        } else if (deviceInfo.playbackType == DeviceInfo.PLAYBACK_TYPE_REMOTE) {
+          // Add UI changes for remote playback.
+        }
+      }
+    };
+
+@Override
+protected void onStart() {
+  super.onStart();
+  mediaController.addListener(playerListener);
+}
+
+@Override
+protected void onStop() {
+  super.onStop();
+  mediaController.removeListener(playerListener);
+}
+```
+
+<br />
+
+For more information about listening and responding to playback events, see the
+[player events](https://developer.android.com/media/media3/exoplayer/listening-to-player-events) guide.

package/skills/mobile-android/references/media/media3-cast-integration/references/android/media/media3/cast/customize-castoptions.md

@@ -0,0 +1,93 @@
+To configure your app's Cast session, provide an [`OptionsProvider`](https://developers.google.com/android/reference/com/google/android/gms/cast/framework/OptionsProvider). Use the
+[`CastOptions`](https://developers.google.com/android/reference/com/google/android/gms/cast/framework/CastOptions) object built by the provider to set the receiver application ID,
+manage session lifecycles, and customize media playback behavior.
+
+## Use the default options provider
+
+For a basic setup that uses the default Cast receiver application, add the
+`DefaultCastOptionsProvider` to your app's `AndroidManifest.xml` file:
+
+    <application>
+      ...
+      <meta-data
+        android:name="com.google.android.gms.cast.framework.OPTIONS_PROVIDER_CLASS_NAME"
+        android:value="androidx.media3.cast.DefaultCastOptionsProvider" />
+      ...
+    </application>
+
+## Create a custom options provider
+
+For more advanced configurations, such as setting a custom receiver application
+ID, you need to create your own `OptionsProvider`.
+
+### 1. Declare the provider in your manifest
+
+First, declare your custom provider in `AndroidManifest.xml`. Make sure to use
+the fully qualified class name.
+
+    <application>
+      ...
+      <meta-data
+        android:name="com.google.android.gms.cast.framework.OPTIONS_PROVIDER_CLASS_NAME"
+        android:value="path.to.your.class.MyCustomCastOptionsProvider" />
+      ...
+    </application>
+
+### 2. Implement the OptionsProvider interface
+
+Next, create a class that implements the `OptionsProvider` interface. In this
+class, you must override `getCastOptions()` to return a `CastOptions` instance.
+The custom `OptionsProvider` class is where you configure your Cast session, for
+example, by setting your custom receiver application ID.
+
+For more information, see [CastOptions.Builder](https://developers.google.com/android/reference/com/google/android/gms/cast/framework/CastOptions.Builder).
+
+
+### Kotlin
+
+```kotlin
+class MyCustomCastOptionsProvider : OptionsProvider {
+
+  override fun getCastOptions(context: Context): CastOptions {
+    return CastOptions.Builder()
+      .setReceiverApplicationId(APP_ID)
+      .setRemoteToLocalEnabled(true)
+      .build()
+  }
+
+  override fun getAdditionalSessionProviders(context: Context): List<SessionProvider>? {
+    return null
+  }
+
+  companion object {
+    // Add your receiver app ID in <APP_ID>.
+    private const val APP_ID = "<APP_ID>"
+  }
+}
+```
+
+### Java
+
+```java
+public static final class MyCustomCastOptionsProvider implements OptionsProvider {
+
+  // Add your receiver app ID in <APP_ID>.
+  public static final String APP_ID = "<APP_ID>";
+
+  @Override
+  public CastOptions getCastOptions(Context context) {
+    return new CastOptions.Builder()
+        .setReceiverApplicationId(APP_ID)
+        .setRemoteToLocalEnabled(true)
+        .build();
+  }
+
+  @Override
+  @Nullable
+  public List<SessionProvider> getAdditionalSessionProviders(Context context) {
+    return null;
+  }
+}
+```
+
+<br />