### Full Activity Integration Example for Mux Player

Source: https://context7.com/muxinc/mux-player-android/llms.txt

A complete Android Activity demonstrating Mux Player integration, including lifecycle management, MediaItem creation with Mux Data, error handling, and resource cleanup. Ensure to replace 'YOUR_PLAYBACK_ID' with your actual Mux playback ID.

```kotlin
import android.content.Context
import android.os.Bundle
import android.util.Log
import android.widget.Toast
import androidx.annotation.OptIn
import androidx.appcompat.app.AppCompatActivity
import androidx.media3.common.MediaMetadata
import androidx.media3.common.PlaybackException
import androidx.media3.common.Player
import androidx.media3.common.util.UnstableApi
import androidx.media3.ui.PlayerView
import com.mux.player.MuxPlayer
import com.mux.player.media.MediaItems
import com.mux.player.media.PlaybackResolution
import com.mux.stats.sdk.core.model.CustomerData
import com.mux.stats.sdk.core.model.CustomerVideoData
import com.mux.stats.sdk.core.model.CustomerViewData
import com.mux.stats.sdk.core.util.UUID

class MyPlayerActivity : AppCompatActivity() {

    private lateinit var playerView: PlayerView
    private var player: MuxPlayer? = null

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_player)
        playerView = findViewById(R.id.player_view)
    }

    override fun onStart() {
        super.onStart()
        val player = createPlayer(this)
        val mediaItem = MediaItems.builderFromMuxPlaybackId(
            playbackId    = "YOUR_PLAYBACK_ID",
            maxResolution = PlaybackResolution.FHD_1080,
        )
            .setMediaMetadata(
                MediaMetadata.Builder()
                    .setTitle("My Video")
                    .build()
            )
            .build()

        player.setMediaItem(mediaItem)
        player.prepare()
        player.playWhenReady = true
        playerView.player = player
        this.player = player
    }

    override fun onStop() {
        playerView.player = null
        player?.release()
        player = null
        super.onStop()
    }

    @OptIn(UnstableApi::class)
    private fun createPlayer(context: Context): MuxPlayer {
        return MuxPlayer.Builder(context)
            .addMonitoringData(CustomerData().apply {
                customerViewData = CustomerViewData().apply {
                    viewSessionId = UUID.generateUUID()
                }
                customerVideoData = CustomerVideoData().apply {
                    videoId    = "my-video-001"
                    videoSeries = "Tutorials"
                }
            })
            .enableSmartCache(true)
            .applyExoConfig {
                setHandleAudioBecomingNoisy(true)
                setSeekBackIncrementMs(10_000)
                setSeekForwardIncrementMs(30_000)
            }
            .build()
            .also { p ->
                p.addListener(object : Player.Listener {
                    override fun onPlayerError(error: PlaybackException) {
                        Log.e("MyPlayerActivity", "Playback error", error)
                        Toast.makeText(
                            context,
                            "Error: ${error.localizedMessage}",
                            Toast.LENGTH_LONG
                        ).show()
                    }
                })
            }
    }
}
```

--------------------------------

### Play Mux Video Asset with MediaItems

Source: https://github.com/muxinc/mux-player-android/blob/main/README.md

Play a Mux Video asset by creating a MediaItem using the MediaItems.builderFromMuxPlaybackId() helper. You can then configure the MediaItem further, for example, by setting its metadata.

```kotlin
// Use the MediaItems class instead of MediaItem.Builder()
val mediaItem = MediaItems.builderFromMuxPlaybackId("YOUR PLAYBACK ID")
  // It's just a MediaItem from here, so you can configure it however you like
  .setMediaMetadata(
    MediaMetadata.Builder()
      .setTitle("Hello from Mux Player on Android!")
      .build()
  )
  .build()

// From here, everything is exactly the same as ExoPlayer
player.setMediaItem(mediaItem)
player.prepare()
player.playWhenReady = true
```

--------------------------------

### Create Configurable MediaItem.Builder from Mux Playback ID

Source: https://context7.com/muxinc/mux-player-android/llms.txt

Use `MediaItems.builderFromMuxPlaybackId` to get a pre-configured `MediaItem.Builder` for a Mux playback ID. This allows for additional media3 customizations before building the `MediaItem`.

