react-native-media3-player 1.0.0 → 2.1.0

package/README.md

@@ -1,18 +1,21 @@
 # 📽️ Media3Player
 
-> A lightweight, high-performance React Native video player powered by Android Media3 (ExoPlayer). Fully customizable and supports autoplay, mute, and event handling. This is **Android** only package.
+> A lightweight, high-performance React Native video player powered by Android Media3 (ExoPlayer). Fully customizable with support for autoplay, mute, event handling, and automatic stream type detection (DASH, HLS, MP4). This is an **Android** only package.
 
 ---
 
 ## Table of Contents
-- [Installation](#installation)  
-- [Usage](#usage)  
-- [Props](#props)  
-- [Events](#events)  
-- [TypeScript Support](#typescript-support)  
-- [Examples](#examples)  
-- [Screenshots](#screenshots)  
-- [Contributing](#contributing)  
+
+- [Installation](#installation)
+- [Usage](#usage)
+- [Props](#props)
+- [Stream Type Detection](#stream-type-detection)
+- [DRM Support (Widevine)](#drm-support-widevine)
+- [Events](#events)
+- [TypeScript Support](#typescript-support)
+- [Examples](#examples)
+- [Screenshots](#screenshots)
+- [Contributing](#contributing)
 - [License](#license)
 
 ---
@@ -20,38 +23,86 @@
 ## Installation
 
 **Install via npm:**
+
 ```bash
 npm install react-native-media3-player
 ```
 
 **Or yarn:**
+
 ```bash
 yarn add react-native-media3-player
 ```
 
-> Requires **React Native >= 0.70** 
+> Requires **React Native >= 0.70**
+
+---
+
+**Note:** To use a specific Media3 version, add or update the following in your **android/build.gradle** (Project-level) file:
+
+```groovy
+buildscript {
+    ext {
+        media3Version = "1.4.1" // Set your desired Media3 version
+    }
+}
+```
+
+Be sure to sync your project after making this change.
 
 ---
 
 ## Usage
 
+**Basic (non-DRM):**
+
 ```jsx
 import React from 'react';
-import { View } from 'react-native';
+import {View} from 'react-native';
 import Media3Player from 'react-native-media3-player';
 
 export default function App() {
   return (
-    <View style={{ flex: 1 }}>
+    <View style={{flex: 1}}>
       <Media3Player
-        style={{ width: '100%', height: 250 }}
-        source={{ uri: 'https://example.com/video.mp4' }}
+        style={{width: '100%', height: 250}}
+        source={{uri: 'https://example.com/video.mp4'}}
         autoplay={true}
         play={true}
         mute={false}
         onReady={() => console.log('Player is ready')}
         onEnd={() => console.log('Video ended')}
-        onError={(error) => console.log('Player error:', error.message)}
+        onError={error => console.log('Player error:', error.message)}
+      />
+    </View>
+  );
+}
+```
+
+**DRM-protected content (Widevine):**
+
+```jsx
+import React from 'react';
+import {View} from 'react-native';
+import Media3Player from 'react-native-media3-player';
+
+export default function App() {
+  return (
+    <View style={{flex: 1}}>
+      <Media3Player
+        style={{width: '100%', height: 250}}
+        source={{
+          uri: 'https://storage.googleapis.com/shaka-demo-assets/angel-one-widevine/dash.mpd',
+          type: 'dash',
+          drm: {
+            licenseUrl: 'https://cwip-shaka-proxy.appspot.com/no_auth',
+          },
+        }}
+        autoplay={true}
+        play={true}
+        onReady={() => console.log('Player is ready')}
+        onEnd={() => console.log('Video ended')}
+        onError={error => console.log('Player error:', error.message)}
       />
     </View>
   );
@@ -62,23 +113,133 @@ export default function App() {
 
 ## Props
 
-| Prop       | Type                        | Default  | Description |
-|------------|-----------------------------|----------|-------------|
-| `source`   | `{ uri: string }`           | required | Video source object. Must include a valid URI. |
-| `autoplay` | `boolean`                   | `false`  | Automatically start playback when the video is ready. |
-| `play`     | `boolean`                   | `false`  | Controls whether the player is playing. Overrides autoplay. |
-| `mute`     | `boolean`                   | `false`  | Mutes or unmutes the video. |
-| `style`    | `ViewStyle` or `ViewStyle[]` | `{ width: '100%', height: 250 }` | Styling for the player container. |
+| Prop       | Type                         | Default                          | Description                                                              |
+| ---------- | ---------------------------- | -------------------------------- | ------------------------------------------------------------------------ |
+| `source`   | `Source`                     | required                         | Video source object. Must include a valid `uri`. Supports optional `drm` config. |
+| `autoplay` | `boolean`                    | `false`                          | Automatically start playback when the video is ready.                    |
+| `play`     | `boolean`                    | `false`                          | Controls whether the player is playing. Overrides autoplay.              |
+| `mute`     | `boolean`                    | `false`                          | Mutes or unmutes the video.                                              |
+| `style`    | `ViewStyle` or `ViewStyle[]` | `{ width: '100%', height: 250 }` | Styling for the player container.                                        |
+
+### `Source` Object
+
+| Property | Type                         | Required | Description                                                                                                  |
+| -------- | ---------------------------- | -------- | ------------------------------------------------------------------------------------------------------------ |
+| `uri`    | `string`                     | Yes      | The URI of the media to play (MP4, DASH, HLS, etc.).                                                         |
+| `type`   | `'dash' \| 'hls' \| 'mp4'`  | No       | Explicitly set the stream type. Defaults to `'mp4'`. If omitted, the player auto-detects the type from the URI. |
+| `drm`    | `DRMConfig`                  | No       | DRM configuration for protected content.                                                                     |
+
+### `DRMConfig` Object
+
+| Property     | Type                              | Required | Description                                           |
+| ------------ | --------------------------------- | -------- | ----------------------------------------------------- |
+| `licenseUrl` | `string`                          | Yes      | The Widevine license server URL.                      |
+| `headers`    | `Array<{ key: string, value: string }>` | No       | Custom headers to include in the DRM license request. |
+
+---
+
+## Stream Type Detection
+
+The player supports **automatic stream type detection** based on the media URI. It inspects the file extension and known manifest patterns (`.mpd` for DASH, `.m3u8` for HLS) to choose the correct media source.
+
+You can also **explicitly set the stream type** using the `type` property in the `source` prop. This is useful when the URI does not contain a recognizable extension (e.g., signed URLs or token-based endpoints).
+
+### Supported Stream Types
+
+| `type` Value | Format              | Description                           |
+| ------------ | ------------------- | ------------------------------------- |
+| `'dash'`     | DASH (`.mpd`)       | Dynamic Adaptive Streaming over HTTP  |
+| `'hls'`      | HLS (`.m3u8`)       | HTTP Live Streaming                   |
+| `'mp4'`      | Progressive (`.mp4`)| Standard progressive HTTP download    |
+
+### Auto-Detection (Recommended)
+
+If the URI contains a known extension, you can omit `type` entirely:
+
+```jsx
+<Media3Player
+  source={{uri: 'https://example.com/stream/manifest.mpd'}}
+  autoplay
+  play
+/>
+```
+
+The player will automatically detect this as a DASH stream.
+
+### Explicit Type Override
+
+Use `type` when the URI does not have a recognizable extension:
+
+```jsx
+<Media3Player
+  source={{
+    uri: 'https://cdn.example.com/stream?token=abc123',
+    type: 'hls',
+  }}
+  autoplay
+  play
+/>
+```
+
+---
+
+## DRM Support (Widevine)
+
+This library supports **Widevine DRM** for playing protected DASH streams on Android. To enable DRM, pass a `drm` object inside the `source` prop.
+
+### Basic DRM Playback
+
+```jsx
+<Media3Player
+  source={{
+    uri: 'https://storage.googleapis.com/wvmedia/cenc/h264/tears/tears.mpd',
+    drm: {
+      licenseUrl: 'https://proxy.uat.widevine.com/proxy?provider=widevine_test',
+    },
+  }}
+  autoplay
+  play
+/>
+```
+
+### DRM with Custom License Headers
+
+Some license servers require authentication tokens or custom headers. Pass them as an array of `{ key, value }` objects:
+
+```jsx
+<Media3Player
+  source={{
+    uri: 'https://example.com/protected-stream/manifest.mpd',
+    drm: {
+      licenseUrl: 'https://license.example.com/widevine',
+      headers: [
+        {key: 'Authorization', value: 'Bearer <your-token>'},
+        {key: 'X-Custom-Header', value: 'custom-value'},
+      ],
+    },
+  }}
+  autoplay
+  play
+  onError={e => console.error('DRM error:', e.message)}
+/>
+```
+
+### Notes
+
+- DRM is currently supported on **Android only** (Widevine L1/L3 depending on device).
+- The `source.uri` should point to a DASH (`.mpd`) stream encrypted with Widevine.
+- Multi-session DRM is enabled by default for streams that require it.
+- If the license request fails, the `onError` callback will fire with the error details.
 
 ---
 
 ## Events
 
-| Event      | Callback Signature                | Description |
-|------------|----------------------------------|-------------|
-| `onReady`  | `() => void`                     | Fired when the player is ready to play. |
-| `onEnd`    | `() => void`                     | Fired when the video reaches the end. |
-| `onError`  | `(error: { message: string }) => void` | Fired when the player encounters an error. Error object includes a `message` property. |
+| Event     | Callback Signature                     | Description                                                                            |
+| --------- | -------------------------------------- | -------------------------------------------------------------------------------------- |
+| `onReady` | `() => void`                           | Fired when the player is ready to play.                                                |
+| `onEnd`   | `() => void`                           | Fired when the video reaches the end.                                                  |
+| `onError` | `(error: { message: string }) => void` | Fired when the player encounters an error. Error object includes a `message` property. |
 
 ---
 
@@ -88,18 +249,39 @@ This library includes TypeScript definitions. Example:
 
 ```ts
 import React from 'react';
-import { ViewStyle } from 'react-native';
-import Media3Player, { Media3PlayerProps } from 'react-native-media3-player';
+import {ViewStyle} from 'react-native';
+import Media3Player, {Media3PlayerProps} from 'react-native-media3-player';
 
 const props: Media3PlayerProps = {
-  source: { uri: 'https://example.com/video.mp4' },
+  source: {uri: 'https://example.com/video.mp4'},
   autoplay: true,
   play: true,
   mute: false,
-  style: { width: '100%', height: 250 },
+  style: {width: '100%', height: 250},
   onReady: () => console.log('Ready'),
   onEnd: () => console.log('End'),
-  onError: (err) => console.log(err.message),
+  onError: err => console.log(err.message),
+};
+```
+
+**With DRM and explicit stream type:**
+
+```ts
+const drmProps: Media3PlayerProps = {
+  source: {
+    uri: 'https://storage.googleapis.com/shaka-demo-assets/angel-one-widevine/dash.mpd',
+    type: 'dash',
+    drm: {
+      licenseUrl: 'https://cwip-shaka-proxy.appspot.com/no_auth',
+      headers: [
+        {key: 'Authorization', value: 'Bearer my-token'},
+      ],
+    },
+  },
+  autoplay: true,
+  play: true,
+  style: {width: '100%', height: 250},
+  onError: err => console.log('DRM Error:', err.message),
 };
 ```
 
@@ -108,26 +290,84 @@ const props: Media3PlayerProps = {
 ## Examples
 
 **Basic Player:**
+
 ```jsx
-<Media3Player source={{ uri: 'https://example.com/video.mp4' }} />
+<Media3Player source={{uri: 'https://example.com/video.mp4'}} />
 ```
 
 **Autoplay & Mute:**
+
 ```jsx
-<Media3Player
-  source={{ uri: 'https://example.com/video.mp4' }}
-  autoplay
-  mute
-/>
+<Media3Player source={{uri: 'https://example.com/video.mp4'}} autoplay mute />
 ```
 
 **Event Handling:**
+
 ```jsx
 <Media3Player
-  source={{ uri: 'https://example.com/video.mp4' }}
+  source={{uri: 'https://example.com/video.mp4'}}
   onReady={() => console.log('Ready')}
   onEnd={() => console.log('End')}
-  onError={(err) => console.error(err.message)}
+  onError={err => console.error(err.message)}
+/>
+```
+
+**HLS Stream:**
+
+```jsx
+<Media3Player
+  source={{
+    uri: 'https://example.com/live/stream.m3u8',
+    type: 'hls',
+  }}
+  autoplay
+  play
+/>
+```
+
+**DASH Stream (auto-detected):**
+
+```jsx
+<Media3Player
+  source={{uri: 'https://example.com/video/manifest.mpd'}}
+  autoplay
+  play
+/>
+```
+
+**Widevine DRM Stream:**
+
+```jsx
+<Media3Player
+  source={{
+    uri: 'https://storage.googleapis.com/wvmedia/cenc/h264/tears/tears.mpd',
+    type: 'dash',
+    drm: {
+      licenseUrl: 'https://proxy.uat.widevine.com/proxy?provider=widevine_test',
+    },
+  }}
+  autoplay
+  play
+/>
+```
+
+**DRM with License Headers:**
+
+```jsx
+<Media3Player
+  source={{
+    uri: 'https://example.com/protected/manifest.mpd',
+    type: 'dash',
+    drm: {
+      licenseUrl: 'https://license.example.com/widevine',
+      headers: [
+        {key: 'Authorization', value: 'Bearer my-token'},
+      ],
+    },
+  }}
+  autoplay
+  play
+  onError={err => console.error('DRM Error:', err.message)}
 />
 ```
 
@@ -135,13 +375,13 @@ const props: Media3PlayerProps = {
 
 ## Contributing
 
-We welcome contributions!  
+We welcome contributions!
 
-1. Fork the repo  
-2. Create a branch (`git checkout -b feature/new-feature`)  
-3. Commit your changes (`git commit -m 'Add feature'`)  
-4. Push to the branch (`git push origin feature/new-feature`)  
-5. Open a Pull Request  
+1. Fork the repo
+2. Create a branch (`git checkout -b feature/new-feature`)
+3. Commit your changes (`git commit -m 'Add feature'`)
+4. Push to the branch (`git push origin feature/new-feature`)
+5. Open a Pull Request
 
 > Please follow [Semantic Versioning](https://semver.org/) for commits.
 
@@ -150,4 +390,3 @@ We welcome contributions!
 ## License
 
 MIT © [Mohammad Rehan](https://github.com/mdRehan991)
-

package/android/build.gradle

@@ -5,6 +5,11 @@ apply plugin: "org.jetbrains.kotlin.android"
 // Apply the React Native plugin to enable React Native integration
 apply plugin: "com.facebook.react"
 
+// Use app-defined version if available, otherwise fallback
+def media3Version = rootProject.ext.has("media3Version")
+        ? rootProject.ext.media3Version
+        : "1.4.1"
+
 android {
     // Set the namespace for the generated R class and manifest
     namespace "com.rnmedia3playerdemo"
@@ -46,9 +51,17 @@ dependencies {
     implementation "org.jetbrains.kotlin:kotlin-stdlib"
 
     // AndroidX Media3 ExoPlayer, UI components, and Common classes
-    implementation "androidx.media3:media3-exoplayer:1.4.1"
-    implementation "androidx.media3:media3-ui:1.4.1"
-    implementation "androidx.media3:media3-common:1.4.1"
+    implementation "androidx.media3:media3-exoplayer:$media3Version"
+    implementation "androidx.media3:media3-ui:$media3Version"
+    implementation "androidx.media3:media3-common:$media3Version"
+
+    // streaming formats
+    implementation "androidx.media3:media3-exoplayer-dash:$media3Version"
+    implementation "androidx.media3:media3-exoplayer-hls:$media3Version"
+    implementation "androidx.media3:media3-exoplayer-smoothstreaming:$media3Version"
+
+    // OkHttp data source for Media3 (DRM/auth/advanced networking)
+    implementation "androidx.media3:media3-datasource-okhttp:$media3Version"
 
     // Android core utilities and extensions (KTX)
     implementation "androidx.core:core-ktx:1.13.1"

package/android/src/main/java/com/rnmedia3playerdemo/Media3PlayerView.kt

@@ -14,6 +14,14 @@ import com.facebook.react.bridge.ReactContext
 import com.facebook.react.bridge.WritableMap
 import com.facebook.react.uimanager.UIManagerHelper
 import com.facebook.react.uimanager.events.Event
+import androidx.media3.common.C
+import androidx.media3.common.util.Util
+import androidx.media3.datasource.DefaultHttpDataSource
+import androidx.media3.exoplayer.source.MediaSource
+import androidx.media3.exoplayer.source.ProgressiveMediaSource
+import androidx.media3.exoplayer.dash.DashMediaSource
+import androidx.media3.exoplayer.hls.HlsMediaSource
+import androidx.media3.exoplayer.smoothstreaming.SsMediaSource
 
 /**
  * Custom view that wraps ExoPlayer and PlayerView, integrating with React Native.
@@ -83,19 +91,174 @@ class Media3PlayerView(context: Context) : FrameLayout(context) {
     }
 
     /**
-     * Sets the video source from a URI string and prepares the player.
-     * @param uriString Video source URI as a string
+     * Maps a media type string from JavaScript to one of Media3's content type constants.
+     *
+     * This function interprets the "type" property provided from React Native JS props ("dash", "hls", "mp4")
+     * and translates it to the corresponding Media3 content type constant used by ExoPlayer.
+     * Returns null if the string is null, empty, or does not match a known type.
+     *
+     * @param type Optional string type from JS ("dash", "hls", "mp4")
+     * @return Media3 content type constant (C.CONTENT_TYPE_DASH, etc.), or null if unrecognized
      */
-    fun setSource(uriString: String?) {
+    private fun mapTypeFromJS(type: String?): Int? {
+        return when (type?.lowercase()) {
+            "dash" -> C.CONTENT_TYPE_DASH
+            "hls" -> C.CONTENT_TYPE_HLS
+            "mp4" -> C.CONTENT_TYPE_OTHER
+            else -> null
+        }
+    }
+
+    /**
+     * Infers the content type of a given URI for media playback.
+     *
+     * This method first uses Media3's built-in Util.inferContentType to try
+     * to detect the type (DASH, HLS, SmoothStreaming, or Other) based on file extension or URI.
+     * If this detection fails (returns CONTENT_TYPE_OTHER), it falls back to checking
+     * for well-known streaming manifest extensions (.mpd for DASH, .m3u8 for HLS)
+     * in the URI string. This fallback is important for cases where extensions are
+     * not present (e.g. signed URLs or tokens).
+     *
+     * @param uri The Uri of the media source.
+     * @return The detected content type as one of C.CONTENT_TYPE_* constants.
+     */
+    private fun inferContentTypeSafe(uri: Uri): Int {
+
+        // Use Media3's built-in Util.inferContentType to try to detect the type.
+        val detectedType = Util.inferContentType(uri)
+
+        // If Media3 was able to determine the type, return it early.
+        if (detectedType != C.CONTENT_TYPE_OTHER) {
+            return detectedType
+        }
+
+        // Convert the Uri to a string
+        val url = uri.toString()
+
+        // Fallback: manually check for known manifest extensions in the URL
+        // This helps handle sources where the content type can't be inferred automatically.
+        return when {
+            url.contains(".mpd", ignoreCase = true) -> C.CONTENT_TYPE_DASH
+            url.contains(".m3u8", ignoreCase = true) -> C.CONTENT_TYPE_HLS
+            else -> C.CONTENT_TYPE_OTHER
+        }
+    }
+
+    /**
+     * Builds a MediaSource instance required by ExoPlayer based on the content type of the given URI.
+     * Handles DASH, HLS, SmoothStreaming, and generic progressive streams.
+     *
+     * @param uri The Uri of the media to play.
+     * @param mediaItem The MediaItem (with possible DRM/config) for playback.
+     * @return The constructed MediaSource for the ExoPlayer.
+     */
+    private fun buildMediaSource(
+        uri: Uri,
+        mediaItem: MediaItem,
+        type: String?
+    ): MediaSource {
+
+        // Create a DefaultHttpDataSourceFactory for the MediaSource.
+        // This is used to fetch the media content from the network.
+        val dataSourceFactory = DefaultHttpDataSource.Factory()
+
+        // Check if a type was explicitly passed from JS (e.g., "hls", "dash", "mp4") and map to Media3 type constant.
+        val overrideType = mapTypeFromJS(type)
+        // Otherwise, infer the content type from the URI (file extension or stream manifest).
+        val detectedType = inferContentTypeSafe(uri)
+        // Use the JS override type if available, else fall back to detected type.
+        val finalType = overrideType ?: detectedType
+
+        // Log the content type detection process for debugging purposes.
+        Log.d(
+            "Media3Player",
+            "Type → override: $overrideType detected: $detectedType final: $finalType url: $uri"
+        )
+
+        // Determine content type and return the appropriate MediaSource.
+        // This is used to create the appropriate MediaSource for the ExoPlayer.
+        return when (finalType) {
+            // DASH (MPD) stream
+            C.CONTENT_TYPE_DASH -> {
+                DashMediaSource.Factory(dataSourceFactory)
+                    .createMediaSource(mediaItem)
+            }
+            // HLS (M3U8) stream
+            C.CONTENT_TYPE_HLS -> {
+                HlsMediaSource.Factory(dataSourceFactory)
+                    .createMediaSource(mediaItem)
+            }
+            // SmoothStreaming (ISM) stream
+            C.CONTENT_TYPE_SS -> {
+                SsMediaSource.Factory(dataSourceFactory)
+                    .createMediaSource(mediaItem)
+            }
+            // Progressive HTTP file (MP4, MP3, etc.)
+            C.CONTENT_TYPE_OTHER -> {
+                ProgressiveMediaSource.Factory(dataSourceFactory)
+                    .createMediaSource(mediaItem)
+            }
+            // Fallback to progressive for unknown types
+            else -> {
+                ProgressiveMediaSource.Factory(dataSourceFactory)
+                    .createMediaSource(mediaItem)
+            }
+        }
+    }
+
+
+    /**
+     * Sets the video source (with optional DRM support) and prepares the player.
+     * Called from the ViewManager when the JS "source" prop changes.
+     *
+     * @param uriString The URI of the media source to play.
+     * @param licenseUrl If provided, enables DRM playback with this license URL.
+     * @param headers Optional headers to add to DRM license requests.
+     */
+    fun setSource(
+        uriString: String?,
+        type: String?,
+        licenseUrl: String?,
+        headers: Map<String, String>?
+    ) {
+        // Return early if no valid URI is provided
         if (uriString.isNullOrEmpty()) return
+        
+        // Store the URI string for reference
         sourceUri = uriString
 
-        // Ensure player is initialized
+        // Ensure the ExoPlayer instance is initialized before use
         initializePlayer()
 
-        // Set and prepare the media item for playback
-        val item = MediaItem.fromUri(Uri.parse(uriString))
-        exoPlayer?.setMediaItem(item)
+        // Parse the URI string into a Uri object
+        val uri = Uri.parse(uriString)
+
+        // Build the MediaItem, adding DRM configuration if a license URL is given.
+        // This includes setting the license URL and multi-session support for DRM streams.
+        // If no license URL is provided, a simple MediaItem is created from the URI.
+        val mediaItem =
+            if (!licenseUrl.isNullOrEmpty()) {
+                val drmBuilder = MediaItem.DrmConfiguration.Builder(C.WIDEVINE_UUID)
+                    .setLicenseUri(licenseUrl) // set the license URL
+                    .setMultiSession(true) // allow multiple DRM sessions if the stream requires them
+
+                headers?.let {
+                    drmBuilder.setLicenseRequestHeaders(it)
+                }
+
+                MediaItem.Builder()
+                    .setUri(uri)
+                    .setDrmConfiguration(drmBuilder.build())
+                    .build()
+            } else {
+                // No DRM: simple MediaItem from URI
+                MediaItem.fromUri(uri)
+            }
+
+        // Build the appropriate MediaSource (handles progressive, DASH/HLS/SmoothStreaming)
+        // and assign it to ExoPlayer. Prepare ExoPlayer for playback.
+        val mediaSource = buildMediaSource(uri, mediaItem, type)
+        exoPlayer?.setMediaSource(mediaSource)
         exoPlayer?.prepare()
     }
 

package/android/src/main/java/com/rnmedia3playerdemo/Media3PlayerViewManager.kt

@@ -45,14 +45,36 @@ class Media3PlayerViewManager :
     }
 
     /**
-     * Sets the "source" property on the Media3PlayerView.
-     * Reads the "uri" string from the passed ReadableMap and loads it into the native view.
+     * Handles the "source" prop for Media3PlayerView.
+     * Extracts the "uri", optional DRM license URL, and headers from the ReadableMap and forwards
+     * them to the view for loading the media source and DRM configuration.
      */
     @ReactProp(name = "source")
     override fun setSource(view: Media3PlayerView, source: ReadableMap?) {
         val uri = source?.getString("uri")
+        val type = source?.getString("type")
+        var licenseUrl: String? = null
+        var headers: Map<String, String>? = null
+        val drmMap = source?.getMap("drm")
+
+        if (drmMap != null) {
+            licenseUrl = drmMap.getString("licenseUrl")
+            val headersArray = drmMap.getArray("headers")
+            if (headersArray != null) {
+                val map = mutableMapOf<String, String>()
+                for (i in 0 until headersArray.size()) {
+                    val entry = headersArray.getMap(i)
+                    val key = entry?.getString("key")
+                    val value = entry?.getString("value")
+                    if (key != null && value != null) {
+                        map[key] = value
+                    }
+                }
+                headers = map
+            }
+        }
         if (!uri.isNullOrEmpty()) {
-            view.setSource(uri)
+            view.setSource(uri, type, licenseUrl, headers)
         }
     }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-media3-player",
-  "version": "1.0.0",
+  "version": "2.1.0",
   "description": "React Native Media3 Player component for Android (ExoPlayer 3 integration).",
   "main": "index.js",
   "react-native": "index.js",

package/src/Media3PlayerNativeComponent.ts

@@ -1,10 +1,27 @@
 // Import the base ViewProps type from React Native to extend the native component's props
 import type {ViewProps} from 'react-native';
 // Import the DirectEventHandler type used for native-to-JS event callback typings
-import type {DirectEventHandler} from 'react-native/Libraries/Types/CodegenTypes';
+import type {DirectEventHandler, WithDefault} from 'react-native/Libraries/Types/CodegenTypes';
 // Import codegenNativeComponent to register the native UI component for use in React Native
 import codegenNativeComponent from 'react-native/Libraries/Utilities/codegenNativeComponent';
 
+type HeaderEntry = Readonly<{
+  key: string;
+  value: string;
+}>;
+
+type DRMConfig = Readonly<{
+  licenseUrl: string;
+  headers?: ReadonlyArray<HeaderEntry>;
+}>;
+// Source defines the media source for the player component.
+// - uri: The URI of the media to be played (required).
+// - drm: (Optional) DRM configuration for protected content.
+type Source = Readonly<{
+  uri: string;
+  type?: WithDefault<'dash' | 'hls' | 'mp4', 'mp4'>;
+  drm?: DRMConfig;
+}>;
 // Event type emitted when the player is ready
 type OnReadyEvent = Readonly<{}>;
 // Event type emitted when playback reaches the end
@@ -17,7 +34,7 @@ type OnErrorEvent = Readonly<{
 // Props supported by the native Media3PlayerView component
 export interface NativeProps extends ViewProps {
   // Source URI for the media to play
-  source?: Readonly<{uri: string}>;
+  source?: Source;
   // Whether playback should start automatically when ready
   autoplay?: boolean;
   // Whether playback should currently be running (true = play, false = pause)