Use RTCAudioSessionDelegate in AudioDeviceIOS.

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/bind.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/criticalsection.h"
 #include "webrtc/base/logging.h"
+#include "webrtc/base/thread.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/base/objc/RTCLogging.h"
 #import "webrtc/modules/audio_device/ios/objc/RTCAudioSession.h"
+#import "webrtc/modules/audio_device/ios/objc/RTCAudioSession+Private.h"
 #import "webrtc/modules/audio_device/ios/objc/RTCAudioSessionConfiguration.h"
+#import "webrtc/modules/audio_device/ios/objc/RTCAudioSessionDelegateAdapter.h"
 
 namespace webrtc {
 
 #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;  \
@@ skipping 58 matching lines @@
     LOG(LS_INFO) << " OS version: " << ios::GetOSVersionString();
     LOG(LS_INFO) << " processing cores: " << ios::GetProcessorCount();
 #if defined(__IPHONE_9_0) && __IPHONE_OS_VERSION_MAX_ALLOWED >= __IPHONE_9_0
     LOG(LS_INFO) << " low power mode: " << ios::GetLowPowerModeEnabled();
 #endif
   }
 }
 #endif  // !defined(NDEBUG)
 
 AudioDeviceIOS::AudioDeviceIOS()
-    : audio_device_buffer_(nullptr),
-      vpio_unit_(nullptr),
-      recording_(0),
-      playing_(0),
-      initialized_(false),
-      rec_is_initialized_(false),
-      play_is_initialized_(false),
-      audio_interruption_observer_(nullptr),
-      route_change_observer_(nullptr) {
+  : async_invoker_(new rtc::AsyncInvoker()),
+    audio_device_buffer_(nullptr),
+    vpio_unit_(nullptr),
+    recording_(0),
+    playing_(0),
+    initialized_(false),
+    rec_is_initialized_(false),
+    play_is_initialized_(false),
+    is_interrupted_(false) {
   LOGI() << "ctor" << ios::GetCurrentThreadDescription();
+  thread_ = rtc::Thread::Current();
+  audio_session_observer_ =
+      [[RTCAudioSessionDelegateAdapter alloc] initWithObserver:this];
 }
 
 AudioDeviceIOS::~AudioDeviceIOS() {
   LOGI() << "~dtor" << ios::GetCurrentThreadDescription();
+  audio_session_observer_ = nil;
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   Terminate();
 }
 
 void AudioDeviceIOS::AttachAudioBuffer(AudioDeviceBuffer* audioBuffer) {
   LOGI() << "AttachAudioBuffer";
   RTC_DCHECK(audioBuffer);
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   audio_device_buffer_ = audioBuffer;
 }
@@ skipping 192 matching lines @@
 }
 
 int AudioDeviceIOS::GetRecordAudioParameters(AudioParameters* params) const {
   LOGI() << "GetRecordAudioParameters";
   RTC_DCHECK(record_parameters_.is_valid());
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   *params = record_parameters_;
   return 0;
 }
 
