Support delayed AudioUnit initialization.

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/base/objc/RTCLogging.h"
 #import "webrtc/modules/audio_device/ios/objc/RTCAudioSession+Private.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;
-  NSInteger _activationCount;
-  NSInteger _lockRecursionCount;
+  volatile int _activationCount;
+  volatile int _lockRecursionCount;
+  volatile int _webRTCSessionCount;
   BOOL _isActive;
   BOOL _shouldDelayAudioConfiguration;
 }
 
 @synthesize session = _session;
 @synthesize delegates = _delegates;
+@synthesize savedConfiguration = _savedConfiguration;
 
 + (instancetype)sharedInstance {
   static dispatch_once_t onceToken;
   static RTCAudioSession *sharedInstance = nil;
   dispatch_once(&onceToken, ^{
-    sharedInstance = [[RTCAudioSession alloc] init];
+    sharedInstance = [[self alloc] init];
   });
   return sharedInstance;
 }
 
 - (instancetype)init {
   if (self = [super init]) {
     _session = [AVAudioSession sharedInstance];
 
     NSNotificationCenter *center = [NSNotificationCenter defaultCenter];
     [center addObserver:self
@@ skipping 45 matching lines @@
   }
 }
 
 - (BOOL)isActive {
   @synchronized(self) {
     return _isActive;
   }
 }
 
 - (BOOL)isLocked {
-  @synchronized(self) {
-    return _lockRecursionCount > 0;
-  }
+  return _lockRecursionCount > 0;
 }
 
 - (void)setShouldDelayAudioConfiguration:(BOOL)shouldDelayAudioConfiguration {
   @synchronized(self) {
+    // No one should be changing this while an audio device is active.
+    RTC_DCHECK(!self.isConfiguredForWebRTC);
     if (_shouldDelayAudioConfiguration == shouldDelayAudioConfiguration) {
       return;
     }
     _shouldDelayAudioConfiguration = shouldDelayAudioConfiguration;
   }
 }
 
 - (BOOL)shouldDelayAudioConfiguration {
   @synchronized(self) {
     return _shouldDelayAudioConfiguration;
   }
 }
 
+// TODO(tkchin): Check for duplicates.
 - (void)addDelegate:(id<RTCAudioSessionDelegate>)delegate {
   if (!delegate) {
     return;
   }
   @synchronized(self) {
     _delegates.push_back(delegate);
     [self removeZeroedDelegates];
   }
 }
 
 - (void)removeDelegate:(id<RTCAudioSessionDelegate>)delegate {
   if (!delegate) {
     return;
   }
   @synchronized(self) {
     _delegates.erase(std::remove(_delegates.begin(),
                                  _delegates.end(),
                                  delegate));
     [self removeZeroedDelegates];
   }
 }
 
 - (void)lockForConfiguration {
   _crit.Enter();
-  @synchronized(self) {
-    ++_lockRecursionCount;
-  }
+  rtc::AtomicOps::Increment(&_lockRecursionCount);
 }
 
 - (void)unlockForConfiguration {
   // Don't let threads other than the one that called lockForConfiguration
   // unlock.
   if (_crit.TryEnter()) {
-    @synchronized(self) {
-      --_lockRecursionCount;
-    }
+    rtc::AtomicOps::Decrement(&_lockRecursionCount);
     // One unlock for the tryLock, and another one to actually unlock. If this
     // was called without anyone calling lock, we will hit an assertion.
     _crit.Leave();
     _crit.Leave();
   }
 }
 
 #pragma mark - AVAudioSession proxy methods
 
 - (NSString *)category {
@@ skipping 80 matching lines @@
   return self.session.IOBufferDuration;
 }
 
 // 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;
   }
-  NSInteger activationCount = self.activationCount;
+  int activationCount = _activationCount;
   if (!active && activationCount == 0) {
     RTCLogWarning(@"Attempting to deactivate without prior activation.");
   }
   BOOL success = YES;
   BOOL isActive = self.isActive;
   // Keep a local error so we can log it.
   NSError *error = nil;
   BOOL shouldSetActive =
       (active && !isActive) || (!active && isActive && activationCount == 1);
   // Attempt to activate if we're not active.
@@ skipping 21 matching lines @@
       [self incrementActivationCount];
     }
   } else {
     RTCLogError(@"Failed to setActive:%d. Error: %@",
                 active, error.localizedDescription);
   }
   // Decrement activation count on deactivation whether or not it succeeded.
   if (!active) {
     [self decrementActivationCount];
   }
-  RTCLog(@"Number of current activations: %ld", (long)self.activationCount);
+  RTCLog(@"Number of current activations: %d", _activationCount);
   return success;
 }
 
 - (BOOL)setCategory:(NSString *)category
         withOptions:(AVAudioSessionCategoryOptions)options
               error:(NSError **)outError {
   if (![self checkLock:outError]) {
     return NO;
   }
   return [self.session setCategory:category withOptions:options error:outError];
@@ skipping 171 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) {
     for (auto it = _delegates.begin(); it != _delegates.end(); ++it) {
       if (!*it) {
         _delegates.erase(it);
       }
     }
   }
 }
 