```kotlin
import androidx.media3.common.MediaMetadata
import com.mux.player.media.MediaItems

val mediaItem = MediaItems.builderFromMuxPlaybackId(
    playbackId    = "YOUR_PLAYBACK_ID",
    maxResolution = PlaybackResolution.HD_720,
)
    .setMediaMetadata(
        MediaMetadata.Builder()
            .setTitle("My Video Title")
            .setArtist("Director Name")
            .build()
    )
    .build()

player.setMediaItem(mediaItem)
player.prepare()
player.playWhenReady = true
```

--------------------------------

### Custom MuxMediaSourceFactory with DataSource

Source: https://context7.com/muxinc/mux-player-android/llms.txt

Use MuxMediaSourceFactory directly when you need to inject a custom DataSource.Factory while retaining Mux's CMCD and DRM features. This example shows how to add custom HTTP headers.

```kotlin
import androidx.media3.datasource.DefaultDataSource
import com.mux.player.media.MuxMediaSourceFactory

// Use a custom DataSource.Factory (e.g., with custom headers)
val customHttpFactory = DefaultHttpDataSource.Factory()
    .setDefaultRequestProperties(mapOf("X-Custom-Header" to "value"))

val mediaSourceFactory = MuxMediaSourceFactory(
    ctx               = context,
    dataSourceFactory = DefaultDataSource.Factory(context, customHttpFactory)
)

val player = MuxPlayer.Builder(context)
    .applyExoConfig {
        setMediaSourceFactory(mediaSourceFactory)
    }
    .build()
```

--------------------------------

### RenditionOrder

Source: https://context7.com/muxinc/mux-player-android/llms.txt

Controls whether ExoPlayer's adaptive algorithm starts at the highest available bitrate (Descending, quality-first) or uses the default delivery-optimized order.

```APIDOC
## RenditionOrder — Adaptive Bitrate Preference

Controls whether ExoPlayer's adaptive algorithm starts at the highest available bitrate (`Descending`, quality-first) or uses the default delivery-optimized order. Use `Descending` when the quality of first-play experience matters more than buffering startup time.

### Values

- `RenditionOrder.Descending` → prefers highest quality, may take longer to start
- `RenditionOrder.Default`    → Mux delivery-optimized order (default)

### Usage Example

```kotlin
import com.mux.player.media.RenditionOrder

val item = MediaItems.fromMuxPlaybackId(
    playbackId     = "YOUR_PLAYBACK_ID",
    renditionOrder = RenditionOrder.Descending
)
```
```

--------------------------------

### Build MuxPlayer Instance with Mux Data and ExoPlayer Configuration

Source: https://context7.com/muxinc/mux-player-android/llms.txt

Create a MuxPlayer instance using MuxPlayer.Builder. Configure Mux Data environment key, viewer/video metadata, and customize the underlying ExoPlayer.Builder settings. Smart caching and logging can also be enabled.

```kotlin
import androidx.annotation.OptIn
import androidx.media3.common.util.UnstableApi
import com.mux.player.MuxPlayer
import com.mux.stats.sdk.core.model.CustomData
import com.mux.stats.sdk.core.model.CustomerData
import com.mux.stats.sdk.core.model.CustomerVideoData
import com.mux.stats.sdk.core.model.CustomerViewData
import com.mux.stats.sdk.core.util.UUID

@OptIn(UnstableApi::class)
fun buildPlayer(context: Context): MuxPlayer {
    return MuxPlayer.Builder(context)
        // Optional: override the Mux Data environment key
        .setMuxDataEnv("your_mux_data_env_key")
        // Optional: supply viewer / video metadata for Mux Data
        .addMonitoringData(
            CustomerData().apply {
                customerViewData = CustomerViewData().apply {
                    viewSessionId = UUID.generateUUID()
                }
                customerVideoData = CustomerVideoData().apply {
                    videoId    = "abc1234zyxw"
                    videoSeries = "My Series"
                }
                customData = CustomData().apply {
                    customData1  = "campaign=summer"
                    customData2  = "region=us-east"
                    customData10 = "tier=premium"
                }
            }
        )
        // Optional: configure the underlying ExoPlayer.Builder
        .applyExoConfig {
            setHandleAudioBecomingNoisy(true)
            setSeekBackIncrementMs(10_000)
            setSeekForwardIncrementMs(30_000)
        }
        // Optional: enable Mux smart caching (experimental)
        .enableSmartCache(true)
        // Optional: print Mux-specific logcat output
        .enableLogcat(true)
        .build()
}
```

