react-native-nitro-player 0.3.0-alpha.8 → 0.4.0

package/README.md

@@ -18,6 +18,91 @@ Make sure you have these installed:
 npm install react-native-nitro-modules
 ```
 
+## API Reference
+
+
+### React Hooks
+
+| Name                          | Platform | Description                                                                     |
+| ----------------------------- | -------- | ------------------------------------------------------------------------------- |
+| `useOnChangeTrack`            | Both     | Returns current track and change reason. Updates automatically.                 |
+| `useOnPlaybackStateChange`    | Both     | Returns current playback state (playing/paused) and change reason.              |
+| `useOnPlaybackProgressChange` | Both     | Returns real-time playback progress, duration, and seek status.                 |
+| `useOnSeek`                   | Both     | Returns information about the last seek event (position/duration).              |
+| `useNowPlaying`               | Both     | Returns complete player state (track, state, duration, playlist) in one object. |
+| `useActualQueue`              | Both     | Returns the efficient playback queue including temporary tracks.                |
+| `usePlaylist`                 | Both     | Manages playlist state, providing access to all playlists and tracks.           |
+| `useEqualizer`                | Both     | Controls the 5-band equalizer, including presets and individual band gains.     |
+| `useAndroidAutoConnection`    | Both     | Monitors Android Auto connection status.                                        |
+| `useAudioDevices`             | Android  | Returns list of available audio output devices.                                 |
+| `useDownloadProgress`         | Both     | Tracks download progress for tracks. Returns progress map and overall status.   |
+| `useDownloadedTracks`         | Both     | Returns all downloaded tracks and playlists with query helpers.                 |
+
+### TrackPlayer Methods
+
+| Name                        | Platform | Description                                                         |
+| --------------------------- | -------- | ------------------------------------------------------------------- |
+| `play()`                    | Both     | Resumes playback.                                                   |
+| `pause()`                   | Both     | Pauses playback.                                                    |
+| `playSong(id, playlistId?)` | Both     | **Async**. Plays a specific song, optionally from a playlist.       |
+| `skipToNext()`              | Both     | Skips to the next track in the queue.                               |
+| `skipToPrevious()`          | Both     | Skips to the previous track.                                        |
+| `seek(position)`            | Both     | Seeks to a specific time position in seconds.                       |
+| `setVolume(0-100)`          | Both     | Sets playback volume (0-100).                                       |
+| `setRepeatMode(mode)`       | Both     | Sets repeat mode (`off`, `track`, `Playlist`).                      |
+| `addToUpNext(id)`           | Both     | **Async**. Adds a track to the "up next" queue (FIFO).              |
+| `playNext(id)`              | Both     | **Async**. Adds a track to the "play next" stack (LIFO).            |
+| `getActualQueue()`          | Both     | **Async**. Gets the full playback queue including temporary tracks. |
+| `getState()`                | Both     | **Async**. Gets the current player state immediately.               |
+| `skipToIndex(index)`        | Both     | **Async**. Skips to a specific index in the actual queue.           |
+| `configure(config)`         | Both     | Configures player settings (Android Auto, etc.).                    |
+| `isAndroidAutoConnected()`  | Both     | Checks if Android Auto is currently connected.                      |
+
+### PlayerQueue Methods
+
+| Name                                    | Platform | Description                                             |
+| --------------------------------------- | -------- | ------------------------------------------------------- |
+| `createPlaylist(name, ...)`             | Both     | Creates a new playlist. Returns ID.                     |
+| `deletePlaylist(id)`                    | Both     | Deletes a playlist by ID.                               |
+| `updatePlaylist(id, ...)`               | Both     | Updates playlist metadata (name, description, artwork). |
+| `getPlaylist(id)`                       | Both     | Gets a specific playlist object.                        |
+| `getAllPlaylists()`                     | Both     | Gets all available playlists.                           |
+| `loadPlaylist(id)`                      | Both     | Loads a playlist for playback.                          |
+| `getCurrentPlaylistId()`                | Both     | Gets the ID of the currently playing playlist.          |
+| `addTrackToPlaylist(pid, track)`        | Both     | Adds a track to a playlist.                             |
+| `addTracksToPlaylist(pid, tracks)`      | Both     | Adds multiple tracks to a playlist.                     |
+| `removeTrackFromPlaylist(pid, tid)`     | Both     | Removes a track from a playlist.                        |
+| `reorderTrackInPlaylist(pid, tid, idx)` | Both     | Moves a track to a new position in the playlist.        |
+
+### Platform-Specific APIs
+
+| Name                                     | Platform | Description                                       |
+| ---------------------------------------- | -------- | ------------------------------------------------- |
+| `AudioDevices.getAudioDevices()`         | Android  | Returns list of available audio devices.          |
+| `AudioDevices.setAudioDevice(id)`        | Android  | Sets the active audio output device.              |
+| `AudioRoutePicker.showRoutePicker()`     | iOS      | Opens the native AirPlay/Audio Route picker menu. |
+| `AndroidAutoMediaLibraryHelper.set(...)` | Android  | Sets custom folder structure for Android Auto.    |
+| `AndroidAutoMediaLibraryHelper.clear()`  | Android  | Resets Android Auto structure to default.         |
+
+### DownloadManager Methods
+
+| Name                                   | Platform | Description                                                   |
+| -------------------------------------- | -------- | ------------------------------------------------------------- |
+| `configure(config)`                    | Both     | Configures download settings (storage, concurrency, etc.).    |
+| `downloadTrack(track, playlistId?)`    | Both     | **Async**. Downloads a track. Returns download ID.            |
+| `downloadPlaylist(playlistId, tracks)` | Both     | **Async**. Downloads all tracks in a playlist.                |
+| `pauseDownload(downloadId)`            | Both     | **Async**. Pauses an active download.                         |
+| `resumeDownload(downloadId)`           | Both     | **Async**. Resumes a paused download.                         |
+| `cancelDownload(downloadId)`           | Both     | **Async**. Cancels a download.                                |
+| `isTrackDownloaded(trackId)`           | Both     | Checks if a track is downloaded.                              |
+| `getAllDownloadedTracks()`             | Both     | Gets all downloaded tracks.                                   |
+| `deleteDownloadedTrack(trackId)`       | Both     | **Async**. Deletes a downloaded track.                        |
+| `getStorageInfo()`                     | Both     | **Async**. Gets download storage usage information.           |
+| `setPlaybackSourcePreference(pref)`    | Both     | Sets playback source: `'auto'`, `'download'`, or `'network'`. |
+
+> [!NOTE]
+> See [DOWNLOADS.md](./DOWNLOADS.md) for complete downloads API documentation.
+
 ## Quick Start
 
 ### 1. Configure the Player
@@ -49,6 +134,12 @@ const tracks: TrackItem[] = [
     duration: 180.0, // in seconds
     url: 'https://example.com/song.mp3',
     artwork: 'https://example.com/artwork.jpg',
+    // Optional custom data (accessible in player state)
+    extraPayload: {
+      artistId: '123',
+      genre: 'Rock',
+      isFavorite: true,
+    },
   },
 ]
 
@@ -72,7 +163,7 @@ import { TrackPlayer, PlayerQueue } from 'react-native-nitro-player'
 PlayerQueue.loadPlaylist(playlistId)
 
 // Or play a specific song
-TrackPlayer.playSong('song-id', playlistId)
+await TrackPlayer.playSong('song-id', playlistId)
 
 // Basic controls
 TrackPlayer.play()
@@ -90,6 +181,178 @@ TrackPlayer.setRepeatMode('track') // Repeat current track
 TrackPlayer.setVolume(50) // Set volume to 50%
 TrackPlayer.setVolume(0) // Mute
 TrackPlayer.setVolume(100) // Maximum volume
+
+// Add temporary tracks to queue
+await TrackPlayer.addToUpNext('song-id') // Add to up-next queue (FIFO)
+await TrackPlayer.playNext('song-id') // Add to play-next stack (LIFO)
+```
+
+### 4. Download for Offline Playback (Optional)
+
+```typescript
+import { DownloadManager } from 'react-native-nitro-player'
+
+// Configure downloads
+DownloadManager.configure({
+  maxConcurrentDownloads: 3,
+  backgroundDownloadsEnabled: true,
+  downloadArtwork: true,
+})
+
+// Download a track
+const downloadId = await DownloadManager.downloadTrack(track)
+
+// Download entire playlist
+const playlist = PlayerQueue.getPlaylist(playlistId)
+await DownloadManager.downloadPlaylist(playlist.id, playlist.tracks)
+
+// Set playback to prefer downloaded tracks
+DownloadManager.setPlaybackSourcePreference('auto')
+```
+
+> [!NOTE]
+> See [DOWNLOADS.md](./DOWNLOADS.md) for complete offline downloads documentation.
+
+## Temporary Queue Management
+
+The player supports adding temporary tracks to the queue without modifying the original playlist. These tracks are automatically removed after playing.
+
+### `addToUpNext(trackId: string): Promise<void>`
+
+Adds a track to the **up-next queue** (FIFO - First In, First Out). Tracks play in the order they were added.
+
+**Behavior:**
+
+- Track is inserted after the current track and any "play next" tracks
+- Multiple tracks can be added - they play in the order added
+- Track is automatically removed after playing
+- Does not modify the original playlist
+
+**Example:**
+
+```typescript
+// Add tracks to up-next queue
+await TrackPlayer.addToUpNext('song-1') // Will play 3rd
+await TrackPlayer.addToUpNext('song-2') // Will play 4th
+await TrackPlayer.addToUpNext('song-3') // Will play 5th
+// Order: [current] → [song-1] → [song-2] → [song-3]
+```
+
+### `playNext(trackId: string): Promise<void>`
+
+Adds a track to the **play-next stack** (LIFO - Last In, First Out). The most recently added track plays first.
+
+**Behavior:**
+
+- Track is inserted immediately after the current track
+- Multiple tracks can be added - the last added plays first
+- Track is automatically removed after playing
+- Does not modify the original playlist
+
+**Example:**
+
+```typescript
+// Add tracks to play-next stack
+await TrackPlayer.playNext('song-1') // Will play 3rd
+await TrackPlayer.playNext('song-2') // Will play 2nd (most recent)
+await TrackPlayer.playNext('song-3') // Will play 1st (most recent)
+// Order: [current] → [song-3] → [song-2] → [song-1]
+```
+
+### Queue Order
+
+The actual playback order is:
+
+```
+[original tracks before current]
++ [CURRENT TRACK]
++ [playNext stack (LIFO)]
++ [upNext queue (FIFO)]
++ [original tracks after current]
+```
+
+### Clearing Temporary Tracks
+
+Temporary tracks are automatically cleared when:
+
+- `await TrackPlayer.playSong()` is called
+- `PlayerQueue.loadPlaylist()` is called
+- `TrackPlayer.playFromIndex()` is called
+
+### `skipToIndex(index: number): Promise<boolean>`
+
+Skips to a specific index in the **actual queue** (the combined queue with temporary tracks).
+
+**Behavior:**
+
+- Takes an index into the actual queue structure
+- If the target is a temporary track (playNext or upNext), plays that track
+- If the target is beyond temporary tracks (in the remaining original playlist), clears all temporary tracks and plays from the original playlist
+- Returns `true` if successful, `false` if the index is invalid
+
+**Example:**
+
+```typescript
+// Queue: [track1(0), track2(1, current), playNext-A(2), upNext-B(3), track3(4), track4(5)]
+
+// Skip to playNext track
+await TrackPlayer.skipToIndex(2) // Plays playNext-A
+
+// Skip to original playlist track (clears temporary tracks)
+await TrackPlayer.skipToIndex(4) // Clears temps, plays track3
+```
+
+### Getting the Actual Queue
+
+Use `useActualQueue()` hook to see the complete queue including temporary tracks:
+
+```typescript
+import { useActualQueue } from 'react-native-nitro-player'
+
+function QueueView() {
+  const { queue, refreshQueue, isLoading } = useActualQueue()
+
+  return (
+    <ScrollView>
+      {queue.map((track, index) => (
+        <View key={track.id}>
+          <Text>{index + 1}. {track.title}</Text>
+        </View>
+      ))}
+    </ScrollView>
+  )
+}
+```
+
+**Returns:**
+
+- `queue: TrackItem[]` - Complete queue in playback order
+- `refreshQueue: () => void` - Manually refresh the queue
+- `isLoading: boolean` - Whether the queue is currently loading
+
+## CurrentPlayingType
+
+The `currentPlayingType` field in `PlayerState` indicates the source of the currently playing track:
+
+| Value          | Description                                              |
+| -------------- | -------------------------------------------------------- |
+| `'playlist'`   | Playing from the original playlist                       |
+| `'play-next'`  | Playing a track added via `playNext()` (LIFO stack)      |
+| `'up-next'`    | Playing a track added via `addToUpNext()` (FIFO queue)   |
+| `'not-playing'`| No track is currently playing                            |
+
+**Example:**
+
+```typescript
+const state = await TrackPlayer.getState()
+
+if (state.currentPlayingType === 'play-next') {
+  console.log('Playing a play-next track')
+} else if (state.currentPlayingType === 'up-next') {
+  console.log('Playing an up-next track')
+} else if (state.currentPlayingType === 'playlist') {
+  console.log('Playing from the original playlist')
+}
 ```
 
 ## Core Concepts