-- (NSInteger)activationCount {
-  @synchronized(self) {
-    return _activationCount;
-  }
+- (int)activationCount {
+  return _activationCount;
 }
 
-- (NSInteger)incrementActivationCount {
+- (int)incrementActivationCount {
   RTCLog(@"Incrementing activation count.");
-  @synchronized(self) {
-    return ++_activationCount;
-  }
+  return rtc::AtomicOps::Increment(&_activationCount);
 }
 
 - (NSInteger)decrementActivationCount {
   RTCLog(@"Decrementing activation count.");
-  @synchronized(self) {
-    return --_activationCount;
-  }
+  return rtc::AtomicOps::Decrement(&_activationCount);
+}
+
+- (int)webRTCSessionCount {
+  return _webRTCSessionCount;
 }
 
 - (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;
+  }
+
+  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;
+  }
+
+  // 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.
+  NSError *error = nil;
+  if (![self unconfigureWebRTCSession:&error]) {
+    RTCLogError(@"Error unconfiguring audio session: %@",
+                error.localizedDescription);
+    if (outError) {
+      *outError = error;
+    }
+    return NO;
+  }
+
+  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)notifyDidBeginInterruption {
   for (auto delegate : self.delegates) {
-    [delegate audioSessionDidBeginInterruption:self];
+    SEL sel = @selector(audioSessionDidBeginInterruption:);
+    if ([delegate respondsToSelector:sel]) {
+      [delegate audioSessionDidBeginInterruption:self];
+    }
   }
 }
 
 - (void)notifyDidEndInterruptionWithShouldResumeSession:
     (BOOL)shouldResumeSession {
   for (auto delegate : self.delegates) {
-    [delegate audioSessionDidEndInterruption:self
-                         shouldResumeSession:shouldResumeSession];
+    SEL sel = @selector(audioSessionDidEndInterruption:shouldResumeSession:);
+    if ([delegate respondsToSelector:sel]) {
+      [delegate audioSessionDidEndInterruption:self
+                           shouldResumeSession:shouldResumeSession];
+    }
   }
-
 }
 
 - (void)notifyDidChangeRouteWithReason:(AVAudioSessionRouteChangeReason)reason
     previousRoute:(AVAudioSessionRouteDescription *)previousRoute {
   for (auto delegate : self.delegates) {
-    [delegate audioSessionDidChangeRoute:self
-                                  reason:reason
-                           previousRoute:previousRoute];
+    SEL sel = @selector(audioSessionDidChangeRoute:reason:previousRoute:);
+    if ([delegate respondsToSelector:sel]) {
+      [delegate audioSessionDidChangeRoute:self
+                                    reason:reason
+                             previousRoute:previousRoute];
+    }
   }
 }
 
 - (void)notifyMediaServicesWereLost {
   for (auto delegate : self.delegates) {
-    [delegate audioSessionMediaServicesWereLost:self];
+    SEL sel = @selector(audioSessionMediaServicesWereLost:);
+    if ([delegate respondsToSelector:sel]) {
+      [delegate audioSessionMediaServicesWereLost:self];
+    }
   }
 }
 
 - (void)notifyMediaServicesWereReset {
   for (auto delegate : self.delegates) {
-    [delegate audioSessionMediaServicesWereReset:self];
+    SEL sel = @selector(audioSessionMediaServicesWereReset:);
+    if ([delegate respondsToSelector:sel]) {
+      [delegate audioSessionMediaServicesWereReset:self];
+    }
   }
 }
 
+- (void)notifyShouldConfigure {
+  for (auto delegate : self.delegates) {
+    SEL sel = @selector(audioSessionShouldConfigure:);
+    if ([delegate respondsToSelector:sel]) {
+      [delegate audioSessionShouldConfigure:self];
+    }
+  }
+}
+
+- (void)notifyShouldUnconfigure {
+  for (auto delegate : self.delegates) {
+    SEL sel = @selector(audioSessionShouldUnconfigure:);
+    if ([delegate respondsToSelector:sel]) {
+      [delegate audioSessionShouldUnconfigure:self];
+    }
+  }
+}
+
+- (void)notifyDidConfigure {
+  for (auto delegate : self.delegates) {
+    SEL sel = @selector(audioSessionDidConfigure:);
+    if ([delegate respondsToSelector:sel]) {
+      [delegate audioSessionDidConfigure:self];
+    }
+  }
+}
+
+- (void)notifyDidUnconfigure {
+  for (auto delegate : self.delegates) {
+    SEL sel = @selector(audioSessionDidUnconfigure:);
+    if ([delegate respondsToSelector:sel]) {
+      [delegate audioSessionDidUnconfigure:self];
+    }
+  }
+}
+
 @end