--------------------------------

### Create MuxPlayer Instance

Source: https://github.com/muxinc/mux-player-android/blob/main/README.md

Instantiate a MuxPlayer object using its Builder. This enables Mux-specific features and allows for ExoPlayer configuration. Use enableLogcat() to enable Mux logging.

```kotlin
val out: MuxPlayer = MuxPlayer.Builder(context = this)
  .enableLogcat() // Only applies to Mux. Media3 logging is not touched
  .applyExoConfig {
    // Call ExoPlayer.Builder methods here (but not build()!)
    setHandleAudioBecomingNoisy(true)
  }
  .build()
```

--------------------------------

### Customize Underlying ExoPlayer with applyExoConfig

Source: https://context7.com/muxinc/mux-player-android/llms.txt

Use `applyExoConfig` in Kotlin or `plusExoConfig` in Java to access and configure the ExoPlayer.Builder before the MuxPlayer is built. This is suitable for settings like audio focus, seek increments, and load controls.

```kotlin
val player = MuxPlayer.Builder(context)
    .applyExoConfig {
        setHandleAudioBecomingNoisy(true)   // pause on headphone disconnect
        setSeekBackIncrementMs(10_000)       // 10-second rewind
        setSeekForwardIncrementMs(30_000)    // 30-second fast-forward
        setWakeMode(PowerManager.PARTIAL_WAKE_LOCK)
    }
    .build()
```

```java
MuxPlayer player = new MuxPlayer.Builder(context)
    .plusExoConfig(builder -> {
        builder.setHandleAudioBecomingNoisy(true);
        builder.setSeekBackIncrementMs(10_000);
    })
    .build();
```

--------------------------------

### Release Player Resources

Source: https://context7.com/muxinc/mux-player-android/llms.txt

Releases both the underlying ExoPlayer and the Mux Data SDK in the correct order. Always call release() when the player is no longer needed to avoid memory and resource leaks.

```kotlin
override fun onStop() {
    // Detach from PlayerView first
    playerView.player = null
    // Release all resources
    player?.release()
    player = null
    super.onStop()
}
```

--------------------------------

### MediaItems.builderFromMuxPlaybackId

Source: https://context7.com/muxinc/mux-player-android/llms.txt

Returns a MediaItem.Builder pre-configured for a Mux playback ID, allowing additional media3 customization before building the MediaItem. Accepts the same parameters as fromMuxPlaybackId.

```APIDOC
## MediaItems.builderFromMuxPlaybackId — Creating a Configurable MediaItem.Builder

Returns a `MediaItem.Builder` pre-configured for a Mux playback ID, allowing additional media3 customization (e.g., `setMediaMetadata`) before calling `build()`. Accepts the same parameters as `fromMuxPlaybackId`.

### Usage Example

```kotlin
import androidx.media3.common.MediaMetadata
import com.mux.player.media.MediaItems

val mediaItem = MediaItems.builderFromMuxPlaybackId(
    playbackId    = "YOUR_PLAYBACK_ID",
    maxResolution = PlaybackResolution.HD_720,
)
    .setMediaMetadata(
        MediaMetadata.Builder()
            .setTitle("My Video Title")
            .setArtist("Director Name")
            .build()
    )
    .build()
```
```

--------------------------------

### Enable Smart Cache for Media Segments

Source: https://context7.com/muxinc/mux-player-android/llms.txt

Enables Mux's smart cache for HLS/DASH media segments on disk. This is most effective for short-form content and reduces redundant network requests. Enable logcat to see cache hit/miss logs.

```kotlin
@OptIn(UnstableApi::class)
val player = MuxPlayer.Builder(context)
    .enableSmartCache(true)   // disk cache for media segments
    .enableLogcat(true)        // see cache hit/miss logs in Logcat
    .build()

// Use the player exactly like ExoPlayer
val mediaItem = MediaItems.fromMuxPlaybackId("YOUR_PLAYBACK_ID")
player.setMediaItem(mediaItem)
player.prepare()
player.playWhenReady = true
playerView.player = player
```

--------------------------------