+void AudioDeviceIOS::OnInterruptionBegin() {
+  RTC_DCHECK(async_invoker_);
+  RTC_DCHECK(thread_);
+  if (thread_->IsCurrent()) {
+    HandleInterruptionBegin();
+    return;
+  }
+  async_invoker_->AsyncInvoke<void>(
+      thread_,
+      rtc::Bind(&webrtc::AudioDeviceIOS::HandleInterruptionBegin, this));
+}
+
+void AudioDeviceIOS::OnInterruptionEnd() {
+  RTC_DCHECK(async_invoker_);
+  RTC_DCHECK(thread_);
+  if (thread_->IsCurrent()) {
+    HandleInterruptionEnd();
+    return;
+  }
+  async_invoker_->AsyncInvoke<void>(
+      thread_,
+      rtc::Bind(&webrtc::AudioDeviceIOS::HandleInterruptionEnd, this));
+}
+
+void AudioDeviceIOS::OnValidRouteChange() {
+  RTC_DCHECK(async_invoker_);
+  RTC_DCHECK(thread_);
+  if (thread_->IsCurrent()) {
+    HandleValidRouteChange();
+    return;
+  }
+  async_invoker_->AsyncInvoke<void>(
+      thread_,
+      rtc::Bind(&webrtc::AudioDeviceIOS::HandleValidRouteChange, this));
+}
+
+void AudioDeviceIOS::HandleInterruptionBegin() {
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
+  RTCLog(@"Stopping the audio unit due to interruption begin.");
+  LOG_IF_ERROR(AudioOutputUnitStop(vpio_unit_),
+               "Failed to stop the the Voice-Processing I/O unit");
+  is_interrupted_ = true;
+}
+
+void AudioDeviceIOS::HandleInterruptionEnd() {
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
+  RTCLog(@"Starting the audio unit due to interruption end.");
+  LOG_IF_ERROR(AudioOutputUnitStart(vpio_unit_),
+               "Failed to start the the Voice-Processing I/O unit");
+  is_interrupted_ = false;
+}
+
+void AudioDeviceIOS::HandleValidRouteChange() {
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
+
+  // Don't do anything if we're interrupted.
+  if (is_interrupted_) {
+    return;
+  }
+
+  // Only restart audio for a valid route change if the session sample rate
+  // has changed.
+  RTCAudioSession* session = [RTCAudioSession sharedInstance];
+  const double current_sample_rate = playout_parameters_.sample_rate();
+  const double session_sample_rate = session.sampleRate;
+  if (current_sample_rate != session_sample_rate) {
+    RTCLog(@"Route changed caused sample rate to change from %f to %f. "
+           "Restarting audio unit.", current_sample_rate, session_sample_rate);
+    if (!RestartAudioUnitWithNewFormat(session_sample_rate)) {
+      RTCLogError(@"Audio restart failed.");
+    }
+  }
+}
+
 void AudioDeviceIOS::UpdateAudioDeviceBuffer() {
   LOGI() << "UpdateAudioDevicebuffer";
   // AttachAudioBuffer() is called at construction by the main class but check
   // just in case.
   RTC_DCHECK(audio_device_buffer_) << "AttachAudioBuffer must be called first";
   // Inform the audio device buffer (ADB) about the new audio format.
   audio_device_buffer_->SetPlayoutSampleRate(playout_parameters_.sample_rate());
   audio_device_buffer_->SetPlayoutChannels(playout_parameters_.channels());
   audio_device_buffer_->SetRecordingSampleRate(
       record_parameters_.sample_rate());
   audio_device_buffer_->SetRecordingChannels(record_parameters_.channels());
 }
 