@@ -111,6 +374,7 @@ Controls playback. Use it to:
 - Skip tracks
 - Control repeat mode
 - Control volume
+- Add temporary tracks to queue (`addToUpNext`, `playNext`)
 - Get current player state
 - Listen to playback events
 
@@ -183,9 +447,82 @@ Returns the complete current player state (same as `TrackPlayer.getState()`). Th
   - `currentState: TrackPlayerState` - Current playback state (`'playing'`, `'paused'`, or `'stopped'`)
   - `currentPlaylistId: string | null` - ID of the currently loaded playlist, or `null` if no playlist is loaded
   - `currentIndex: number` - Index of the current track in the playlist (-1 if no track is playing)
+  - `currentPlayingType: CurrentPlayingType` - Source of the current track (`'playlist'`, `'play-next'`, `'up-next'`, or `'not-playing'`)
 
 **Note:** This hook is equivalent to calling `TrackPlayer.getState()` but provides reactive updates. It listens to track changes and playback state changes to update automatically. Also dont rely on progress from this hook
 
+### `useActualQueue()`
+
+Returns the actual playback queue including temporary tracks (from `addToUpNext` and `playNext`).
+
+**Returns:**
+
+- `queue: TrackItem[]` - Complete queue in playback order: `[tracks_before_current] + [current] + [playNext_stack] + [upNext_queue] + [remaining_tracks]`
+- `refreshQueue: () => void` - Manually refresh the queue (useful after adding tracks)
+- `isLoading: boolean` - Whether the queue is currently loading
+
+**Auto-updates when:**
+
+- Track changes
+- Temporary tracks are added (`playNext`/`addToUpNext`)
+- Playback state changes
+
+**Example:**
+
+```typescript
+import { useActualQueue } from 'react-native-nitro-player'
+
+function QueueView() {
+  const { queue, refreshQueue, isLoading } = useActualQueue()
+
+  const handleAddToUpNext = async (trackId: string) => {
+    await TrackPlayer.addToUpNext(trackId)
+    // Refresh queue after adding track
+    setTimeout(refreshQueue, 100)
+  }
+
+  return (
+    <ScrollView>
+      {queue.map((track, index) => (
+        <View key={track.id}>
+          <Text>{index + 1}. {track.title}</Text>
+        </View>
+      ))}
+    </ScrollView>
+  )
+}
+```
+
+### `usePlaylist()`
+
+Manages playlist-related state and provides access to all playlists and tracks.
+
+**Returns:**
+
+- `currentPlaylist: Playlist | null` - The currently loaded playlist
+- `currentPlaylistId: string | null` - ID of the currently loaded playlist
+- `allPlaylists: Playlist[]` - Array of all playlists
+- `allTracks: TrackItem[]` - Array of all tracks from all playlists
+- `isLoading: boolean` - Whether playlists are currently loading
+- `refreshPlaylists: () => void` - Manually refresh playlist data
+
+**Example:**
+
+```typescript
+import { usePlaylist } from 'react-native-nitro-player'
+
+function PlaylistView() {
+  const { allPlaylists, allTracks, refreshPlaylists } = usePlaylist()
+
+  return (
+    <View>
+      <Text>Playlists: {allPlaylists.length}</Text>
+      <Text>Total Tracks: {allTracks.length}</Text>
+    </View>
+  )
+}
+```
+
 ## Audio Device APIs
 
 ### `AudioDevices` (Android only)