### Create MediaItem from Mux Playback ID

Source: https://context7.com/muxinc/mux-player-android/llms.txt

Use `MediaItems.fromMuxPlaybackId` to create a `MediaItem` for a Mux Video asset. This method supports various configurations including resolution limits, asset clipping, signed playback tokens, DRM tokens, and custom domains.

```kotlin
import com.mux.player.media.MediaItems
import com.mux.player.media.PlaybackResolution
import com.mux.player.media.RenditionOrder

// Basic usage
val basicItem = MediaItems.fromMuxPlaybackId("YOUR_PLAYBACK_ID")

// With resolution limits (cap at 1080p, require at least 480p)
val cappedItem = MediaItems.fromMuxPlaybackId(
    playbackId      = "YOUR_PLAYBACK_ID",
    minResolution   = PlaybackResolution.LD_480,
    maxResolution   = PlaybackResolution.FHD_1080,
    renditionOrder  = RenditionOrder.Descending,   // quality-first adaptive selection
)

// Instant clip: play only seconds 25–35 of the asset
val clipItem = MediaItems.fromMuxPlaybackId(
    playbackId     = "YOUR_PLAYBACK_ID",
    assetStartTime = 25.0,
    assetEndTime   = 35.0,
)

// Signed playback (token required from your backend)
val signedItem = MediaItems.fromMuxPlaybackId(
    playbackId     = "YOUR_PLAYBACK_ID",
    playbackToken  = "JWT_PLAYBACK_TOKEN_FROM_BACKEND",
)

// DRM playback (both tokens required from your backend)
val drmItem = MediaItems.fromMuxPlaybackId(
    playbackId    = "YOUR_PLAYBACK_ID",
    playbackToken = "JWT_PLAYBACK_TOKEN_FROM_BACKEND",
    drmToken      = "JWT_DRM_TOKEN_FROM_BACKEND",
)

// Custom delivery domain
val customDomainItem = MediaItems.fromMuxPlaybackId(
    playbackId = "YOUR_PLAYBACK_ID",
    domain     = "stream.your-custom-domain.com",
)

player.setMediaItem(basicItem)
player.prepare()
player.playWhenReady = true
```

--------------------------------

### Add Mux Maven Repository and SDK Dependency

Source: https://context7.com/muxinc/mux-player-android/llms.txt

Configure your Gradle project to include the Mux Maven repository and the Mux Player SDK. Replace '[Current Version]' with the latest version.

```kotlin
dependencyResolutionManagement {
    repositories {
        maven { url = uri("https://muxinc.jfrog.io/artifactory/default-maven-release-local") }
        google()
        mavenCentral()
    }
}

// app/build.gradle.kts – add SDK dependency
dependencies {
    implementation("com.mux.player:android:[Current Version]")
}
```

--------------------------------

### MediaItems.fromMuxPlaybackId

Source: https://context7.com/muxinc/mux-player-android/llms.txt

Creates a fully configured MediaItem for a Mux Video asset using its playback ID. Supports resolution clamping, rendition order preference, signed playback tokens, DRM tokens, asset clipping, and custom domains.

```APIDOC
## MediaItems.fromMuxPlaybackId — Creating a MediaItem from a Playback ID

A static factory method that builds a fully configured `MediaItem` pointing to a Mux Video asset via its playback ID. Supports resolution clamping, rendition order preference, signed playback tokens, DRM tokens, asset clipping (start/end time), and custom domains.

### Usage Examples

**Basic usage:**
```kotlin
val basicItem = MediaItems.fromMuxPlaybackId("YOUR_PLAYBACK_ID")
```

**With resolution limits:**
```kotlin
val cappedItem = MediaItems.fromMuxPlaybackId(
    playbackId      = "YOUR_PLAYBACK_ID",
    minResolution   = PlaybackResolution.LD_480,
    maxResolution   = PlaybackResolution.FHD_1080,
    renditionOrder  = RenditionOrder.Descending
)
```

**Asset clipping:**
```kotlin
val clipItem = MediaItems.fromMuxPlaybackId(
    playbackId     = "YOUR_PLAYBACK_ID",
    assetStartTime = 25.0,
    assetEndTime   = 35.0
)
```

**Signed playback:**
```kotlin
val signedItem = MediaItems.fromMuxPlaybackId(
    playbackId     = "YOUR_PLAYBACK_ID",
    playbackToken  = "JWT_PLAYBACK_TOKEN_FROM_BACKEND"
)
```

**DRM playback:**
```kotlin
val drmItem = MediaItems.fromMuxPlaybackId(
    playbackId    = "YOUR_PLAYBACK_ID",
    playbackToken = "JWT_PLAYBACK_TOKEN_FROM_BACKEND",
    drmToken      = "JWT_DRM_TOKEN_FROM_BACKEND"
)
```

**Custom delivery domain:**
```kotlin
val customDomainItem = MediaItems.fromMuxPlaybackId(
    playbackId = "YOUR_PLAYBACK_ID",
    domain     = "stream.your-custom-domain.com"
)
```
```

