@livekit/react-native 1.1.2 → 1.3.0

package/README.md

@@ -29,7 +29,7 @@ This library depends on `@livekit/react-native-webrtc`, which has additional ins
 - [iOS Installation Guide](https://github.com/livekit/react-native-webrtc/blob/master/Documentation/iOSInstallation.md)
 - [Android Installation Guide](https://github.com/livekit/react-native-webrtc/blob/master/Documentation/AndroidInstallation.md)
 
-----
+---
 
 Once the `@livekit/react-native-webrtc` dependency is installed, one last step is needed to finish the installation:
 
@@ -45,7 +45,7 @@ public class MainApplication extends Application implements ReactApplication {
   @Override
   public void onCreate() {
     // Place this above any other RN related initialization
-    LiveKitReactNative.setup();
+    LiveKitReactNative.setup(this);
 
     //...
   }
@@ -106,8 +106,12 @@ const [room] = useState(() => new Room());
 const { participants } = useRoom(room);
 
 useEffect(() => {
-  AudioSession.startAudioSession();
-  room.connect(url, token, {});
+  let connect = async () => {
+    await AudioSession.startAudioSession();
+    await room.connect(url, token, {});
+    console.log('connected to ', url, ' ', token);
+  };
+  connect();
   return () => {
     room.disconnect();
     AudioSession.stopAudioSession();
@@ -126,6 +130,40 @@ const videoView = participants.length > 0 && (
 
 Additional documentation for the LiveKit SDK can be found at https://docs.livekit.io/references/client-sdks/
 
+## Audio sessions
+
+As seen in the above example, we've introduced a new class `AudioSession` that helps
+to manage the audio session on native platforms. This class wraps either [AudioManager](https://developer.android.com/reference/android/media/AudioManager) on Android, or [AVAudioSession](https://developer.apple.com/documentation/avfaudio/avaudiosession) on iOS.
+
+You can customize the configuration of the audio session with `configureAudio`.
+
+```js
+useEffect(() => {
+  let connect = async () => {
+    // configure audio session prior to starting it.
+    await AudioSession.configureAudio({
+      android: {
+        preferredOutputList: ['earpiece'],
+        // See [AudioManager](https://developer.android.com/reference/android/media/AudioManager)
+        // for details on audio and focus modes.
+        audioMode: 'normal',
+        audioFocusMode: 'gain',
+      },
+      ios: {
+        defaultOutput: 'earpiece',
+      },
+    });
+    await AudioSession.startAudioSession();
+    await room.connect(url, token, {});
+  };
+  connect();
+  return () => {
+    room.disconnect();
+    AudioSession.stopAudioSession();
+  };
+}, [url, token, room]);
+```
+
 ## Screenshare
 
 Enabling screenshare requires extra installation steps:
@@ -196,10 +234,12 @@ See the [contributing guide](CONTRIBUTING.md) to learn how to contribute to the
 Apache License 2.0
 
 <!--BEGIN_REPO_NAV-->
+
 <br/><table>
+
 <thead><tr><th colspan="2">LiveKit Ecosystem</th></tr></thead>
 <tbody>
-<tr><td>Client SDKs</td><td><a href="https://github.com/livekit/components-js">Components</a> · <a href="https://github.com/livekit/client-sdk-js">JavaScript</a> · <a href="https://github.com/livekit/client-sdk-rust">Rust</a> · <a href="https://github.com/livekit/client-sdk-swift">iOS/macOS</a> · <a href="https://github.com/livekit/client-sdk-android">Android</a> · <a href="https://github.com/livekit/client-sdk-flutter">Flutter</a> · <a href="https://github.com/livekit/client-sdk-unity-web">Unity (web)</a> · <b>React Native (beta)</b></td></tr><tr></tr>
+<tr><td>Client SDKs</td><td><a href="https://github.com/livekit/components-js">Components</a> · <a href="https://github.com/livekit/client-sdk-js">JavaScript</a> · <a href="https://github.com/livekit/client-sdk-swift">iOS/macOS</a> · <a href="https://github.com/livekit/client-sdk-android">Android</a> · <a href="https://github.com/livekit/client-sdk-flutter">Flutter</a> · <b>React Native</b> · <a href="https://github.com/livekit/client-sdk-rust">Rust</a> · <a href="https://github.com/livekit/client-sdk-python">Python</a> · <a href="https://github.com/livekit/client-sdk-unity-web">Unity (web)</a> · <a href="https://github.com/livekit/client-sdk-unity">Unity (beta)</a></td></tr><tr></tr>
 <tr><td>Server SDKs</td><td><a href="https://github.com/livekit/server-sdk-js">Node.js</a> · <a href="https://github.com/livekit/server-sdk-go">Golang</a> · <a href="https://github.com/livekit/server-sdk-ruby">Ruby</a> · <a href="https://github.com/livekit/server-sdk-kotlin">Java/Kotlin</a> · <a href="https://github.com/agence104/livekit-server-sdk-php">PHP (community)</a> · <a href="https://github.com/tradablebits/livekit-server-sdk-python">Python (community)</a></td></tr><tr></tr>
 <tr><td>Services</td><td><a href="https://github.com/livekit/livekit">Livekit server</a> · <a href="https://github.com/livekit/egress">Egress</a> · <a href="https://github.com/livekit/ingress">Ingress</a></td></tr><tr></tr>
 <tr><td>Resources</td><td><a href="https://docs.livekit.io">Docs</a> · <a href="https://github.com/livekit-examples">Example apps</a> · <a href="https://livekit.io/cloud">Cloud</a> · <a href="https://docs.livekit.io/oss/deployment">Self-hosting</a> · <a href="https://github.com/livekit/livekit-cli">CLI</a></td></tr>

package/android/build.gradle

@@ -129,8 +129,8 @@ dependencies {
   // noinspection GradleDynamicVersion
   api 'com.facebook.react:react-native:+'
   implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
-  api 'com.github.davidliu:audioswitch:c498d866c57f1d88056d5e7e7a78d622e3b0c046'
-  api 'io.github.webrtc-sdk:android:104.5112.09'
+  api 'com.github.davidliu:audioswitch:d18e3e31d427c27f1593030e024b370bf24480fd'
+  api 'io.github.webrtc-sdk:android:104.5112.10'
   implementation project(':livekit_react-native-webrtc')
   implementation "androidx.annotation:annotation:1.4.0"
 }

package/android/src/main/java/com/livekit/reactnative/LiveKitReactNative.kt

@@ -1,16 +1,35 @@
 package com.livekit.reactnative
 
+import android.app.Application
+import android.content.Context
+import android.os.Build
+import com.livekit.reactnative.audio.AudioType
 import com.livekit.reactnative.video.SimulcastVideoEncoderFactoryWrapper
 import com.livekit.reactnative.video.WrappedVideoDecoderFactoryProxy
 import com.oney.WebRTCModule.WebRTCModuleOptions
-
+import org.webrtc.audio.JavaAudioDeviceModule
 
 object LiveKitReactNative {
 
+    /**
+     * Initializes components required for LiveKit to work on Android.
+     *
+     * Must be called from your [Application.onCreate] method before any other react-native
+     * initialization.
+     */
     @JvmStatic
-    fun setup() {
+    @JvmOverloads
+    fun setup(context: Context, audioType: AudioType = AudioType.CommunicationAudioType()) {
         val options = WebRTCModuleOptions.getInstance()
         options.videoEncoderFactory = SimulcastVideoEncoderFactoryWrapper(null, true, true)
         options.videoDecoderFactory = WrappedVideoDecoderFactoryProxy()
+
+        val useHardwareAudioProcessing = Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q
+
+        options.audioDeviceModule = JavaAudioDeviceModule.builder(context)
+            .setUseHardwareAcousticEchoCanceler(useHardwareAudioProcessing)
+            .setUseHardwareNoiseSuppressor(useHardwareAudioProcessing)
+            .setAudioAttributes(audioType.audioAttributes)
+            .createAudioDeviceModule()
     }
 }

package/android/src/main/java/com/livekit/reactnative/LivekitReactNativeModule.kt

@@ -1,7 +1,10 @@
 package com.livekit.reactnative
 
+import android.annotation.SuppressLint
+import android.content.Context
 import com.facebook.react.bridge.*
 import com.livekit.reactnative.audio.AudioDeviceKind
+import com.livekit.reactnative.audio.AudioManagerUtils
 import com.livekit.reactnative.audio.AudioSwitchManager
 
 
@@ -16,12 +19,72 @@ class LivekitReactNativeModule(reactContext: ReactApplicationContext) : ReactCon
     fun configureAudio(config: ReadableMap) {
         val androidConfig = config.getMap("android") ?: return
 
-        androidConfig.getArray("preferredOutputList")?.let { preferredOutputList ->
-            val preferredDeviceList = preferredOutputList.toArrayList().mapNotNull { output ->
-                val outputStr = output as? String
-                AudioDeviceKind.fromTypeName(outputStr)?.audioDeviceClass
+        if (androidConfig.hasKey("preferredOutputList")) {
+            androidConfig.getArray("preferredOutputList")?.let { preferredOutputList ->
+                val preferredDeviceList = preferredOutputList.toArrayList().mapNotNull { output ->
+                    val outputStr = output as? String
+                    AudioDeviceKind.fromTypeName(outputStr)?.audioDeviceClass
+                }
+                audioManager.preferredDeviceList = preferredDeviceList
+            }
+        }
+
+        if (androidConfig.hasKey("audioTypeOptions")) {
+            val audioTypeOptions = androidConfig.getMap("audioTypeOptions") ?: return
+
+            if (audioTypeOptions.hasKey("manageAudioFocus")) {
+                val manageFocus = audioTypeOptions.getBoolean("manageAudioFocus")
+                audioManager.setManageAudioFocus(manageFocus)
+            }
+            if (audioTypeOptions.hasKey("audioMode")) {
+                audioTypeOptions.getString("audioMode")?.let { audioModeString ->
+                    val audioMode = AudioManagerUtils.audioModeFromString(audioModeString)
+                    if (audioMode != null) {
+                        audioManager.setAudioMode(audioMode)
+                    }
+                }
+            }
+
+            if (audioTypeOptions.hasKey("audioFocusMode")) {
+                audioTypeOptions.getString("audioFocusMode")?.let { focusModeString ->
+                    val focusMode = AudioManagerUtils.focusModeFromString(focusModeString)
+                    if (focusMode != null) {
+                        audioManager.setFocusMode(focusMode)
+                    }
+                }
+            }
+
+            if (audioTypeOptions.hasKey("audioStreamType")) {
+                audioTypeOptions.getString("audioStreamType")?.let { streamTypeString ->
+                    val streamType = AudioManagerUtils.audioStreamTypeFromString(streamTypeString)
+                    if (streamType != null) {
+                        audioManager.setAudioStreamType(streamType)
+                    }
+                }
+            }
+
+            if (audioTypeOptions.hasKey("audioAttributesUsageType")) {
+                audioTypeOptions.getString("audioAttributesUsageType")?.let { usageTypeString ->
+                    val usageType = AudioManagerUtils.audioAttributesUsageTypeFromString(usageTypeString)
+                    if (usageType != null) {
+                        audioManager.setAudioAttributesUsageType(usageType)
+                    }
+                }
+            }
+
+            if (audioTypeOptions.hasKey("audioAttributesContentType")) {
+                audioTypeOptions.getString("audioAttributesContentType")?.let { contentTypeString ->
+                    val contentType = AudioManagerUtils.audioAttributesContentTypeFromString(contentTypeString)
+                    if (contentType != null) {
+                        audioManager.setAudioAttributesContentType(contentType)
+                    }
+                }
+            }
+
+            if (audioTypeOptions.hasKey("forceHandleAudioRouting")) {
+                val force = audioTypeOptions.getBoolean("forceHandleAudioRouting")
+                audioManager.setForceHandleAudioRouting(force)
             }
-            audioManager.preferredDeviceList = preferredDeviceList
         }
     }
 

package/android/src/main/java/com/livekit/reactnative/audio/AudioManagerUtils.kt

@@ -0,0 +1,116 @@
+package com.livekit.reactnative.audio
+
+import android.media.AudioAttributes
+import android.media.AudioManager
+import android.util.Log
+
+
+object AudioManagerUtils {
+    private const val TAG = "AudioManagerUtils"
+
+    fun audioModeFromString(audioModeString: String?): Int? {
+        if (audioModeString == null) {
+            return null
+        }
+
+        var audioMode: Int? = null
+        when (audioModeString) {
+            "normal" -> audioMode = AudioManager.MODE_NORMAL
+            "callScreening" -> audioMode = AudioManager.MODE_CALL_SCREENING
+            "inCall" -> audioMode = AudioManager.MODE_IN_CALL
+            "inCommunication" -> audioMode = AudioManager.MODE_IN_COMMUNICATION
+            "ringtone" -> audioMode = AudioManager.MODE_RINGTONE
+            else -> Log.w(TAG, "Unknown audio mode: $audioModeString")
+        }
+
+        return audioMode
+    }
+
+    fun focusModeFromString(focusModeString: String?): Int? {
+        if (focusModeString == null) {
+            return null
+        }
+
+        var focusMode: Int? = null
+        when (focusModeString) {
+            "gain" -> focusMode = AudioManager.AUDIOFOCUS_GAIN
+            "gainTransient" -> focusMode = AudioManager.AUDIOFOCUS_GAIN_TRANSIENT
+            "gainTransientExclusive" -> focusMode = AudioManager.AUDIOFOCUS_GAIN_TRANSIENT_EXCLUSIVE
+            "gainTransientMayDuck" -> focusMode = AudioManager.AUDIOFOCUS_GAIN_TRANSIENT_MAY_DUCK
+            else -> Log.w(TAG, "Unknown audio focus mode: $focusModeString")
+        }
+
+        return focusMode
+    }
+
+    fun audioAttributesUsageTypeFromString(usageTypeString: String?): Int? {
+        if (usageTypeString == null) {
+            return null
+        }
+
+        val usageType: Int? = when (usageTypeString) {
+            "alarm" -> AudioAttributes.USAGE_ALARM
+            "assistanceAccessibility" -> AudioAttributes.USAGE_ASSISTANCE_ACCESSIBILITY
+            "assistanceNavigationGuidance" -> AudioAttributes.USAGE_ASSISTANCE_NAVIGATION_GUIDANCE
+            "assistanceSonification" -> AudioAttributes.USAGE_ASSISTANCE_SONIFICATION
+            "assistant" -> AudioAttributes.USAGE_ASSISTANT
+            "game" -> AudioAttributes.USAGE_GAME
+            "media" -> AudioAttributes.USAGE_MEDIA
+            "notification" -> AudioAttributes.USAGE_NOTIFICATION
+            "notificationEvent" -> AudioAttributes.USAGE_NOTIFICATION_EVENT
+            "notificationRingtone" -> AudioAttributes.USAGE_NOTIFICATION_RINGTONE
+            "unknown" -> AudioAttributes.USAGE_UNKNOWN
+            "voiceCommunication" -> AudioAttributes.USAGE_VOICE_COMMUNICATION
+            "voiceCommunicationSignalling" -> AudioAttributes.USAGE_VOICE_COMMUNICATION_SIGNALLING
+            else -> {
+                Log.w(TAG, "Unknown audio attributes usage type: $usageTypeString")
+                null
+            }
+        }
+
+        return usageType
+    }
+
+    fun audioAttributesContentTypeFromString(contentTypeString: String?): Int? {
+        if (contentTypeString == null) {
+            return null
+        }
+
+        val contentType = when (contentTypeString) {
+            "movie" -> AudioAttributes.CONTENT_TYPE_MOVIE
+            "music" -> AudioAttributes.CONTENT_TYPE_MUSIC
+            "sonification" -> AudioAttributes.CONTENT_TYPE_SONIFICATION
+            "speech" -> AudioAttributes.CONTENT_TYPE_SPEECH
+            "unknown" -> AudioAttributes.CONTENT_TYPE_UNKNOWN
+            else -> {
+                Log.w(TAG, "Unknown audio attributes content type: $contentTypeString")
+                null
+            }
+        }
+
+        return contentType
+    }
+
+    fun audioStreamTypeFromString(streamTypeString: String?): Int? {
+        if (streamTypeString == null) {
+            return null
+        }
+
+        val streamType = when (streamTypeString) {
+            "accessibility" -> AudioManager.STREAM_ACCESSIBILITY
+            "alarm" -> AudioManager.STREAM_ALARM
+            "dtmf" -> AudioManager.STREAM_DTMF
+            "music" -> AudioManager.STREAM_MUSIC
+            "notification" -> AudioManager.STREAM_NOTIFICATION
+            "ring" -> AudioManager.STREAM_RING
+            "system" -> AudioManager.STREAM_SYSTEM
+            "voiceCall" -> AudioManager.STREAM_VOICE_CALL
+            else -> {
+                Log.w(TAG, "Unknown audio stream type: $streamTypeString")
+                null
+            }
+        }
+
+        return streamType
+    }
+}

package/android/src/main/java/com/livekit/reactnative/audio/AudioSwitchManager.java

@@ -1,6 +1,7 @@
 package com.livekit.reactnative.audio;
 
 import android.content.Context;
+import android.media.AudioAttributes;
 import android.media.AudioManager;
 import android.os.Handler;
 import android.os.Looper;
@@ -14,6 +15,7 @@ import com.twilio.audioswitch.AudioSwitch;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
+import java.util.Objects;
 
 import kotlin.Unit;
 import kotlin.jvm.functions.Function2;
@@ -32,7 +34,8 @@ public class AudioSwitchManager {
             Unit> audioDeviceChangeListener = (devices, currentDevice) -> null;
 
     @NonNull
-    public AudioManager.OnAudioFocusChangeListener audioFocusChangeListener = (i -> {});
+    public AudioManager.OnAudioFocusChangeListener audioFocusChangeListener = (i -> {
+    });
 
     @NonNull
     public List<Class<? extends AudioDevice>> preferredDeviceList;
@@ -43,6 +46,73 @@ public class AudioSwitchManager {
     @Nullable
     private AudioSwitch audioSwitch;
 
+    /**
+     * When true, AudioSwitchHandler will request audio focus on start and abandon on stop.
+     *
+     * Defaults to true.
+     */
+    private boolean manageAudioFocus = true;
+
+    /**
+     * The audio focus mode to use while started.
+     *
+     * Defaults to [AudioManager.AUDIOFOCUS_GAIN].
+     */
+    private int focusMode = AudioManager.AUDIOFOCUS_GAIN;
+
+    /**
+     * The audio mode to use while started.
+     *
+     * Defaults to AudioManager.MODE_IN_COMMUNICATION.
+     */
+    private int audioMode = AudioManager.MODE_IN_COMMUNICATION;
+
+    /**
+     * The audio stream type to use when requesting audio focus on pre-O devices.
+     *
+     * Defaults to [AudioManager.STREAM_VOICE_CALL].
+     *
+     * Refer to this [compatibility table](https://source.android.com/docs/core/audio/attributes#compatibility)
+     * to ensure that your values match between android versions.
+     *
+     * Note: Manual audio routing may not work appropriately when using non-default values.
+     */
+    private int audioStreamType = AudioManager.STREAM_VOICE_CALL;
+
+    /**
+     * The audio attribute usage type to use when requesting audio focus on devices O and beyond.
+     *
+     * Defaults to [AudioAttributes.USAGE_VOICE_COMMUNICATION].
+     *
+     * Refer to this [compatibility table](https://source.android.com/docs/core/audio/attributes#compatibility)
+     * to ensure that your values match between android versions.
+     *
+     * Note: Manual audio routing may not work appropriately when using non-default values.
+     */
+    private int audioAttributeUsageType = AudioAttributes.USAGE_VOICE_COMMUNICATION;
+
+    /**
+     * The audio attribute content type to use when requesting audio focus on devices O and beyond.
+     *
+     * Defaults to [AudioAttributes.CONTENT_TYPE_SPEECH].
+     *
+     * Refer to this [compatibility table](https://source.android.com/docs/core/audio/attributes#compatibility)
+     * to ensure that your values match between android versions.
+     *
+     * Note: Manual audio routing may not work appropriately when using non-default values.
+     */
+    private int audioAttributeContentType = AudioAttributes.CONTENT_TYPE_SPEECH;
+
+    /**
+     * On certain Android devices, audio routing does not function properly and bluetooth microphones will not work
+     * unless audio mode is set to [AudioManager.MODE_IN_COMMUNICATION] or [AudioManager.MODE_IN_CALL].
+     *
+     * AudioSwitchManager by default will not handle audio routing in those cases to avoid audio issues.
+     *
+     * If this set to true, AudioSwitchManager will attempt to do audio routing, though behavior is undefined.
+     */
+    private boolean forceHandleAudioRouting = false;
+
     public AudioSwitchManager(@NonNull Context context) {
         this.context = context;
         this.audioManager = (AudioManager) context.getSystemService(Context.AUDIO_SERVICE);
@@ -64,6 +134,13 @@ public class AudioSwitchManager {
                         audioFocusChangeListener,
                         preferredDeviceList
                 );
+                audioSwitch.setManageAudioFocus(manageAudioFocus);
+                audioSwitch.setFocusMode(focusMode);
+                audioSwitch.setAudioMode(audioMode);
+                audioSwitch.setAudioStreamType(audioStreamType);
+                audioSwitch.setAudioAttributeContentType(audioAttributeContentType);
+                audioSwitch.setAudioAttributeUsageType(audioAttributeUsageType);
+                audioSwitch.setForceHandleAudioRouting(forceHandleAudioRouting);
                 audioSwitch.start(audioDeviceChangeListener);
                 audioSwitch.activate();
             });
@@ -80,7 +157,7 @@ public class AudioSwitchManager {
         });
     }
 
-    public void setMicrophoneMute(boolean mute){
+    public void setMicrophoneMute(boolean mute) {
         audioManager.setMicrophoneMute(mute);
     }
 
@@ -125,16 +202,65 @@ public class AudioSwitchManager {
     }
 
     public void enableSpeakerphone(boolean enable) {
-        if(enable) {
+        if (enable) {
             audioManager.setSpeakerphoneOn(true);
         } else {
             audioManager.setSpeakerphoneOn(false);
         }
     }
-    
+
     public void selectAudioOutput(@Nullable AudioDeviceKind kind) {
         if (kind != null) {
             selectAudioOutput(kind.audioDeviceClass);
         }
     }
+
+    public void setManageAudioFocus(boolean manage) {
+        this.manageAudioFocus = manage;
+        if (audioSwitch != null) {
+            Objects.requireNonNull(audioSwitch).setManageAudioFocus(this.manageAudioFocus);
+        }
+    }
+
+    public void setFocusMode(int focusMode) {
+        this.focusMode = focusMode;
+        if (audioSwitch != null) {
+            Objects.requireNonNull(audioSwitch).setFocusMode(this.focusMode);
+        }
+    }
+
+    public void setAudioMode(int audioMode) {
+        this.audioMode = audioMode;
+        if (audioSwitch != null) {
+            Objects.requireNonNull(audioSwitch).setAudioMode(this.audioMode);
+        }
+    }
+
+    public void setAudioStreamType(int streamType) {
+        this.audioStreamType = streamType;
+        if (audioSwitch != null) {
+            Objects.requireNonNull(audioSwitch).setAudioStreamType(this.audioStreamType);
+        }
+    }
+
+    public void setAudioAttributesUsageType(int usageType) {
+        this.audioAttributeUsageType = usageType;
+        if (audioSwitch != null) {
+            Objects.requireNonNull(audioSwitch).setAudioAttributeUsageType(this.audioAttributeUsageType);
+        }
+    }
+
+    public void setAudioAttributesContentType(int contentType) {
+        this.audioAttributeContentType = contentType;
+        if (audioSwitch != null) {
+            Objects.requireNonNull(audioSwitch).setAudioAttributeContentType(this.audioAttributeContentType);
+        }
+    }
+
+    public void setForceHandleAudioRouting(boolean force) {
+        this.forceHandleAudioRouting = force;
+        if (audioSwitch != null) {
+            Objects.requireNonNull(audioSwitch).setForceHandleAudioRouting(this.forceHandleAudioRouting);
+        }
+    }
 }

package/android/src/main/java/com/livekit/reactnative/audio/AudioType.kt

@@ -0,0 +1,46 @@
+package com.livekit.reactnative.audio
+
+import android.media.AudioAttributes
+import android.media.AudioManager
+
+sealed class AudioType(
+    val audioMode: Int, 
+    val audioAttributes: AudioAttributes, 
+    val audioStreamType: Int
+) {
+    /**
+     * An audio type for general media playback usage (i.e. listener-only use cases).
+     *
+     * Audio routing is handled automatically by the system in normal media mode,
+     * and bluetooth microphones may not work on some devices.
+     */
+    class MediaAudioType : AudioType(
+        AudioManager.MODE_NORMAL,
+        AudioAttributes.Builder()
+            .setUsage(AudioAttributes.USAGE_MEDIA)
+            .setContentType(AudioAttributes.CONTENT_TYPE_SPEECH)
+            .build(),
+        AudioManager.STREAM_MUSIC
+    )
+
+    /**
+     * An audio type for communications (i.e. participating a call or otherwise
+     * publishing local microphone).
+     *
+     * Audio routing can be manually controlled.
+     */
+    class CommunicationAudioType : AudioType(
+        AudioManager.MODE_IN_COMMUNICATION,
+        AudioAttributes.Builder()
+            .setUsage(AudioAttributes.USAGE_VOICE_COMMUNICATION)
+            .setContentType(AudioAttributes.CONTENT_TYPE_SPEECH)
+            .build(),
+        AudioManager.STREAM_VOICE_CALL
+    )
+
+    /**
+     * An audio type that takes in a user-defined [AudioAttributes] and audio stream type.
+     */
+    class CustomAudioType(audioMode: Int, audioAttributes: AudioAttributes, audioStreamType: Int) :
+        AudioType(audioMode, audioAttributes, audioStreamType)
+}

package/lib/commonjs/audio/AudioSession.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = void 0;
+exports.default = exports.AndroidAudioTypePresets = void 0;
 
 var _reactNative = require("react-native");
 
@@ -29,10 +29,15 @@ const LivekitReactNative = _reactNative.NativeModules.LivekitReactNative ? _reac
  *   This is ignored when an output is manually selected with {@link AudioSession.selectAudioOutput}.
  *
  *   By default, the order is set to:
- *   1. `"speaker"`
- *   2. `"earpiece"`
- *   3. `"headset"`
- *   4. `"bluetooth"`
+ *   1. `"bluetooth"
+ *   2. `"headset"``
+ *   3. `"speaker"`
+ *   4. `"earpiece"`
+ *
+ * * audioTypeOptions - An {@link AndroidAudioTypeOptions} object which provides the
+ *   audio options to use on Android.
+ *
+ *   See {@link AndroidAudioTypePresets} for pre-configured values.
  *
  * ----
  * iOS
@@ -42,6 +47,26 @@ const LivekitReactNative = _reactNative.NativeModules.LivekitReactNative ? _reac
  *   By default, this is set to `"speaker"`
  */
 
+const AndroidAudioTypePresets = {
+  communication: {
+    manageAudioFocus: true,
+    audioMode: 'inCommunication',
+    audioFocusMode: 'gain',
+    audioStreamType: 'voiceCall',
+    audioAttributesUsageType: 'voiceCommunication',
+    audioAttributesContentType: 'speech'
+  },
+  media: {
+    manageAudioFocus: true,
+    audioMode: 'normal',
+    audioFocusMode: 'gain',
+    audioStreamType: 'music',
+    audioAttributesUsageType: 'media',
+    audioAttributesContentType: 'unknown'
+  }
+};
+exports.AndroidAudioTypePresets = AndroidAudioTypePresets;
+
 class AudioSession {}
 
 exports.default = AudioSession;