@livekit/react-native 1.2.0 → 1.4.0

package/README.md

@@ -39,13 +39,16 @@ In your [MainApplication.java](https://github.com/livekit/client-sdk-react-nativ
 
 ```
 import com.livekit.reactnative.LiveKitReactNative;
+import com.livekit.reactnative.audio.AudioType;
 
 public class MainApplication extends Application implements ReactApplication {
 
   @Override
   public void onCreate() {
     // Place this above any other RN related initialization
-    LiveKitReactNative.setup();
+    // When AudioType is omitted, it'll default to CommunicationAudioType
+    // use MediaAudioType if user is only consuming audio, and not publishing
+    LiveKitReactNative.setup(this, new AudioType.CommunicationAudioType());
 
     //...
   }
@@ -137,20 +140,26 @@ to manage the audio session on native platforms. This class wraps either [AudioM
 
 You can customize the configuration of the audio session with `configureAudio`.
 
+### Media playback
+
+By default, the audio session is set up for bidirectional communication. In this mode, the audio framework exhibits the following behaviors:
+
+- The volume cannot be reduced to 0.
+- Echo cancellation is available and is enabled by default.
+- A microphone indicator can be displayed, depending on the platform.
+
+If you're leveraging LiveKit primarily for media playback, you have the option to reconfigure the audio session to better suit media playback. Here's how:
+
+Note: iOS audio session customization is in development, and will be documented here when released.
+
 ```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',
+        // currently supports .media and .communication presets
+        audioTypeOptions: AndroidAudioTypePresets.media,
       },
     });
     await AudioSession.startAudioSession();