--------------------------------

### MuxPlayer.release

Source: https://context7.com/muxinc/mux-player-android/llms.txt

Releases both the underlying `ExoPlayer` and the Mux Data SDK in the correct order. Always call `release()` when the player is no longer needed to avoid memory and resource leaks.

```APIDOC
## MuxPlayer.release — Releasing Player Resources

### Description
Releases both the underlying `ExoPlayer` and the Mux Data SDK in the correct order. Always call `release()` when the player is no longer needed to avoid memory and resource leaks.

### Method
`release()`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```kotlin
override fun onStop() {
    // Detach from PlayerView first
    playerView.player = null
    // Release all resources
    player?.release()
    player = null
    super.onStop()
}
```

### Response
None

#### Success Response (200)
None

#### Response Example
None
```

--------------------------------

### Add Mux Maven Repository to Gradle

Source: https://github.com/muxinc/mux-player-android/blob/main/README.md

Add the Mux Maven repository to your Gradle project. This is required before adding the SDK dependency. Newer projects declare this in settings.gradle, older projects in the project-level build.gradle.

```kotlin
// in a repositories {} block
maven {
  url = uri("https://muxinc.jfrog.io/artifactory/default-maven-release-local")
}
```

--------------------------------

### MuxPlayer.Builder.enableSmartCache

Source: https://context7.com/muxinc/mux-player-android/llms.txt

Enables Mux's smart cache for HLS/DASH media segments, storing and revalidating them on disk. This is most effective for short-form content and reduces redundant network requests. When enabled, the builder uses `MuxDataSource.Factory` as the upstream data source.

```APIDOC
## MuxPlayer.Builder.enableSmartCache — Smart Segment Caching

### Description
Enables Mux's smart cache, which stores and revalidates HLS/DASH media segments on disk using HTTP cache-control semantics. Smart caching is most effective for short-form content and reduces redundant network requests during repeat playback. When enabled, the builder swaps in `MuxDataSource.Factory` as the upstream data source.

### Method
`enableSmartCache(boolean)`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```kotlin
@OptIn(UnstableApi::class)
val player = MuxPlayer.Builder(context)
    .enableSmartCache(true)   // disk cache for media segments
    .enableLogcat(true)        // see cache hit/miss logs in Logcat
    .build()

// Use the player exactly like ExoPlayer
val mediaItem = MediaItems.fromMuxPlaybackId("YOUR_PLAYBACK_ID")
player.setMediaItem(mediaItem)
player.prepare()
player.playWhenReady = true
playerView.player = player
```

### Response
None

#### Success Response (200)
None

#### Response Example
None
```

--------------------------------

### Add Mux Player SDK Dependency

Source: https://github.com/muxinc/mux-player-android/blob/main/README.md

Add the Mux Player SDK library to your app's dependencies. Replace '[Current Version]' with the actual version number.

```kotlin
implementation("com.mux.player:android:[Current Version]")
```

--------------------------------

### Update Telemetry Metadata at Runtime

Source: https://context7.com/muxinc/mux-player-android/llms.txt

Updates the Mux Data CustomerData on a live player without re-creating it. This is useful when video metadata is loaded asynchronously after the player is already created.

```kotlin
// Later in your code, once you know the video details:
player.updateCustomerData(CustomerData().apply {
    customerVideoData = CustomerVideoData().apply {
        videoId    = "newly-loaded-video-id"
        videoTitle = "Updated Title"
    }
})
```

--------------------------------

### RenditionOrder Enum for Adaptive Bitrate Preference