-void AudioDeviceIOS::RegisterNotificationObservers() {
-  LOGI() << "RegisterNotificationObservers";
-  // This code block will be called when AVAudioSessionInterruptionNotification
-  // is observed.
-  void (^interrupt_block)(NSNotification*) = ^(NSNotification* notification) {
-    NSNumber* type_number =
-        notification.userInfo[AVAudioSessionInterruptionTypeKey];
-    AVAudioSessionInterruptionType type =
-        (AVAudioSessionInterruptionType)type_number.unsignedIntegerValue;
-    LOG(LS_INFO) << "Audio session interruption:";
-    switch (type) {
-      case AVAudioSessionInterruptionTypeBegan:
-        // The system has deactivated our audio session.
-        // Stop the active audio unit.
-        LOG(LS_INFO) << " Began => stopping the audio unit";
-        LOG_IF_ERROR(AudioOutputUnitStop(vpio_unit_),
-                     "Failed to stop the the Voice-Processing I/O unit");
-        break;
-      case AVAudioSessionInterruptionTypeEnded:
-        // The interruption has ended. Restart the audio session and start the
-        // initialized audio unit again.
-        LOG(LS_INFO) << " Ended => restarting audio session and audio unit";
-        NSError* error = nil;
-        BOOL success = NO;
-        AVAudioSession* session = [AVAudioSession sharedInstance];
-        success = [session setActive:YES error:&error];
-        if (CheckAndLogError(success, error)) {
-          LOG_IF_ERROR(AudioOutputUnitStart(vpio_unit_),
-                       "Failed to start the the Voice-Processing I/O unit");
-        }
-        break;
-    }
-  };
-
-  // This code block will be called when AVAudioSessionRouteChangeNotification
-  // is observed.
-  void (^route_change_block)(NSNotification*) =
-      ^(NSNotification* notification) {
-        // Get reason for current route change.
-        NSNumber* reason_number =
-            notification.userInfo[AVAudioSessionRouteChangeReasonKey];
-        AVAudioSessionRouteChangeReason reason =
-            (AVAudioSessionRouteChangeReason)reason_number.unsignedIntegerValue;
-        bool valid_route_change = true;
-        LOG(LS_INFO) << "Route change:";
-        switch (reason) {
-          case AVAudioSessionRouteChangeReasonUnknown:
-            LOG(LS_INFO) << " ReasonUnknown";
-            break;
-          case AVAudioSessionRouteChangeReasonNewDeviceAvailable:
-            LOG(LS_INFO) << " NewDeviceAvailable";
-            break;
-          case AVAudioSessionRouteChangeReasonOldDeviceUnavailable:
-            LOG(LS_INFO) << " OldDeviceUnavailable";
-            break;
-          case AVAudioSessionRouteChangeReasonCategoryChange:
-            // It turns out that we see this notification (at least in iOS 9.2)
-            // when making a switch from a BT device to e.g. Speaker using the
-            // iOS Control Center and that we therefore must check if the sample
-            // rate has changed. And if so is the case, restart the audio unit.
-            LOG(LS_INFO) << " CategoryChange";
-            LOG(LS_INFO) << " New category: " << ios::GetAudioSessionCategory();
-            break;
-          case AVAudioSessionRouteChangeReasonOverride:
-            LOG(LS_INFO) << " Override";
-            break;
-          case AVAudioSessionRouteChangeReasonWakeFromSleep:
-            LOG(LS_INFO) << " WakeFromSleep";
-            break;
-          case AVAudioSessionRouteChangeReasonNoSuitableRouteForCategory:
-            LOG(LS_INFO) << " NoSuitableRouteForCategory";
-            break;
-          case AVAudioSessionRouteChangeReasonRouteConfigurationChange:
-            // The set of input and output ports has not changed, but their
-            // configuration has, e.g., a port’s selected data source has
-            // changed. Ignore this type of route change since we are focusing
-            // on detecting headset changes.
-            LOG(LS_INFO) << " RouteConfigurationChange (ignored)";
-            valid_route_change = false;
-            break;
-        }
-
-        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.
-          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";
-            }
-          }
-        }
-      };
-
-  // Get the default notification center of the current process.
-  NSNotificationCenter* center = [NSNotificationCenter defaultCenter];
-
-  // Add AVAudioSessionInterruptionNotification observer.
-  id interruption_observer =
-      [center addObserverForName:AVAudioSessionInterruptionNotification
-                          object:nil
-                           queue:[NSOperationQueue mainQueue]
-                      usingBlock:interrupt_block];
-  // Add AVAudioSessionRouteChangeNotification observer.
-  id route_change_observer =
-      [center addObserverForName:AVAudioSessionRouteChangeNotification
-                          object:nil
-                           queue:[NSOperationQueue mainQueue]
-                      usingBlock:route_change_block];
-
-  // Increment refcount on observers using ARC bridge. Instance variable is a
-  // void* instead of an id because header is included in other pure C++
-  // files.
-  audio_interruption_observer_ = (__bridge_retained void*)interruption_observer;
-  route_change_observer_ = (__bridge_retained void*)route_change_observer;
-}
-
-void AudioDeviceIOS::UnregisterNotificationObservers() {
-  LOGI() << "UnregisterNotificationObservers";
-  // Transfer ownership of observer back to ARC, which will deallocate the
-  // observer once it exits this scope.
-  NSNotificationCenter* center = [NSNotificationCenter defaultCenter];
-  if (audio_interruption_observer_ != nullptr) {
-    id observer = (__bridge_transfer id)audio_interruption_observer_;
-    [center removeObserver:observer];
-    audio_interruption_observer_ = nullptr;
-  }
-  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.
   RTCAudioSession* session = [RTCAudioSession sharedInstance];
-  LOG(LS_INFO) << " sample rate: " << session.sampleRate;
-  LOG(LS_INFO) << " IO buffer duration: " << session.IOBufferDuration;
+  double sample_rate = session.sampleRate;
+  NSTimeInterval io_buffer_duration = session.IOBufferDuration;
+  LOG(LS_INFO) << " sample rate: " << sample_rate;
+  LOG(LS_INFO) << " IO buffer duration: " << io_buffer_duration;
   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
   // 16kHz.
   RTCAudioSessionConfiguration* webRTCConfig =
       [RTCAudioSessionConfiguration webRTCConfiguration];
-  if (session.sampleRate != webRTCConfig.sampleRate) {
+  if (sample_rate != webRTCConfig.sampleRate) {
     LOG(LS_WARNING) << "Unable to set the preferred sample rate";
   }
 
   // At this stage, we also know the exact IO buffer duration and can add
   // that info to the existing audio parameters where it is converted into
   // number of audio frames.
   // Example: IO buffer size = 0.008 seconds <=> 128 audio frames at 16kHz.
   // Hence, 128 is the size we expect to see in upcoming render callbacks.
-  playout_parameters_.reset(session.sampleRate, playout_parameters_.channels(),
-                            session.IOBufferDuration);
+  playout_parameters_.reset(sample_rate, playout_parameters_.channels(),
+                            io_buffer_duration);
   RTC_DCHECK(playout_parameters_.is_complete());
-  record_parameters_.reset(session.sampleRate, record_parameters_.channels(),
-                           session.IOBufferDuration);
+  record_parameters_.reset(sample_rate, record_parameters_.channels(),
+                           io_buffer_duration);
   RTC_DCHECK(record_parameters_.is_complete());
   LOG(LS_INFO) << " frames per I/O buffer: "
                << playout_parameters_.frames_per_buffer();
   LOG(LS_INFO) << " bytes per I/O buffer: "
                << playout_parameters_.GetBytesPerBuffer();
   RTC_DCHECK_EQ(playout_parameters_.GetBytesPerBuffer(),
                 record_parameters_.GetBytesPerBuffer());
 
   // Update the ADB parameters since the sample rate might have changed.
   UpdateAudioDeviceBuffer();
@@ skipping 245 matching lines @@
   [session lockForConfiguration];
   NSError* error = nil;
   if (![session configureWebRTCSession:&error]) {
     RTCLogError(@"Failed to configure WebRTC session: %@",
                 error.localizedDescription);
     [session unlockForConfiguration];
     return false;
   }
 
   // Start observing audio session interruptions and route changes.
-  RegisterNotificationObservers();
+  [session pushDelegate:audio_session_observer_];
 
   // Ensure that we got what what we asked for in our active audio session.
   SetupAudioBuffersForActiveAudioSession();
 
   // Create, setup and initialize a new Voice-Processing I/O unit.
   if (!SetupAndInitializeVoiceProcessingAudioUnit()) {
     [session setActive:NO error:nil];
     [session unlockForConfiguration];
     return false;
   }
@@ skipping 11 matching lines @@
       LOG_F(LS_ERROR) << "AudioOutputUnitStop failed: " << result;
     }
     result = AudioUnitUninitialize(vpio_unit_);
     if (result != noErr) {
       LOG_F(LS_ERROR) << "AudioUnitUninitialize failed: " << result;
     }
     DisposeAudioUnit();
   }
 
   // Remove audio session notification observers.
-  UnregisterNotificationObservers();
+  RTCAudioSession* session = [RTCAudioSession sharedInstance];
+  [session removeDelegate:audio_session_observer_];
 
   // All I/O should be stopped or paused prior to deactivating the audio
   // session, hence we deactivate as last action.
-  RTCAudioSession* session = [RTCAudioSession sharedInstance];
   [session lockForConfiguration];
   [session setActive:NO error:nil];
   [session unlockForConfiguration];
 }
 
 void AudioDeviceIOS::DisposeAudioUnit() {
   if (nullptr == vpio_unit_)
     return;
   OSStatus result = AudioComponentInstanceDispose(vpio_unit_);
   if (result != noErr) {
@@ skipping 94 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