Provide isAudioEnabled flag to control audio unit.

webrtc/modules/audio_device/ios/objc/RTCAudioSession.mm

 /*
  *  Copyright 2016 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.
  */
 
 #import "webrtc/modules/audio_device/ios/objc/RTCAudioSession.h"
 
 #include "webrtc/base/atomicops.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/criticalsection.h"
 #include "webrtc/modules/audio_device/ios/audio_device_ios.h"
 
 #import "WebRTC/RTCLogging.h"
 #import "webrtc/modules/audio_device/ios/objc/RTCAudioSession+Private.h"
+#import "webrtc/modules/audio_device/ios/objc/RTCAudioSessionConfiguration.h"
 
 NSString * const kRTCAudioSessionErrorDomain = @"org.webrtc.RTCAudioSession";
 NSInteger const kRTCAudioSessionErrorLockRequired = -1;
 NSInteger const kRTCAudioSessionErrorConfiguration = -2;
 
 // This class needs to be thread-safe because it is accessed from many threads.
 // TODO(tkchin): Consider more granular locking. We're not expecting a lot of
 // lock contention so coarse locks should be fine for now.
 @implementation RTCAudioSession {
   rtc::CriticalSection _crit;
   AVAudioSession *_session;
   volatile int _activationCount;
   volatile int _lockRecursionCount;
   volatile int _webRTCSessionCount;
   BOOL _isActive;
-  BOOL _shouldDelayAudioConfiguration;
+  BOOL _useManualAudio;
+  BOOL _isAudioEnabled;
+  BOOL _canPlayOrRecord;
 }
 
 @synthesize session = _session;
 @synthesize delegates = _delegates;
-@synthesize savedConfiguration = _savedConfiguration;
 
 + (instancetype)sharedInstance {
   static dispatch_once_t onceToken;
   static RTCAudioSession *sharedInstance = nil;
   dispatch_once(&onceToken, ^{
     sharedInstance = [[self alloc] init];
   });
   return sharedInstance;
 }
 
@@ skipping 23 matching lines @@
   return self;
 }
 
 - (void)dealloc {
   [[NSNotificationCenter defaultCenter] removeObserver:self];
 }
 
 - (NSString *)description {
   NSString *format =
       @"RTCAudioSession: {\n"
+       "  category: %@\n"
+       "  categoryOptions: %ld\n"
+       "  mode: %@\n"
        "  isActive: %d\n"
        "  sampleRate: %.2f\n"
        "  IOBufferDuration: %f\n"
        "  outputNumberOfChannels: %ld\n"
        "  inputNumberOfChannels: %ld\n"
        "  outputLatency: %f\n"
        "  inputLatency: %f\n"
        "}";
   NSString *description = [NSString stringWithFormat:format,
+      self.category, (long)self.categoryOptions, self.mode,
       self.isActive, self.sampleRate, self.IOBufferDuration,
       self.outputNumberOfChannels, self.inputNumberOfChannels,
       self.outputLatency, self.inputLatency];
   return description;
 }
 
 - (void)setIsActive:(BOOL)isActive {
   @synchronized(self) {
     _isActive = isActive;
   }
 }
 
 - (BOOL)isActive {
   @synchronized(self) {
     return _isActive;
   }
 }
 
 - (BOOL)isLocked {
   return _lockRecursionCount > 0;
 }
 