@@ -164,6 +173,29 @@ useEffect(() => {
 }, [url, token, room]);
 ```
 
+### Customizing audio session
+
+Instead of using our presets, you can further customize the audio session to suit your specific needs.
+
+```js
+await AudioSession.configureAudio({
+  android: {
+    preferredOutputList: ['earpiece'],
+    // See [AudioManager](https://developer.android.com/reference/android/media/AudioManager)
+    // for details on audio and focus modes.
+    audioTypeOptions: {
+      manageAudioFocus: true,
+      audioMode: 'normal',
+      audioFocusMode: 'gain',
+      audioStreamType: 'music',
+      audioAttributesUsageType: 'media',
+      audioAttributesContentType: 'unknown',
+    },
+  },
+});
+await AudioSession.startAudioSession();
+```
+
 ## Screenshare
 
 Enabling screenshare requires extra installation steps:
@@ -223,7 +255,18 @@ return (
 
 ### Note
 
-Currently it does not run on iOS Simulator on M1 Macs.
+You will not be able to publish camera or microphone tracks on iOS Simulator.
+
+## Troubleshooting
+
+#### Cannot read properties of undefined (reading 'split')
+
+This error could happen if you are using yarn and have incompatible versions of dependencies with livekit-client.
+
+To fix this, you can either:
+
+- use another package manager, like npm
+- use [yarn-deduplicate](https://www.npmjs.com/package/yarn-deduplicate) to deduplicate dependencies
 
 ## Contributing
 

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:fb33b237aa50b3d1d2dea0e0695ecb7b38a98971'
-  api 'io.github.webrtc-sdk:android:104.5112.10'
+  api 'com.github.davidliu:audioswitch:89582c47c9a04c62f90aa5e57251af4800a62c9a'
+  api 'io.github.webrtc-sdk:android:114.5735.05'
   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,5 +1,7 @@
 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
@@ -17,24 +19,71 @@ 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
             }
-            audioManager.preferredDeviceList = preferredDeviceList
         }
 
-        androidConfig.getString("audioMode")?.let { audioModeString ->
-            val audioMode = AudioManagerUtils.audioModeFromString(audioModeString)
-            if (audioMode != null) {
-                audioManager.setAudioMode(audioMode)
+        if (androidConfig.hasKey("audioTypeOptions")) {
+            val audioTypeOptions = androidConfig.getMap("audioTypeOptions") ?: return
+
+            if (audioTypeOptions.hasKey("manageAudioFocus")) {
+                val manageFocus = audioTypeOptions.getBoolean("manageAudioFocus")
+                audioManager.setManageAudioFocus(manageFocus)
             }
-        }
-        androidConfig.getString("audioFocusMode")?.let { focusModeString ->
-            val focusMode = AudioManagerUtils.focusModeFromString(focusModeString)
-            if (focusMode != null) {
-                audioManager.setFocusMode(focusMode)
+            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)
             }
         }
     }

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

@@ -1,5 +1,6 @@
 package com.livekit.reactnative.audio
 
+import android.media.AudioAttributes
 import android.media.AudioManager
 import android.util.Log
 
@@ -41,4 +42,75 @@ object AudioManagerUtils {
 
         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,13 @@ 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.
      *
@@ -53,9 +63,55 @@ public class AudioSwitchManager {
     /**
      * The audio mode to use while started.
      *
-     * Defaults to [AudioManager.MODE_NORMAL].
+     * 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 audioMode = AudioManager.MODE_NORMAL;
+    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;
@@ -78,8 +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();
             });
@@ -96,7 +157,7 @@ public class AudioSwitchManager {
         });
     }
 
-    public void setMicrophoneMute(boolean mute){
+    public void setMicrophoneMute(boolean mute) {
         audioManager.setMicrophoneMute(mute);
     }
 
@@ -141,24 +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/android/src/main/java/com/livekit/reactnative/video/SimulcastVideoEncoderFactoryWrapper.kt

@@ -1,6 +1,7 @@
 package com.livekit.reactnative.video
 
 import android.util.Log
+import com.oney.WebRTCModule.webrtcutils.SoftwareVideoEncoderFactoryProxy
 import org.webrtc.EglBase
 import org.webrtc.HardwareVideoEncoderFactory
 import org.webrtc.SimulcastVideoEncoderFactory
@@ -64,7 +65,7 @@ open class SimulcastVideoEncoderFactoryWrapper(
     private class FallbackFactory(private val hardwareVideoEncoderFactory: VideoEncoderFactory) :
         VideoEncoderFactory {
 
-        private val softwareVideoEncoderFactory: VideoEncoderFactory = SoftwareVideoEncoderFactory()
+        private val softwareVideoEncoderFactory: VideoEncoderFactory = SoftwareVideoEncoderFactoryProxy()
 
         override fun createEncoder(info: VideoCodecInfo): VideoEncoder? {
             val softwareEncoder = softwareVideoEncoderFactory.createEncoder(info)

package/ios/AudioUtils.h

@@ -0,0 +1,9 @@
+#if TARGET_OS_IPHONE
+#import <AVFoundation/AVFoundation.h>
+
+@interface AudioUtils : NSObject
++ (AVAudioSessionMode)audioSessionModeFromString:(NSString*)mode;
++ (AVAudioSessionCategory)audioSessionCategoryFromString:(NSString *)category;
+@end
+
+#endif

package/ios/AudioUtils.m

@@ -0,0 +1,48 @@
+#if TARGET_OS_IPHONE
+#import "AudioUtils.h"
+#import <AVFoundation/AVFoundation.h>
+
+@implementation AudioUtils
+
++ (AVAudioSessionMode)audioSessionModeFromString:(NSString*)mode {
+  if([@"default_" isEqualToString:mode]) {
+    return AVAudioSessionModeDefault;
+  } else if([@"voicePrompt" isEqualToString:mode]) {
+    return AVAudioSessionModeVoicePrompt;
+  } else if([@"videoRecording" isEqualToString:mode]) {
+    return AVAudioSessionModeVideoRecording;
+  } else if([@"videoChat" isEqualToString:mode]) {
+    return AVAudioSessionModeVideoChat;
+  } else if([@"voiceChat" isEqualToString:mode]) {
+    return AVAudioSessionModeVoiceChat;
+  } else if([@"gameChat" isEqualToString:mode]) {
+    return AVAudioSessionModeGameChat;
+  } else if([@"measurement" isEqualToString:mode]) {
+    return AVAudioSessionModeMeasurement;
+  } else if([@"moviePlayback" isEqualToString:mode]) {
+    return AVAudioSessionModeMoviePlayback;
+  } else if([@"spokenAudio" isEqualToString:mode]) {
+    return AVAudioSessionModeSpokenAudio;
+  } 
+  return AVAudioSessionModeDefault;
+}
+
++ (AVAudioSessionCategory)audioSessionCategoryFromString:(NSString *)category {
+  if([@"ambient" isEqualToString:category]) {
+    return AVAudioSessionCategoryAmbient;
+  } else if([@"soloAmbient" isEqualToString:category]) {
+    return AVAudioSessionCategorySoloAmbient;
+  } else if([@"playback" isEqualToString:category]) {
+    return AVAudioSessionCategoryPlayback;
+  } else if([@"record" isEqualToString:category]) {
+    return AVAudioSessionCategoryRecord;
+  } else if([@"playAndRecord" isEqualToString:category]) {
+    return AVAudioSessionCategoryPlayAndRecord;
+  } else if([@"multiRoute" isEqualToString:category]) {
+    return AVAudioSessionCategoryMultiRoute;
+  }
+  return AVAudioSessionCategoryAmbient;
+}
+
+@end
+#endif