Add RTCAudioSession proxy class.

webrtc/modules/audio_device/ios/audio_device_ios.mm

 /*
  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #if !defined(__has_feature) || !__has_feature(objc_arc)
 #error "This file requires ARC support."
 #endif
 
 #import <AVFoundation/AVFoundation.h>
 #import <Foundation/Foundation.h>
 
 #include "webrtc/modules/audio_device/ios/audio_device_ios.h"
 
 #include "webrtc/base/atomicops.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/criticalsection.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/thread_annotations.h"
 #include "webrtc/modules/audio_device/fine_audio_buffer.h"
 #include "webrtc/modules/utility/include/helpers_ios.h"
 
+#import "webrtc/modules/audio_device/ios/objc/RTCAudioSession.h"
+
 namespace webrtc {
 
-// Protects |g_audio_session_users|.
-static rtc::GlobalLockPod g_lock;
-
-// Counts number of users (=instances of this object) who needs an active
-// audio session. This variable is used to ensure that we only activate an audio
-// session for the first user and deactivate it for the last.
-// Member is static to ensure that the value is counted for all instances
-// and not per instance.
-static int g_audio_session_users GUARDED_BY(g_lock) = 0;
-
 #define LOGI() LOG(LS_INFO) << "AudioDeviceIOS::"
 
 #define LOG_AND_RETURN_IF_ERROR(error, message) \
   do {                                          \
     OSStatus err = error;                       \
     if (err) {                                  \
       LOG(LS_ERROR) << message << ": " << err;  \
       return false;                             \
     }                                           \
   } while (0)
@@ skipping 40 matching lines @@
 // ADM instances. A fall-back solution is to allow multiple sequential calls
 // with as small delay between each. This factor sets the max number of allowed
 // initialization attempts.
 const int kMaxNumberOfAudioUnitInitializeAttempts = 5;
 
 
 using ios::CheckAndLogError;
 
 // Verifies that the current audio session supports input audio and that the
 // required category and mode are enabled.
-static bool VerifyAudioSession(AVAudioSession* session) {
+static bool VerifyAudioSession(RTCAudioSession* session) {
   LOG(LS_INFO) << "VerifyAudioSession";
   // Ensure that the device currently supports audio input.
-  if (!session.isInputAvailable) {
+  if (!session.inputAvailable) {
     LOG(LS_ERROR) << "No audio input path is available!";
     return false;
   }
 
   // Ensure that the required category and mode are actually activated.
   if (![session.category isEqualToString:AVAudioSessionCategoryPlayAndRecord]) {
     LOG(LS_ERROR)
         << "Failed to set category to AVAudioSessionCategoryPlayAndRecord";
     return false;
   }
   if (![session.mode isEqualToString:AVAudioSessionModeVoiceChat]) {
     LOG(LS_ERROR) << "Failed to set mode to AVAudioSessionModeVoiceChat";
     return false;
   }
   return true;
 }
 
 // Activates an audio session suitable for full duplex VoIP sessions when
 // |activate| is true. Also sets the preferred sample rate and IO buffer
 // duration. Deactivates an active audio session if |activate| is set to false.
-static bool ActivateAudioSession(AVAudioSession* session, bool activate)
-    EXCLUSIVE_LOCKS_REQUIRED(g_lock) {
+static bool ActivateAudioSession(RTCAudioSession* session, bool activate) {
   LOG(LS_INFO) << "ActivateAudioSession(" << activate << ")";
-  @autoreleasepool {
-    NSError* error = nil;
-    BOOL success = NO;
 
-    if (!activate) {
-      // Deactivate the audio session using an extra option and then return.
-      // AVAudioSessionSetActiveOptionNotifyOthersOnDeactivation is used to
-      // ensure that other audio sessions that were interrupted by our session
-      // can return to their active state. It is recommended for VoIP apps to
-      // use this option.
-      success = [session
-            setActive:NO
-          withOptions:AVAudioSessionSetActiveOptionNotifyOthersOnDeactivation
-                error:&error];
-      return CheckAndLogError(success, error);
-    }
+  NSError* error = nil;
+  BOOL success = NO;
 
-    // Go ahead and active our own audio session since |activate| is true.
-    // Use a category which supports simultaneous recording and playback.
-    // By default, using this category implies that our app’s audio is
-    // nonmixable, hence activating the session will interrupt any other
-    // audio sessions which are also nonmixable.
-    if (session.category != AVAudioSessionCategoryPlayAndRecord) {
-      error = nil;
-      success = [session setCategory:AVAudioSessionCategoryPlayAndRecord
-                         withOptions:AVAudioSessionCategoryOptionAllowBluetooth
-                               error:&error];
-      RTC_DCHECK(CheckAndLogError(success, error));
-    }
+  [session lockForConfiguration];
+  if (!activate) {
+    success = [session setActive:NO
+                           error:&error];
+    [session unlockForConfiguration];
+    return CheckAndLogError(success, error);
+  }
 
-    // Specify mode for two-way voice communication (e.g. VoIP).
-    if (session.mode != AVAudioSessionModeVoiceChat) {
-      error = nil;
-      success = [session setMode:AVAudioSessionModeVoiceChat error:&error];
-      RTC_DCHECK(CheckAndLogError(success, error));
-    }
+  // Go ahead and active our own audio session since |activate| is true.
+  // Use a category which supports simultaneous recording and playback.
+  // By default, using this category implies that our app’s audio is
+  // nonmixable, hence activating the session will interrupt any other
+  // audio sessions which are also nonmixable.
+  if (session.category != AVAudioSessionCategoryPlayAndRecord) {
+    error = nil;
+    success = [session setCategory:AVAudioSessionCategoryPlayAndRecord
+                       withOptions:AVAudioSessionCategoryOptionAllowBluetooth
+                             error:&error];
+    RTC_DCHECK(CheckAndLogError(success, error));
+  }
 
-    // Set the session's sample rate or the hardware sample rate.
-    // It is essential that we use the same sample rate as stream format
-    // to ensure that the I/O unit does not have to do sample rate conversion.
+  // Specify mode for two-way voice communication (e.g. VoIP).
+  if (session.mode != AVAudioSessionModeVoiceChat) {
     error = nil;
-    success =
-        [session setPreferredSampleRate:kPreferredSampleRate error:&error];
+    success = [session setMode:AVAudioSessionModeVoiceChat error:&error];
     RTC_DCHECK(CheckAndLogError(success, error));
+  }
 
-    // Set the preferred audio I/O buffer duration, in seconds.
-    error = nil;
-    success = [session setPreferredIOBufferDuration:kPreferredIOBufferDuration
-                                              error:&error];
-    RTC_DCHECK(CheckAndLogError(success, error));
+  // Set the session's sample rate or the hardware sample rate.
+  // It is essential that we use the same sample rate as stream format
+  // to ensure that the I/O unit does not have to do sample rate conversion.
+  error = nil;
+  success =
+      [session setPreferredSampleRate:kPreferredSampleRate error:&error];
+  RTC_DCHECK(CheckAndLogError(success, error));
 
-    // Activate the audio session. Activation can fail if another active audio
-    // session (e.g. phone call) has higher priority than ours.
-    error = nil;
-    success = [session setActive:YES error:&error];
-    if (!CheckAndLogError(success, error)) {
-      return false;
-    }
+  // Set the preferred audio I/O buffer duration, in seconds.
+  error = nil;
+  success = [session setPreferredIOBufferDuration:kPreferredIOBufferDuration
+                                            error:&error];
+  RTC_DCHECK(CheckAndLogError(success, error));
 
-    // Ensure that the active audio session has the correct category and mode.
-    if (!VerifyAudioSession(session)) {
-      LOG(LS_ERROR) << "Failed to verify audio session category and mode";
-      return false;
-    }
+  // Activate the audio session. Activation can fail if another active audio
+  // session (e.g. phone call) has higher priority than ours.
+  error = nil;
+  success = [session setActive:YES error:&error];
+  if (!CheckAndLogError(success, error)) {
+    [session unlockForConfiguration];
+    return false;
+  }
 
-    // Try to set the preferred number of hardware audio channels. These calls
-    // must be done after setting the audio session’s category and mode and
-    // activating the session.
-    // We try to use mono in both directions to save resources and format
-    // conversions in the audio unit. Some devices does only support stereo;
-    // e.g. wired headset on iPhone 6.
-    // TODO(henrika): add support for stereo if needed.
-    error = nil;
-    success =
-        [session setPreferredInputNumberOfChannels:kPreferredNumberOfChannels
-                                             error:&error];
-    RTC_DCHECK(CheckAndLogError(success, error));
-    error = nil;
-    success =
-        [session setPreferredOutputNumberOfChannels:kPreferredNumberOfChannels
-                                              error:&error];
-    RTC_DCHECK(CheckAndLogError(success, error));
-    return true;
+  // Ensure that the active audio session has the correct category and mode.
+  if (!VerifyAudioSession(session)) {
+    LOG(LS_ERROR) << "Failed to verify audio session category and mode";
+    [session unlockForConfiguration];
+    return false;
   }
+
+  // Try to set the preferred number of hardware audio channels. These calls
+  // must be done after setting the audio session’s category and mode and
+  // activating the session.
+  // We try to use mono in both directions to save resources and format
+  // conversions in the audio unit. Some devices does only support stereo;
+  // e.g. wired headset on iPhone 6.
+  // TODO(henrika): add support for stereo if needed.
+  error = nil;
+  success =
+      [session setPreferredInputNumberOfChannels:kPreferredNumberOfChannels
+                                           error:&error];
+  RTC_DCHECK(CheckAndLogError(success, error));
+  error = nil;
+  success =
+      [session setPreferredOutputNumberOfChannels:kPreferredNumberOfChannels
+                                            error:&error];
+  RTC_DCHECK(CheckAndLogError(success, error));
+  [session unlockForConfiguration];
+  return true;
 }
 
 // An application can create more than one ADM and start audio streaming
 // for all of them. It is essential that we only activate the app's audio
 // session once (for the first one) and deactivate it once (for the last).
 static bool ActivateAudioSession() {
   LOGI() << "ActivateAudioSession";
-  rtc::GlobalLockScope ls(&g_lock);
-  if (g_audio_session_users == 0) {
-    // The system provides an audio session object upon launch of an
-    // application. However, we must initialize the session in order to
-    // handle interruptions. Implicit initialization occurs when obtaining
-    // a reference to the AVAudioSession object.
-    AVAudioSession* session = [AVAudioSession sharedInstance];
-    // Try to activate the audio session and ask for a set of preferred audio
-    // parameters.
-    if (!ActivateAudioSession(session, true)) {
-      LOG(LS_ERROR) << "Failed to activate the audio session";
-      return false;
-    }
-    LOG(LS_INFO) << "The audio session is now activated";
-  }
-  ++g_audio_session_users;
-  LOG(LS_INFO) << "Number of audio session users: " << g_audio_session_users;
-  return true;
+  RTCAudioSession* session = [RTCAudioSession sharedInstance];
+  return ActivateAudioSession(session, true);
 }
 
 // If more than one object is using the audio session, ensure that only the
 // last object deactivates. Apple recommends: "activate your audio session
 // only as needed and deactivate it when you are not using audio".
 static bool DeactivateAudioSession() {
   LOGI() << "DeactivateAudioSession";
-  rtc::GlobalLockScope ls(&g_lock);
-  if (g_audio_session_users == 1) {
-    AVAudioSession* session = [AVAudioSession sharedInstance];
-    if (!ActivateAudioSession(session, false)) {
-      LOG(LS_ERROR) << "Failed to deactivate the audio session";
-      return false;
-    }
-    LOG(LS_INFO) << "Our audio session is now deactivated";
-  }
-  --g_audio_session_users;
-  LOG(LS_INFO) << "Number of audio session users: " << g_audio_session_users;
-  return true;
+  RTCAudioSession* session = [RTCAudioSession sharedInstance];
+  return ActivateAudioSession(session, false);
 }
 
 #if !defined(NDEBUG)
 // Helper method for printing out an AudioStreamBasicDescription structure.
 static void LogABSD(AudioStreamBasicDescription absd) {
   char formatIDString[5];
   UInt32 formatID = CFSwapInt32HostToBig(absd.mFormatID);
   bcopy(&formatID, formatIDString, 4);
   formatIDString[4] = '\0';
   LOG(LS_INFO) << "LogABSD";
@@ skipping 72 matching lines @@
 
 int32_t AudioDeviceIOS::Terminate() {
   LOGI() << "Terminate";
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   if (!initialized_) {
     return 0;
   }
   StopPlayout();
   StopRecording();
   initialized_ = false;
-  {
-    rtc::GlobalLockScope ls(&g_lock);
-    if (g_audio_session_users != 0) {
-      LOG(LS_WARNING) << "Object is destructed with an active audio session";
-    }
-    RTC_DCHECK_GE(g_audio_session_users, 0);
-  }
   return 0;
 }
 
 int32_t AudioDeviceIOS::InitPlayout() {
   LOGI() << "InitPlayout";
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   RTC_DCHECK(initialized_);
   RTC_DCHECK(!play_is_initialized_);
   RTC_DCHECK(!playing_);
   if (!rec_is_initialized_) {
@@ skipping 85 matching lines @@
   }
   rec_is_initialized_ = false;
   rtc::AtomicOps::ReleaseStore(&recording_, 0);
   return 0;
 }
 
 // Change the default receiver playout route to speaker.
 int32_t AudioDeviceIOS::SetLoudspeakerStatus(bool enable) {
   LOGI() << "SetLoudspeakerStatus(" << enable << ")";
 
-  AVAudioSession* session = [AVAudioSession sharedInstance];
+  RTCAudioSession* session = [RTCAudioSession sharedInstance];
+  [session lockForConfiguration];
   NSString* category = session.category;
   AVAudioSessionCategoryOptions options = session.categoryOptions;
   // Respect old category options if category is
   // AVAudioSessionCategoryPlayAndRecord. Otherwise reset it since old options
   // might not be valid for this category.
   if ([category isEqualToString:AVAudioSessionCategoryPlayAndRecord]) {
     if (enable) {
       options |= AVAudioSessionCategoryOptionDefaultToSpeaker;
     } else {
       options &= ~AVAudioSessionCategoryOptionDefaultToSpeaker;
     }
   } else {
     options = AVAudioSessionCategoryOptionDefaultToSpeaker;
   }
   NSError* error = nil;
   BOOL success = [session setCategory:AVAudioSessionCategoryPlayAndRecord
                           withOptions:options
                                 error:&error];
   ios::CheckAndLogError(success, error);
+  [session unlockForConfiguration];
   return (error == nil) ? 0 : -1;
 }
 
 int32_t AudioDeviceIOS::GetLoudspeakerStatus(bool& enabled) const {
   LOGI() << "GetLoudspeakerStatus";
-  AVAudioSession* session = [AVAudioSession sharedInstance];
+  RTCAudioSession* session = [RTCAudioSession sharedInstance];
   AVAudioSessionCategoryOptions options = session.categoryOptions;
   enabled = options & AVAudioSessionCategoryOptionDefaultToSpeaker;
   return 0;
 }
 
 int32_t AudioDeviceIOS::PlayoutDelay(uint16_t& delayMS) const {
   delayMS = kFixedPlayoutDelayEstimate;
   return 0;
 }
 
@@ skipping 116 matching lines @@
         if (valid_route_change) {
           // Log previous route configuration.
           AVAudioSessionRouteDescription* prev_route =
               notification.userInfo[AVAudioSessionRouteChangePreviousRouteKey];
           LOG(LS_INFO) << "Previous route:";
           LOG(LS_INFO) << ios::StdStringFromNSString(
               [NSString stringWithFormat:@"%@", prev_route]);
 
           // Only restart audio for a valid route change and if the
           // session sample rate has changed.
-          AVAudioSession* session = [AVAudioSession sharedInstance];
+          RTCAudioSession* session = [RTCAudioSession sharedInstance];
           const double session_sample_rate = session.sampleRate;
           LOG(LS_INFO) << "session sample rate: " << session_sample_rate;
           if (playout_parameters_.sample_rate() != session_sample_rate) {
             if (!RestartAudioUnitWithNewFormat(session_sample_rate)) {
               LOG(LS_ERROR) << "Audio restart failed";
             }
           }
         }
       };
 
@@ skipping 33 matching lines @@
   if (route_change_observer_ != nullptr) {
     id observer = (__bridge_transfer id)route_change_observer_;
     [center removeObserver:observer];
     route_change_observer_ = nullptr;
   }
 }
 
 void AudioDeviceIOS::SetupAudioBuffersForActiveAudioSession() {
   LOGI() << "SetupAudioBuffersForActiveAudioSession";
   // Verify the current values once the audio session has been activated.
-  AVAudioSession* session = [AVAudioSession sharedInstance];
+  RTCAudioSession* session = [RTCAudioSession sharedInstance];
   LOG(LS_INFO) << " sample rate: " << session.sampleRate;
   LOG(LS_INFO) << " IO buffer duration: " << session.IOBufferDuration;
   LOG(LS_INFO) << " output channels: " << session.outputNumberOfChannels;
   LOG(LS_INFO) << " input channels: " << session.inputNumberOfChannels;
   LOG(LS_INFO) << " output latency: " << session.outputLatency;
   LOG(LS_INFO) << " input latency: " << session.inputLatency;
 
   // Log a warning message for the case when we are unable to set the preferred
   // hardware sample rate but continue and use the non-ideal sample rate after
   // reinitializing the audio parameters. Most BT headsets only support 8kHz or
@@ skipping 261 matching lines @@
 }
 
 bool AudioDeviceIOS::InitPlayOrRecord() {
   LOGI() << "InitPlayOrRecord";
   // Activate the audio session if not already activated.
   if (!ActivateAudioSession()) {
     return false;
   }
 
   // Ensure that the active audio session has the correct category and mode.
-  AVAudioSession* session = [AVAudioSession sharedInstance];
+  RTCAudioSession* session = [RTCAudioSession sharedInstance];
   if (!VerifyAudioSession(session)) {
     DeactivateAudioSession();
     LOG(LS_ERROR) << "Failed to verify audio session category and mode";
     return false;
   }
 
   // Start observing audio session interruptions and route changes.
   RegisterNotificationObservers();
 
   // Ensure that we got what what we asked for in our active audio session.
@@ skipping 135 matching lines @@
   // Read decoded 16-bit PCM samples from WebRTC (using a size that matches
   // the native I/O audio unit) to a preallocated intermediate buffer and
   // copy the result to the audio buffer in the |io_data| destination.
   SInt8* source = playout_audio_buffer_.get();
   fine_audio_buffer_->GetPlayoutData(source);
   memcpy(destination, source, dataSizeInBytes);
   return noErr;
 }
 
 }  // namespace webrtc