-- (void)setShouldDelayAudioConfiguration:(BOOL)shouldDelayAudioConfiguration {
+- (void)setUseManualAudio:(BOOL)useManualAudio {
   @synchronized(self) {
-    // No one should be changing this while an audio device is active.
-    RTC_DCHECK(!self.isConfiguredForWebRTC);
-    if (_shouldDelayAudioConfiguration == shouldDelayAudioConfiguration) {
+    if (_useManualAudio == useManualAudio) {
       return;
     }
-    _shouldDelayAudioConfiguration = shouldDelayAudioConfiguration;
+    _useManualAudio = useManualAudio;
+  }
+  [self updateCanPlayOrRecord];
+}
+
+- (BOOL)useManualAudio {
+  @synchronized(self) {
+    return _useManualAudio;
   }
 }
 
-- (BOOL)shouldDelayAudioConfiguration {
+- (void)setIsAudioEnabled:(BOOL)isAudioEnabled {
   @synchronized(self) {
-    return _shouldDelayAudioConfiguration;
+    if (_isAudioEnabled == isAudioEnabled) {
+      return;
+    }
+    _isAudioEnabled = isAudioEnabled;
+  }
+  [self updateCanPlayOrRecord];
+}
+
+- (BOOL)isAudioEnabled {
+  @synchronized(self) {
+    return _isAudioEnabled;
   }
 }
 
 // TODO(tkchin): Check for duplicates.
 - (void)addDelegate:(id<RTCAudioSessionDelegate>)delegate {
   if (!delegate) {
     return;
   }
   @synchronized(self) {
     _delegates.push_back(delegate);
@@ skipping 86 matching lines @@
 }
 
 - (AVAudioSessionDataSourceDescription *)outputDataSource {
   return self.session.outputDataSource;
 }
 
 - (double)sampleRate {
   return self.session.sampleRate;
 }
 
+- (double)preferredSampleRate {
+  return self.session.preferredSampleRate;
+}
+
 - (NSInteger)inputNumberOfChannels {
   return self.session.inputNumberOfChannels;
 }
 
 - (NSInteger)outputNumberOfChannels {
   return self.session.outputNumberOfChannels;
 }
 
 - (float)outputVolume {
   return self.session.outputVolume;
 }
 
 - (NSTimeInterval)inputLatency {
   return self.session.inputLatency;
 }
 
 - (NSTimeInterval)outputLatency {
   return self.session.outputLatency;
 }
 
 - (NSTimeInterval)IOBufferDuration {
   return self.session.IOBufferDuration;
 }
 
+- (NSTimeInterval)preferredIOBufferDuration {
+  return self.session.preferredIOBufferDuration;
+}
+
 // TODO(tkchin): Simplify the amount of locking happening here. Likely that we
 // can just do atomic increments / decrements.
 - (BOOL)setActive:(BOOL)active
             error:(NSError **)outError {
   if (![self checkLock:outError]) {
     return NO;
   }
   int activationCount = _activationCount;
   if (!active && activationCount == 0) {
     RTCLogWarning(@"Attempting to deactivate without prior activation.");
@@ skipping 221 matching lines @@
   return error;
 }
 
 - (std::vector<__weak id<RTCAudioSessionDelegate> >)delegates {
   @synchronized(self) {
     // Note: this returns a copy.
     return _delegates;
   }
 }
 
-- (void)setSavedConfiguration:(RTCAudioSessionConfiguration *)configuration {
-  @synchronized(self) {
-    if (_savedConfiguration == configuration) {
-      return;
-    }
-    _savedConfiguration = configuration;
-  }
-}
-
-- (RTCAudioSessionConfiguration *)savedConfiguration {
-  @synchronized(self) {
-    return _savedConfiguration;
-  }
-}
-
 // TODO(tkchin): check for duplicates.
 - (void)pushDelegate:(id<RTCAudioSessionDelegate>)delegate {
   @synchronized(self) {
     _delegates.insert(_delegates.begin(), delegate);
   }
 }
 
 - (void)removeZeroedDelegates {
   @synchronized(self) {
     _delegates.erase(
@@ skipping 15 matching lines @@
 
 - (NSInteger)decrementActivationCount {
   RTCLog(@"Decrementing activation count.");
   return rtc::AtomicOps::Decrement(&_activationCount);
 }
 
 - (int)webRTCSessionCount {
   return _webRTCSessionCount;
 }
 
+- (BOOL)canPlayOrRecord {
+  return !self.useManualAudio || self.isAudioEnabled;
+}
+
 - (BOOL)checkLock:(NSError **)outError {
   // Check ivar instead of trying to acquire lock so that we won't accidentally
   // acquire lock if it hasn't already been called.
   if (!self.isLocked) {
     if (outError) {
       *outError = [RTCAudioSession lockError];
     }
     return NO;
   }
   return YES;
 }
 
 - (BOOL)beginWebRTCSession:(NSError **)outError {
   if (outError) {
     *outError = nil;
   }
   if (![self checkLock:outError]) {
     return NO;
   }
-  NSInteger sessionCount = rtc::AtomicOps::Increment(&_webRTCSessionCount);
-  if (sessionCount > 1) {
-    // Should already be configured.
-    RTC_DCHECK(self.isConfiguredForWebRTC);
-    return YES;
-  }
-
-  // Only perform configuration steps once. Application might have already
-  // configured the session.
-  if (self.isConfiguredForWebRTC) {
-    // Nothing more to do, already configured.
-    return YES;
-  }
-
-  // If application has prevented automatic configuration, return here and wait
-  // for application to call configureWebRTCSession.
-  if (self.shouldDelayAudioConfiguration) {
-    [self notifyShouldConfigure];
-    return YES;
-  }
-
-  // Configure audio session.
-  NSError *error = nil;
-  if (![self configureWebRTCSession:&error]) {
-    RTCLogError(@"Error configuring audio session: %@",
-                error.localizedDescription);
-    if (outError) {
-      *outError = error;
-    }
-    return NO;
-  }
-
+  rtc::AtomicOps::Increment(&_webRTCSessionCount);
+  [self notifyDidStartPlayOrRecord];
   return YES;
 }
 
 - (BOOL)endWebRTCSession:(NSError **)outError {
   if (outError) {
     *outError = nil;
   }
   if (![self checkLock:outError]) {
     return NO;
   }
-  int sessionCount = rtc::AtomicOps::Decrement(&_webRTCSessionCount);
-  RTC_DCHECK_GE(sessionCount, 0);
-  if (sessionCount != 0) {
-    // Should still be configured.
-    RTC_DCHECK(self.isConfiguredForWebRTC);
-    return YES;
+  rtc::AtomicOps::Decrement(&_webRTCSessionCount);
+  [self notifyDidStopPlayOrRecord];
+  return YES;
+}
+
+- (BOOL)configureWebRTCSession:(NSError **)outError {
+  if (outError) {
+    *outError = nil;
   }
+  if (![self checkLock:outError]) {
+    return NO;
+  }
+  RTCLog(@"Configuring audio session for WebRTC.");
 
-  // Only unconfigure if application has not done it.
-  if (!self.isConfiguredForWebRTC) {
-    // Nothing more to do, already unconfigured.
-    return YES;
-  }
-
-  // If application has prevented automatic configuration, return here and wait
-  // for application to call unconfigureWebRTCSession.
-  if (self.shouldDelayAudioConfiguration) {
-    [self notifyShouldUnconfigure];
-    return YES;
-  }
-
-  // Unconfigure audio session.
+  // Configure the AVAudioSession and activate it.
+  // Provide an error even if there isn't one so we can log it.
   NSError *error = nil;
-  if (![self unconfigureWebRTCSession:&error]) {
-    RTCLogError(@"Error unconfiguring audio session: %@",
+  RTCAudioSessionConfiguration *webRTCConfig =
+      [RTCAudioSessionConfiguration webRTCConfiguration];
+  if (![self setConfiguration:webRTCConfig active:YES error:&error]) {
+    RTCLogError(@"Failed to set WebRTC audio configuration: %@",
                 error.localizedDescription);
+    [self unconfigureWebRTCSession:nil];
     if (outError) {
       *outError = error;
     }
     return NO;
   }
 
+  // Ensure that the device currently supports audio input.
+  // TODO(tkchin): Figure out if this is really necessary.
+  if (!self.inputAvailable) {
+    RTCLogError(@"No audio input path is available!");
+    [self unconfigureWebRTCSession:nil];
+    if (outError) {
+      *outError = [self configurationErrorWithDescription:@"No input path."];
+    }
+    return NO;
+  }
+
   return YES;
 }
+
+- (BOOL)unconfigureWebRTCSession:(NSError **)outError {
+  if (outError) {
+    *outError = nil;
+  }
+  if (![self checkLock:outError]) {
+    return NO;
+  }
+  RTCLog(@"Unconfiguring audio session for WebRTC.");
+  [self setActive:NO error:outError];
+
+  return YES;
+}
 
 - (NSError *)configurationErrorWithDescription:(NSString *)description {
   NSDictionary* userInfo = @{
     NSLocalizedDescriptionKey: description,
   };
   return [[NSError alloc] initWithDomain:kRTCAudioSessionErrorDomain
                                     code:kRTCAudioSessionErrorConfiguration
                                 userInfo:userInfo];
 }
 
 - (void)updateAudioSessionAfterEvent {
   BOOL shouldActivate = self.activationCount > 0;
   AVAudioSessionSetActiveOptions options = shouldActivate ?
       0 : AVAudioSessionSetActiveOptionNotifyOthersOnDeactivation;
   NSError *error = nil;
   if ([self.session setActive:shouldActivate
                   withOptions:options
                         error:&error]) {
     self.isActive = shouldActivate;
   } else {
     RTCLogError(@"Failed to set session active to %d. Error:%@",
                 shouldActivate, error.localizedDescription);
   }
 }
 
+- (void)updateCanPlayOrRecord {
+  BOOL canPlayOrRecord = NO;
+  BOOL shouldNotify = NO;
+  @synchronized(self) {
+    canPlayOrRecord = !self.useManualAudio || self.isAudioEnabled;
+    if (_canPlayOrRecord == canPlayOrRecord) {
+      return;
+    }
+    _canPlayOrRecord = canPlayOrRecord;
+    shouldNotify = YES;
+  }
+  if (shouldNotify) {
+    [self notifyDidChangeCanPlayOrRecord:canPlayOrRecord];
+  }
+}
+
 - (void)notifyDidBeginInterruption {
   for (auto delegate : self.delegates) {
     SEL sel = @selector(audioSessionDidBeginInterruption:);
     if ([delegate respondsToSelector:sel]) {
       [delegate audioSessionDidBeginInterruption:self];
     }
   }
 }
 
 - (void)notifyDidEndInterruptionWithShouldResumeSession:
@@ skipping 30 matching lines @@
 
 - (void)notifyMediaServicesWereReset {
   for (auto delegate : self.delegates) {
     SEL sel = @selector(audioSessionMediaServicesWereReset:);
     if ([delegate respondsToSelector:sel]) {
       [delegate audioSessionMediaServicesWereReset:self];
     }
   }
 }
 
-- (void)notifyShouldConfigure {
+- (void)notifyDidChangeCanPlayOrRecord:(BOOL)canPlayOrRecord {
   for (auto delegate : self.delegates) {
-    SEL sel = @selector(audioSessionShouldConfigure:);
+    SEL sel = @selector(audioSession:didChangeCanPlayOrRecord:);
     if ([delegate respondsToSelector:sel]) {
-      [delegate audioSessionShouldConfigure:self];
+      [delegate audioSession:self didChangeCanPlayOrRecord:canPlayOrRecord];
     }
   }
 }
 
-- (void)notifyShouldUnconfigure {
+- (void)notifyDidStartPlayOrRecord {
   for (auto delegate : self.delegates) {
-    SEL sel = @selector(audioSessionShouldUnconfigure:);
+    SEL sel = @selector(audioSessionDidStartPlayOrRecord:);
     if ([delegate respondsToSelector:sel]) {
-      [delegate audioSessionShouldUnconfigure:self];
+      [delegate audioSessionDidStartPlayOrRecord:self];
     }
   }
 }
 
-- (void)notifyDidConfigure {
+- (void)notifyDidStopPlayOrRecord {
   for (auto delegate : self.delegates) {
-    SEL sel = @selector(audioSessionDidConfigure:);
+    SEL sel = @selector(audioSessionDidStopPlayOrRecord:);
     if ([delegate respondsToSelector:sel]) {
-      [delegate audioSessionDidConfigure:self];
+      [delegate audioSessionDidStopPlayOrRecord:self];
     }
   }
 }
-
-- (void)notifyDidUnconfigure {
-  for (auto delegate : self.delegates) {
-    SEL sel = @selector(audioSessionDidUnconfigure:);
-    if ([delegate respondsToSelector:sel]) {
-      [delegate audioSessionDidUnconfigure:self];
-    }
-  }
-}
 
 @end