Source: https://context7.com/muxinc/mux-player-android/llms.txt

The `RenditionOrder` enum controls ExoPlayer's adaptive algorithm. `Descending` prioritizes higher quality for the initial playback experience, potentially at the cost of longer startup times, while `Default` uses Mux's delivery-optimized order.

```kotlin
import com.mux.player.media.RenditionOrder

// RenditionOrder.Descending → prefers highest quality, may take longer to start
// RenditionOrder.Default    → Mux delivery-optimized order (default)

val item = MediaItems.fromMuxPlaybackId(
    playbackId     = "YOUR_PLAYBACK_ID",
    renditionOrder = RenditionOrder.Descending,
)
```

--------------------------------

### PlaybackResolution

Source: https://context7.com/muxinc/mux-player-android/llms.txt

An enum that specifies a resolution floor or ceiling when building a MediaItem. Used to control bandwidth usage and enforce quality floors.

```APIDOC
## PlaybackResolution — Clamping Adaptive Stream Resolution

An enum that specifies a resolution floor or ceiling when building a `MediaItem` via `MediaItems.fromMuxPlaybackId` or `MediaItems.builderFromMuxPlaybackId`. Setting `maxResolution` controls bandwidth usage; `minResolution` enforces a quality floor.

### Available Values

- `PlaybackResolution.LD_480` → "480p"
- `PlaybackResolution.LD_540` → "540p"
- `PlaybackResolution.HD_720` → "720p"
- `PlaybackResolution.FHD_1080` → "1080p"
- `PlaybackResolution.QHD_1440` → "1440p"
- `PlaybackResolution.FOUR_K_2160` → "2160p"

### Usage Example

```kotlin
import com.mux.player.media.PlaybackResolution

val item = MediaItems.fromMuxPlaybackId(
    playbackId    = "YOUR_PLAYBACK_ID",
    minResolution = PlaybackResolution.HD_720,    // never go below 720p
    maxResolution = PlaybackResolution.FHD_1080  // never exceed 1080p
)
```
```

--------------------------------

### PlaybackResolution Enum for Resolution Clamping

Source: https://context7.com/muxinc/mux-player-android/llms.txt

The `PlaybackResolution` enum defines resolution floors and ceilings for `MediaItem` creation. Use `maxResolution` to control bandwidth and `minResolution` to enforce a minimum quality.

```kotlin
import com.mux.player.media.PlaybackResolution

// Available values:
// PlaybackResolution.LD_480    → "480p"
// PlaybackResolution.LD_540    → "540p"
// PlaybackResolution.HD_720    → "720p"
// PlaybackResolution.FHD_1080  → "1080p"
// PlaybackResolution.QHD_1440  → "1440p"
// PlaybackResolution.FOUR_K_2160 → "2160p"

val item = MediaItems.fromMuxPlaybackId(
    playbackId    = "YOUR_PLAYBACK_ID",
    minResolution = PlaybackResolution.HD_720,    // never go below 720p
    maxResolution = PlaybackResolution.FHD_1080,  // never exceed 1080p
)
```

--------------------------------

### MuxPlayer.recordPlayerSize

Source: https://context7.com/muxinc/mux-player-android/llms.txt

Manually reports the player view's pixel dimensions to Mux Data. This is optional, as `MuxPlayer` auto-detects size when a `PlayerView`, `SurfaceView`, or `TextureView` is used. Only call this if you have a custom rendering surface.

```APIDOC
## MuxPlayer.recordPlayerSize — Manual Player Dimension Reporting

### Description
Manually reports the player view's pixel dimensions to Mux Data. This is **optional** — `MuxPlayer` auto-detects size when a `PlayerView`, `SurfaceView`, or `TextureView` is used. Only call this if you have a custom rendering surface.

### Method
`recordPlayerSize(width: Int, height: Int)`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```kotlin
// Report size explicitly when using a custom surface
val widthPx  = customSurface.width
val heightPx = customSurface.height
player.recordPlayerSize(widthPx, heightPx)
```

### Response
None

#### Success Response (200)
None

#### Response Example
None
```

--------------------------------

### MuxPlayer.updateCustomerData

Source: https://context7.com/muxinc/mux-player-android/llms.txt

Updates the Mux Data `CustomerData` on a live player without re-creating it. This is useful when video metadata is loaded asynchronously after the player is already created, such as after an API response.

