Refactor AVAudioSession intialization code.

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/checks.h"
 #include "webrtc/base/criticalsection.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;
   NSHashTable *_delegates;
   NSInteger _activationCount;
   NSInteger _lockRecursionCount;
   BOOL _isActive;
+  BOOL _shouldDelayAudioConfiguration;
 }
 
 @synthesize session = _session;
 
 + (instancetype)sharedInstance {
   static dispatch_once_t onceToken;
   static RTCAudioSession *sharedInstance = nil;
   dispatch_once(&onceToken, ^{
     sharedInstance = [[RTCAudioSession alloc] init];
   });
@@ skipping 42 matching lines @@
     return _isActive;
   }
 }
 
 - (BOOL)isLocked {
   @synchronized(self) {
     return _lockRecursionCount > 0;
   }
 }
 
+- (void)setShouldDelayAudioConfiguration:(BOOL)shouldDelayAudioConfiguration {
+  @synchronized(self) {
+    if (_shouldDelayAudioConfiguration == shouldDelayAudioConfiguration) {
+      return;
+    }
+    _shouldDelayAudioConfiguration = shouldDelayAudioConfiguration;
+  }
+}
+
+- (BOOL)shouldDelayAudioConfiguration {
+  @synchronized(self) {
+    return _shouldDelayAudioConfiguration;
+  }
+}
+
 - (void)addDelegate:(id<RTCAudioSessionDelegate>)delegate {
   @synchronized(self) {
     [_delegates addObject:delegate];
   }
 }
 
 - (void)removeDelegate:(id<RTCAudioSessionDelegate>)delegate {
   @synchronized(self) {
     [_delegates removeObject:delegate];
   }
@@ skipping 139 matching lines @@
     }
   }
   if (success) {
     if (shouldSetActive) {
       self.isActive = active;
     }
     if (active) {
       [self incrementActivationCount];
     }
   } else {
-    RTCLogError(@"Failed to setActive:%d. Error: %@", active, error);
+    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);
   return success;
 }
 
 - (BOOL)setCategory:(NSString *)category
@@ skipping 170 matching lines @@
     NSLocalizedDescriptionKey:
         @"Must call lockForConfiguration before calling this method."
   };
   NSError *error =
       [[NSError alloc] initWithDomain:kRTCAudioSessionErrorDomain
                                  code:kRTCAudioSessionErrorLockRequired
                              userInfo:userInfo];
   return error;
 }
 
-- (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;
-}
-
 - (NSSet *)delegates {
   @synchronized(self) {
     return _delegates.setRepresentation;
   }
 }
 
 - (NSInteger)activationCount {
   @synchronized(self) {
     return _activationCount;
   }
 }
 
 - (NSInteger)incrementActivationCount {
   RTCLog(@"Incrementing activation count.");
   @synchronized(self) {
     return ++_activationCount;
   }
 }
 
 - (NSInteger)decrementActivationCount {
   RTCLog(@"Decrementing activation count.");
   @synchronized(self) {
     return --_activationCount;
   }
 }
 
+- (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;
+}
+
 - (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 {
@@ skipping 32 matching lines @@
   }
 }
 
 - (void)notifyMediaServicesWereReset {
   for (id<RTCAudioSessionDelegate> delegate in self.delegates) {
     [delegate audioSessionMediaServicesWereReset:self];
   }
 }
 
 @end