@@ -210,7 +547,7 @@ import { AudioDevices } from 'react-native-nitro-player'
 
 if (AudioDevices) {
   const devices = AudioDevices.getAudioDevices()
-  devices.forEach(device => {
+  devices.forEach((device) => {
     console.log(`${device.name} - Active: ${device.isActive}`)
   })
 }
@@ -255,6 +592,73 @@ if (AudioRoutePicker) {
 }
 ```
 
+
+## Equalizer
+
+The player includes a powerful 5-band equalizer that works on both iOS and Android.
+
+### `useEqualizer()`
+
+Returns the current equalizer state and control methods.
+
+**Returns:**
+
+- `isEnabled: boolean` - Whether the equalizer is currently active
+- `bands: EqualizerBand[]` - Current gain settings for all 5 bands
+- `currentPreset: string | null` - Name of the currently applied preset
+- `setEnabled(enabled: boolean): boolean` - Toggle the equalizer on/off
+- `setBandGain(index: number, gainDb: number): boolean` - Set gain for a specific band (range: -12dB to +12dB)
+- `setAllBandGains(gains: number[]): boolean` - Set all band gains at once
+- `reset(): void` - Reset to flat response
+
+**Bands:**
+
+The equalizer features 5 bands at the following center frequencies:
+1. **60 Hz** - Sub-bass/Bass
+2. **230 Hz** - Bass/Low-mids
+3. **910 Hz** - Mids
+4. **3.6 kHz** - Upper-mids/Treble
+5. **14 kHz** - High treble/Air
+
+**Example:**
+
+```typescript
+import { useEqualizer } from 'react-native-nitro-player'
+
+function EqualizerControl() {
+  const { 
+    isEnabled, 
+    setEnabled, 
+    bands, 
+    setBandGain, 
+    reset 
+  } = useEqualizer()
+
+  return (
+    <View>
+      <Switch 
+        value={isEnabled} 
+        onValueChange={setEnabled} 
+      />
+      
+      {bands.map((band) => (
+        <View key={band.index}>
+          <Text>{band.frequencyLabel}</Text>
+          <Slider
+            minimumValue={-12}
+            maximumValue={12}
+            value={band.gainDb}
+            onSlidingComplete={(value) => setBandGain(band.index, value)}
+          />
+        </View>
+      ))}
+      
+      <Button title="Reset" onPress={reset} />
+    </View>
+  )
+}
+```
+
 ## Repeat Mode
 
 Control how tracks repeat during playback.
@@ -457,7 +861,7 @@ TrackPlayer.onPlaybackProgressChange(
 )
 
 // Listen to Android Auto connection changes
-TrackPlayer.onAndroidAutoConnectionChange(connected => {
+TrackPlayer.onAndroidAutoConnectionChange((connected) => {
   console.log('Android Auto:', connected ? 'Connected' : 'Disconnected')
 })
 ```
@@ -467,7 +871,7 @@ TrackPlayer.onAndroidAutoConnectionChange(connected => {
 ```typescript
 import { TrackPlayer } from 'react-native-nitro-player'
 
-const state = TrackPlayer.getState()
+const state = await TrackPlayer.getState()
 
 console.log(state.currentState) // 'playing' | 'paused' | 'stopped'
 console.log(state.currentPosition) // current position in seconds
@@ -475,6 +879,7 @@ console.log(state.totalDuration) // total duration in seconds
 console.log(state.currentTrack) // current TrackItem or null
 console.log(state.currentPlaylistId) // current playlist ID or null
 console.log(state.currentIndex) // current track index in playlist
+console.log(state.currentPlayingType) // 'playlist' | 'play-next' | 'up-next' | 'not-playing'
 ```
 
 ## Track Item Structure
@@ -490,6 +895,29 @@ interface TrackItem {
   duration: number // Duration in seconds
   url: string // Audio file URL
   artwork?: string | null // Optional artwork URL
+  // key-value pairs for arbitrary data
+  extraPayload?: {
+    [key: string]: string | number | boolean | Record<string, unknown>
+  }
+}
+```
+
+### Custom Track Metadata (extraPayload)
+
+```typescript
+const track = {
+  // ... standard fields
+  extraPayload: {
+    externalId: 'sp-12345',
+    rating: 4.5,
+    tags: ['chill', 'instrumental']
+  }
+}
+
+// Accessing it later
+const { track } = useOnChangeTrack()
+if (track?.extraPayload?.rating > 4) {
+  console.log('High rated track playing!')
 }
 ```
 
@@ -687,6 +1115,7 @@ AndroidAutoMediaLibraryHelper.set({
 - ✅ **CarPlay Support**: Control playback from CarPlay (iOS)
 - ✅ **Notification Controls**: Show playback controls in notifications
 - ✅ **Progress Tracking**: Real-time playback progress updates
+- ✅ **Offline Downloads**: Download tracks and playlists for offline playback
 
 ## TypeScript Support
 
@@ -698,6 +1127,7 @@ import type {
   Playlist,
   PlayerState,
   TrackPlayerState,
+  CurrentPlayingType,
   QueueOperation,
   Reason,
   PlayerConfig,
@@ -705,6 +1135,16 @@ import type {
   MediaItem,
   LayoutType,
   MediaType,
+  // Download types
+  DownloadConfig,
+  DownloadProgress,
+  DownloadedTrack,
+  DownloadedPlaylist,
+  DownloadTask,
+  DownloadState,
+  DownloadError,
+  DownloadStorageInfo,
+  PlaybackSource,
 } from 'react-native-nitro-player'
 ```
 

package/android/build.gradle

@@ -129,7 +129,7 @@ repositories {
 }
 
 
-def media3_version = "1.3.0"
+def media3_version = "1.9.0"
 dependencies {
   // For < 0.71, this will be from the local maven repo
   // For > 0.71, this will be replaced by `com.facebook.react:react-android:$version` by react gradle plugin
@@ -143,5 +143,8 @@ dependencies {
   implementation "androidx.media3:media3-session:$media3_version"
   implementation "androidx.media3:media3-common:$media3_version"
   implementation "androidx.media:media:1.7.0"
+  
+  // WorkManager for background downloads
+  implementation "androidx.work:work-runtime-ktx:2.9.0"
 }
 

package/android/src/main/AndroidManifest.xml

@@ -1,2 +1,17 @@
-<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools">
+    <!-- Permissions for downloads -->
+    <uses-permission android:name="android.permission.INTERNET" />
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_DATA_SYNC" />
+    
+    <application>
+        <!-- WorkManager's SystemForegroundService for download notifications -->
+        <service
+            android:name="androidx.work.impl.foreground.SystemForegroundService"
+            android:foregroundServiceType="dataSync"
+            android:exported="false"
+            tools:node="merge" />
+    </application>
 </manifest>
+

package/android/src/main/java/com/margelo/nitro/nitroplayer/HybridAndroidAutoMediaLibrary.kt

@@ -5,6 +5,8 @@ import com.facebook.proguard.annotations.DoNotStrip
 import com.margelo.nitro.NitroModules
 import com.margelo.nitro.nitroplayer.core.TrackPlayerCore
 
+@DoNotStrip
+@Keep
 class HybridAndroidAutoMediaLibrary : HybridAndroidAutoMediaLibrarySpec() {
     private val core: TrackPlayerCore
 

package/android/src/main/java/com/margelo/nitro/nitroplayer/HybridAudioDevices.kt

@@ -4,8 +4,12 @@ import android.content.Context
 import android.media.AudioDeviceInfo
 import android.media.AudioManager
 import android.os.Build
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
 import com.margelo.nitro.NitroModules
 
+@DoNotStrip
+@Keep
 class HybridAudioDevices : HybridAudioDevicesSpec() {
     val applicationContext = NitroModules.applicationContext
     private val audioManager = applicationContext?.getSystemService(Context.AUDIO_SERVICE) as AudioManager
@@ -30,6 +34,8 @@ class HybridAudioDevices : HybridAudioDevicesSpec() {
         types
     }
 
+    @DoNotStrip
+    @Keep
     override fun getAudioDevices(): Array<TAudioDevice> {
         val devices = audioManager.getDevices(android.media.AudioManager.GET_DEVICES_OUTPUTS)
         var activeDevice: AudioDeviceInfo? = null
@@ -66,6 +72,8 @@ class HybridAudioDevices : HybridAudioDevicesSpec() {
             else -> "Type $type"
         }
 
+    @DoNotStrip
+    @Keep
     override fun setAudioDevice(deviceId: Double): Boolean {
         val device =
             audioManager