```APIDOC
## MuxPlayer.updateCustomerData — Updating Telemetry Metadata at Runtime

### Description
Updates the Mux Data `CustomerData` on a live player without re-creating it. Useful when video metadata is loaded asynchronously after the player is already created (e.g., after an API response).

### Method
`updateCustomerData(CustomerData)`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **customerData** (CustomerData) - Required - The updated customer data to apply to the player.

### Request Example
```kotlin
// Later in your code, once you know the video details:
player.updateCustomerData(CustomerData().apply {
    customerVideoData = CustomerVideoData().apply {
        videoId    = "newly-loaded-video-id"
        videoTitle = "Updated Title"
    }
})
```

### Response
None

#### Success Response (200)
None

#### Response Example
None
```

--------------------------------

### Manually Report Player Dimensions

Source: https://context7.com/muxinc/mux-player-android/llms.txt

Manually reports the player view's pixel dimensions to Mux Data. This is optional and only needed if you have a custom rendering surface, as MuxPlayer auto-detects size with standard views.

```kotlin
// Report size explicitly when using a custom surface
val widthPx  = customSurface.width
val heightPx = customSurface.height
player.recordPlayerSize(widthPx, heightPx)
```

--------------------------------

### MuxPlayer.Builder.addMonitoringData

Source: https://context7.com/muxinc/mux-player-android/llms.txt

Attaches `CustomerData` to the player for Mux Data reporting. This metadata appears in the Mux Data dashboard and can be used for filtering and segmentation. Calling `addMonitoringData` multiple times merges the data, with later calls overriding individual fields without clearing unset ones.

```APIDOC
## MuxPlayer.Builder.addMonitoringData — Mux Data Telemetry Metadata

### Description
Attaches `CustomerData` to the player for Mux Data reporting. This metadata appears in the Mux Data dashboard and can be used for filtering and segmentation. Calling `addMonitoringData` multiple times merges the data — later calls override individual fields without clearing unset ones.

### Method
`addMonitoringData(CustomerData)`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **customerData** (CustomerData) - Required - The customer data to attach for Mux Data reporting.

### Request Example
```kotlin
import com.mux.stats.sdk.core.model.CustomData
import com.mux.stats.sdk.core.model.CustomerData
import com.mux.stats.sdk.core.model.CustomerVideoData
import com.mux.stats.sdk.core.model.CustomerViewData
import com.mux.stats.sdk.core.util.UUID

val player = MuxPlayer.Builder(context)
    .addMonitoringData(CustomerData().apply {
        customerViewData = CustomerViewData().apply {
            viewSessionId = UUID.generateUUID()   // unique per play attempt
        }
        customerVideoData = CustomerVideoData().apply {
            videoId     = "my-video-id-001"
            videoSeries = "Product Demos"
            videoTitle  = "SDK Overview"
        }
        customData = CustomData().apply {
            customData1 = "experiment=variantB"
            customData2 = "env=production"
        }
    })
    .build()
```

### Response
None

#### Success Response (200)
None

#### Response Example
None
```

--------------------------------

### Add Mux Data Telemetry Metadata

Source: https://context7.com/muxinc/mux-player-android/llms.txt

Attaches CustomerData to the player for Mux Data reporting, which appears in the Mux Data dashboard for filtering and segmentation. Calling addMonitoringData multiple times merges data, with later calls overriding individual fields.

```kotlin
import com.mux.stats.sdk.core.model.CustomData
import com.mux.stats.sdk.core.model.CustomerData
import com.mux.stats.sdk.core.model.CustomerVideoData
import com.mux.stats.sdk.core.model.CustomerViewData
import com.mux.stats.sdk.core.util.UUID

val player = MuxPlayer.Builder(context)
    .addMonitoringData(CustomerData().apply {
        customerViewData = CustomerViewData().apply {
            viewSessionId = UUID.generateUUID()   // unique per play attempt
        }
        customerVideoData = CustomerVideoData().apply {
            videoId     = "my-video-id-001"
            videoSeries = "Product Demos"
            videoTitle  = "SDK Overview"
        }
        customData = CustomData().apply {
            customData1 = "experiment=variantB"
            customData2 = "env=production"
        }
    })
    .build()
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.