You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1005 lines
31 KiB
1005 lines
31 KiB
/*
|
|
* 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 "RTCAudioSession+Private.h"
|
|
|
|
#import <UIKit/UIKit.h>
|
|
|
|
#include <vector>
|
|
|
|
#include "rtc_base/atomic_ops.h"
|
|
#include "rtc_base/checks.h"
|
|
#include "rtc_base/deprecated/recursive_critical_section.h"
|
|
|
|
#import "RTCAudioSessionConfiguration.h"
|
|
#import "base/RTCLogging.h"
|
|
|
|
NSString *const kRTCAudioSessionErrorDomain = @"org.webrtc.RTC_OBJC_TYPE(RTCAudioSession)";
|
|
NSInteger const kRTCAudioSessionErrorLockRequired = -1;
|
|
NSInteger const kRTCAudioSessionErrorConfiguration = -2;
|
|
NSString * const kRTCAudioSessionOutputVolumeSelector = @"outputVolume";
|
|
|
|
@interface RTC_OBJC_TYPE (RTCAudioSession)
|
|
() @property(nonatomic,
|
|
readonly) std::vector<__weak id<RTC_OBJC_TYPE(RTCAudioSessionDelegate)> > delegates;
|
|
@end
|
|
|
|
// 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 RTC_OBJC_TYPE (RTCAudioSession) {
|
|
rtc::RecursiveCriticalSection _crit;
|
|
AVAudioSession *_session;
|
|
volatile int _activationCount;
|
|
volatile int _lockRecursionCount;
|
|
volatile int _webRTCSessionCount;
|
|
BOOL _isActive;
|
|
BOOL _useManualAudio;
|
|
BOOL _isAudioEnabled;
|
|
BOOL _canPlayOrRecord;
|
|
BOOL _isInterrupted;
|
|
}
|
|
|
|
@synthesize session = _session;
|
|
@synthesize delegates = _delegates;
|
|
@synthesize ignoresPreferredAttributeConfigurationErrors =
|
|
_ignoresPreferredAttributeConfigurationErrors;
|
|
|
|
+ (instancetype)sharedInstance {
|
|
static dispatch_once_t onceToken;
|
|
static RTC_OBJC_TYPE(RTCAudioSession) *sharedInstance = nil;
|
|
dispatch_once(&onceToken, ^{
|
|
sharedInstance = [[self alloc] init];
|
|
});
|
|
return sharedInstance;
|
|
}
|
|
|
|
- (instancetype)init {
|
|
return [self initWithAudioSession:[AVAudioSession sharedInstance]];
|
|
}
|
|
|
|
/** This initializer provides a way for unit tests to inject a fake/mock audio session. */
|
|
- (instancetype)initWithAudioSession:(id)audioSession {
|
|
if (self = [super init]) {
|
|
_session = audioSession;
|
|
|
|
NSNotificationCenter *center = [NSNotificationCenter defaultCenter];
|
|
[center addObserver:self
|
|
selector:@selector(handleInterruptionNotification:)
|
|
name:AVAudioSessionInterruptionNotification
|
|
object:nil];
|
|
[center addObserver:self
|
|
selector:@selector(handleRouteChangeNotification:)
|
|
name:AVAudioSessionRouteChangeNotification
|
|
object:nil];
|
|
[center addObserver:self
|
|
selector:@selector(handleMediaServicesWereLost:)
|
|
name:AVAudioSessionMediaServicesWereLostNotification
|
|
object:nil];
|
|
[center addObserver:self
|
|
selector:@selector(handleMediaServicesWereReset:)
|
|
name:AVAudioSessionMediaServicesWereResetNotification
|
|
object:nil];
|
|
// Posted on the main thread when the primary audio from other applications
|
|
// starts and stops. Foreground applications may use this notification as a
|
|
// hint to enable or disable audio that is secondary.
|
|
[center addObserver:self
|
|
selector:@selector(handleSilenceSecondaryAudioHintNotification:)
|
|
name:AVAudioSessionSilenceSecondaryAudioHintNotification
|
|
object:nil];
|
|
// Also track foreground event in order to deal with interruption ended situation.
|
|
[center addObserver:self
|
|
selector:@selector(handleApplicationDidBecomeActive:)
|
|
name:UIApplicationDidBecomeActiveNotification
|
|
object:nil];
|
|
[_session addObserver:self
|
|
forKeyPath:kRTCAudioSessionOutputVolumeSelector
|
|
options:NSKeyValueObservingOptionNew | NSKeyValueObservingOptionOld
|
|
context:(__bridge void *)RTC_OBJC_TYPE(RTCAudioSession).class];
|
|
|
|
RTCLog(@"RTC_OBJC_TYPE(RTCAudioSession) (%p): init.", self);
|
|
}
|
|
return self;
|
|
}
|
|
|
|
- (void)dealloc {
|
|
[[NSNotificationCenter defaultCenter] removeObserver:self];
|
|
[_session removeObserver:self
|
|
forKeyPath:kRTCAudioSessionOutputVolumeSelector
|
|
context:(__bridge void *)RTC_OBJC_TYPE(RTCAudioSession).class];
|
|
RTCLog(@"RTC_OBJC_TYPE(RTCAudioSession) (%p): dealloc.", self);
|
|
}
|
|
|
|
- (NSString *)description {
|
|
NSString *format = @"RTC_OBJC_TYPE(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"
|
|
" outputVolume: %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, self.outputVolume];
|
|
return description;
|
|
}
|
|
|
|
- (void)setIsActive:(BOOL)isActive {
|
|
@synchronized(self) {
|
|
_isActive = isActive;
|
|
}
|
|
}
|
|
|
|
- (BOOL)isActive {
|
|
@synchronized(self) {
|
|
return _isActive;
|
|
}
|
|
}
|
|
|
|
- (BOOL)isLocked {
|
|
return _lockRecursionCount > 0;
|
|
}
|
|
|
|
- (void)setUseManualAudio:(BOOL)useManualAudio {
|
|
@synchronized(self) {
|
|
if (_useManualAudio == useManualAudio) {
|
|
return;
|
|
}
|
|
_useManualAudio = useManualAudio;
|
|
}
|
|
[self updateCanPlayOrRecord];
|
|
}
|
|
|
|
- (BOOL)useManualAudio {
|
|
@synchronized(self) {
|
|
return _useManualAudio;
|
|
}
|
|
}
|
|
|
|
- (void)setIsAudioEnabled:(BOOL)isAudioEnabled {
|
|
@synchronized(self) {
|
|
if (_isAudioEnabled == isAudioEnabled) {
|
|
return;
|
|
}
|
|
_isAudioEnabled = isAudioEnabled;
|
|
}
|
|
[self updateCanPlayOrRecord];
|
|
}
|
|
|
|
- (BOOL)isAudioEnabled {
|
|
@synchronized(self) {
|
|
return _isAudioEnabled;
|
|
}
|
|
}
|
|
|
|
- (void)setIgnoresPreferredAttributeConfigurationErrors:
|
|
(BOOL)ignoresPreferredAttributeConfigurationErrors {
|
|
@synchronized(self) {
|
|
if (_ignoresPreferredAttributeConfigurationErrors ==
|
|
ignoresPreferredAttributeConfigurationErrors) {
|
|
return;
|
|
}
|
|
_ignoresPreferredAttributeConfigurationErrors = ignoresPreferredAttributeConfigurationErrors;
|
|
}
|
|
}
|
|
|
|
- (BOOL)ignoresPreferredAttributeConfigurationErrors {
|
|
@synchronized(self) {
|
|
return _ignoresPreferredAttributeConfigurationErrors;
|
|
}
|
|
}
|
|
|
|
// TODO(tkchin): Check for duplicates.
|
|
- (void)addDelegate:(id<RTC_OBJC_TYPE(RTCAudioSessionDelegate)>)delegate {
|
|
RTCLog(@"Adding delegate: (%p)", delegate);
|
|
if (!delegate) {
|
|
return;
|
|
}
|
|
@synchronized(self) {
|
|
_delegates.push_back(delegate);
|
|
[self removeZeroedDelegates];
|
|
}
|
|
}
|
|
|
|
- (void)removeDelegate:(id<RTC_OBJC_TYPE(RTCAudioSessionDelegate)>)delegate {
|
|
RTCLog(@"Removing delegate: (%p)", delegate);
|
|
if (!delegate) {
|
|
return;
|
|
}
|
|
@synchronized(self) {
|
|
_delegates.erase(std::remove(_delegates.begin(),
|
|
_delegates.end(),
|
|
delegate),
|
|
_delegates.end());
|
|
[self removeZeroedDelegates];
|
|
}
|
|
}
|
|
|
|
#pragma clang diagnostic push
|
|
#pragma clang diagnostic ignored "-Wthread-safety-analysis"
|
|
|
|
- (void)lockForConfiguration {
|
|
_crit.Enter();
|
|
rtc::AtomicOps::Increment(&_lockRecursionCount);
|
|
}
|
|
|
|
- (void)unlockForConfiguration {
|
|
// Don't let threads other than the one that called lockForConfiguration
|
|
// unlock.
|
|
if (_crit.TryEnter()) {
|
|
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 clang diagnostic pop
|
|
|
|
#pragma mark - AVAudioSession proxy methods
|
|
|
|
- (NSString *)category {
|
|
return self.session.category;
|
|
}
|
|
|
|
- (AVAudioSessionCategoryOptions)categoryOptions {
|
|
return self.session.categoryOptions;
|
|
}
|
|
|
|
- (NSString *)mode {
|
|
return self.session.mode;
|
|
}
|
|
|
|
- (BOOL)secondaryAudioShouldBeSilencedHint {
|
|
return self.session.secondaryAudioShouldBeSilencedHint;
|
|
}
|
|
|
|
- (AVAudioSessionRouteDescription *)currentRoute {
|
|
return self.session.currentRoute;
|
|
}
|
|
|
|
- (NSInteger)maximumInputNumberOfChannels {
|
|
return self.session.maximumInputNumberOfChannels;
|
|
}
|
|
|
|
- (NSInteger)maximumOutputNumberOfChannels {
|
|
return self.session.maximumOutputNumberOfChannels;
|
|
}
|
|
|
|
- (float)inputGain {
|
|
return self.session.inputGain;
|
|
}
|
|
|
|
- (BOOL)inputGainSettable {
|
|
return self.session.inputGainSettable;
|
|
}
|
|
|
|
- (BOOL)inputAvailable {
|
|
return self.session.inputAvailable;
|
|
}
|
|
|
|
- (NSArray<AVAudioSessionDataSourceDescription *> *)inputDataSources {
|
|
return self.session.inputDataSources;
|
|
}
|
|
|
|
- (AVAudioSessionDataSourceDescription *)inputDataSource {
|
|
return self.session.inputDataSource;
|
|
}
|
|
|
|
- (NSArray<AVAudioSessionDataSourceDescription *> *)outputDataSources {
|
|
return self.session.outputDataSources;
|
|
}
|
|
|
|
- (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.");
|
|
}
|
|
[self notifyWillSetActive:active];
|
|
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.
|
|
// Attempt to deactivate if we're active and it's the last unbalanced call.
|
|
if (shouldSetActive) {
|
|
AVAudioSession *session = self.session;
|
|
// 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.
|
|
AVAudioSessionSetActiveOptions options =
|
|
active ? 0 : AVAudioSessionSetActiveOptionNotifyOthersOnDeactivation;
|
|
success = [session setActive:active
|
|
withOptions:options
|
|
error:&error];
|
|
if (outError) {
|
|
*outError = error;
|
|
}
|
|
}
|
|
if (success) {
|
|
if (shouldSetActive) {
|
|
self.isActive = active;
|
|
if (active && self.isInterrupted) {
|
|
self.isInterrupted = NO;
|
|
[self notifyDidEndInterruptionWithShouldResumeSession:YES];
|
|
}
|
|
}
|
|
if (active) {
|
|
[self incrementActivationCount];
|
|
}
|
|
[self notifyDidSetActive:active];
|
|
} else {
|
|
RTCLogError(@"Failed to setActive:%d. Error: %@",
|
|
active, error.localizedDescription);
|
|
[self notifyFailedToSetActive:active error:error];
|
|
}
|
|
// Decrement activation count on deactivation whether or not it succeeded.
|
|
if (!active) {
|
|
[self decrementActivationCount];
|
|
}
|
|
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];
|
|
}
|
|
|
|
- (BOOL)setMode:(NSString *)mode error:(NSError **)outError {
|
|
if (![self checkLock:outError]) {
|
|
return NO;
|
|
}
|
|
return [self.session setMode:mode error:outError];
|
|
}
|
|
|
|
- (BOOL)setInputGain:(float)gain error:(NSError **)outError {
|
|
if (![self checkLock:outError]) {
|
|
return NO;
|
|
}
|
|
return [self.session setInputGain:gain error:outError];
|
|
}
|
|
|
|
- (BOOL)setPreferredSampleRate:(double)sampleRate error:(NSError **)outError {
|
|
if (![self checkLock:outError]) {
|
|
return NO;
|
|
}
|
|
return [self.session setPreferredSampleRate:sampleRate error:outError];
|
|
}
|
|
|
|
- (BOOL)setPreferredIOBufferDuration:(NSTimeInterval)duration
|
|
error:(NSError **)outError {
|
|
if (![self checkLock:outError]) {
|
|
return NO;
|
|
}
|
|
return [self.session setPreferredIOBufferDuration:duration error:outError];
|
|
}
|
|
|
|
- (BOOL)setPreferredInputNumberOfChannels:(NSInteger)count
|
|
error:(NSError **)outError {
|
|
if (![self checkLock:outError]) {
|
|
return NO;
|
|
}
|
|
return [self.session setPreferredInputNumberOfChannels:count error:outError];
|
|
}
|
|
- (BOOL)setPreferredOutputNumberOfChannels:(NSInteger)count
|
|
error:(NSError **)outError {
|
|
if (![self checkLock:outError]) {
|
|
return NO;
|
|
}
|
|
return [self.session setPreferredOutputNumberOfChannels:count error:outError];
|
|
}
|
|
|
|
- (BOOL)overrideOutputAudioPort:(AVAudioSessionPortOverride)portOverride
|
|
error:(NSError **)outError {
|
|
if (![self checkLock:outError]) {
|
|
return NO;
|
|
}
|
|
return [self.session overrideOutputAudioPort:portOverride error:outError];
|
|
}
|
|
|
|
- (BOOL)setPreferredInput:(AVAudioSessionPortDescription *)inPort
|
|
error:(NSError **)outError {
|
|
if (![self checkLock:outError]) {
|
|
return NO;
|
|
}
|
|
return [self.session setPreferredInput:inPort error:outError];
|
|
}
|
|
|
|
- (BOOL)setInputDataSource:(AVAudioSessionDataSourceDescription *)dataSource
|
|
error:(NSError **)outError {
|
|
if (![self checkLock:outError]) {
|
|
return NO;
|
|
}
|
|
return [self.session setInputDataSource:dataSource error:outError];
|
|
}
|
|
|
|
- (BOOL)setOutputDataSource:(AVAudioSessionDataSourceDescription *)dataSource
|
|
error:(NSError **)outError {
|
|
if (![self checkLock:outError]) {
|
|
return NO;
|
|
}
|
|
return [self.session setOutputDataSource:dataSource error:outError];
|
|
}
|
|
|
|
#pragma mark - Notifications
|
|
|
|
- (void)handleInterruptionNotification:(NSNotification *)notification {
|
|
NSNumber* typeNumber =
|
|
notification.userInfo[AVAudioSessionInterruptionTypeKey];
|
|
AVAudioSessionInterruptionType type =
|
|
(AVAudioSessionInterruptionType)typeNumber.unsignedIntegerValue;
|
|
switch (type) {
|
|
case AVAudioSessionInterruptionTypeBegan:
|
|
RTCLog(@"Audio session interruption began.");
|
|
self.isActive = NO;
|
|
self.isInterrupted = YES;
|
|
[self notifyDidBeginInterruption];
|
|
break;
|
|
case AVAudioSessionInterruptionTypeEnded: {
|
|
RTCLog(@"Audio session interruption ended.");
|
|
self.isInterrupted = NO;
|
|
[self updateAudioSessionAfterEvent];
|
|
NSNumber *optionsNumber =
|
|
notification.userInfo[AVAudioSessionInterruptionOptionKey];
|
|
AVAudioSessionInterruptionOptions options =
|
|
optionsNumber.unsignedIntegerValue;
|
|
BOOL shouldResume =
|
|
options & AVAudioSessionInterruptionOptionShouldResume;
|
|
[self notifyDidEndInterruptionWithShouldResumeSession:shouldResume];
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
- (void)handleRouteChangeNotification:(NSNotification *)notification {
|
|
// Get reason for current route change.
|
|
NSNumber* reasonNumber =
|
|
notification.userInfo[AVAudioSessionRouteChangeReasonKey];
|
|
AVAudioSessionRouteChangeReason reason =
|
|
(AVAudioSessionRouteChangeReason)reasonNumber.unsignedIntegerValue;
|
|
RTCLog(@"Audio route changed:");
|
|
switch (reason) {
|
|
case AVAudioSessionRouteChangeReasonUnknown:
|
|
RTCLog(@"Audio route changed: ReasonUnknown");
|
|
break;
|
|
case AVAudioSessionRouteChangeReasonNewDeviceAvailable:
|
|
RTCLog(@"Audio route changed: NewDeviceAvailable");
|
|
break;
|
|
case AVAudioSessionRouteChangeReasonOldDeviceUnavailable:
|
|
RTCLog(@"Audio route changed: OldDeviceUnavailable");
|
|
break;
|
|
case AVAudioSessionRouteChangeReasonCategoryChange:
|
|
RTCLog(@"Audio route changed: CategoryChange to :%@",
|
|
self.session.category);
|
|
break;
|
|
case AVAudioSessionRouteChangeReasonOverride:
|
|
RTCLog(@"Audio route changed: Override");
|
|
break;
|
|
case AVAudioSessionRouteChangeReasonWakeFromSleep:
|
|
RTCLog(@"Audio route changed: WakeFromSleep");
|
|
break;
|
|
case AVAudioSessionRouteChangeReasonNoSuitableRouteForCategory:
|
|
RTCLog(@"Audio route changed: NoSuitableRouteForCategory");
|
|
break;
|
|
case AVAudioSessionRouteChangeReasonRouteConfigurationChange:
|
|
RTCLog(@"Audio route changed: RouteConfigurationChange");
|
|
break;
|
|
}
|
|
AVAudioSessionRouteDescription* previousRoute =
|
|
notification.userInfo[AVAudioSessionRouteChangePreviousRouteKey];
|
|
// Log previous route configuration.
|
|
RTCLog(@"Previous route: %@\nCurrent route:%@",
|
|
previousRoute, self.session.currentRoute);
|
|
[self notifyDidChangeRouteWithReason:reason previousRoute:previousRoute];
|
|
}
|
|
|
|
- (void)handleMediaServicesWereLost:(NSNotification *)notification {
|
|
RTCLog(@"Media services were lost.");
|
|
[self updateAudioSessionAfterEvent];
|
|
[self notifyMediaServicesWereLost];
|
|
}
|
|
|
|
- (void)handleMediaServicesWereReset:(NSNotification *)notification {
|
|
RTCLog(@"Media services were reset.");
|
|
[self updateAudioSessionAfterEvent];
|
|
[self notifyMediaServicesWereReset];
|
|
}
|
|
|
|
- (void)handleSilenceSecondaryAudioHintNotification:(NSNotification *)notification {
|
|
// TODO(henrika): just adding logs here for now until we know if we are ever
|
|
// see this notification and might be affected by it or if further actions
|
|
// are required.
|
|
NSNumber *typeNumber =
|
|
notification.userInfo[AVAudioSessionSilenceSecondaryAudioHintTypeKey];
|
|
AVAudioSessionSilenceSecondaryAudioHintType type =
|
|
(AVAudioSessionSilenceSecondaryAudioHintType)typeNumber.unsignedIntegerValue;
|
|
switch (type) {
|
|
case AVAudioSessionSilenceSecondaryAudioHintTypeBegin:
|
|
RTCLog(@"Another application's primary audio has started.");
|
|
break;
|
|
case AVAudioSessionSilenceSecondaryAudioHintTypeEnd:
|
|
RTCLog(@"Another application's primary audio has stopped.");
|
|
break;
|
|
}
|
|
}
|
|
|
|
- (void)handleApplicationDidBecomeActive:(NSNotification *)notification {
|
|
BOOL isInterrupted = self.isInterrupted;
|
|
RTCLog(@"Application became active after an interruption. Treating as interruption "
|
|
"end. isInterrupted changed from %d to 0.",
|
|
isInterrupted);
|
|
if (isInterrupted) {
|
|
self.isInterrupted = NO;
|
|
[self updateAudioSessionAfterEvent];
|
|
}
|
|
// Always treat application becoming active as an interruption end event.
|
|
[self notifyDidEndInterruptionWithShouldResumeSession:YES];
|
|
}
|
|
|
|
#pragma mark - Private
|
|
|
|
+ (NSError *)lockError {
|
|
NSDictionary *userInfo = @{
|
|
NSLocalizedDescriptionKey:
|
|
@"Must call lockForConfiguration before calling this method."
|
|
};
|
|
NSError *error =
|
|
[[NSError alloc] initWithDomain:kRTCAudioSessionErrorDomain
|
|
code:kRTCAudioSessionErrorLockRequired
|
|
userInfo:userInfo];
|
|
return error;
|
|
}
|
|
|
|
- (std::vector<__weak id<RTC_OBJC_TYPE(RTCAudioSessionDelegate)> >)delegates {
|
|
@synchronized(self) {
|
|
// Note: this returns a copy.
|
|
return _delegates;
|
|
}
|
|
}
|
|
|
|
// TODO(tkchin): check for duplicates.
|
|
- (void)pushDelegate:(id<RTC_OBJC_TYPE(RTCAudioSessionDelegate)>)delegate {
|
|
@synchronized(self) {
|
|
_delegates.insert(_delegates.begin(), delegate);
|
|
}
|
|
}
|
|
|
|
- (void)removeZeroedDelegates {
|
|
@synchronized(self) {
|
|
_delegates.erase(
|
|
std::remove_if(_delegates.begin(),
|
|
_delegates.end(),
|
|
[](id delegate) -> bool { return delegate == nil; }),
|
|
_delegates.end());
|
|
}
|
|
}
|
|
|
|
- (int)activationCount {
|
|
return _activationCount;
|
|
}
|
|
|
|
- (int)incrementActivationCount {
|
|
RTCLog(@"Incrementing activation count.");
|
|
return rtc::AtomicOps::Increment(&_activationCount);
|
|
}
|
|
|
|
- (NSInteger)decrementActivationCount {
|
|
RTCLog(@"Decrementing activation count.");
|
|
return rtc::AtomicOps::Decrement(&_activationCount);
|
|
}
|
|
|
|
- (int)webRTCSessionCount {
|
|
return _webRTCSessionCount;
|
|
}
|
|
|
|
- (BOOL)canPlayOrRecord {
|
|
return !self.useManualAudio || self.isAudioEnabled;
|
|
}
|
|
|
|
- (BOOL)isInterrupted {
|
|
@synchronized(self) {
|
|
return _isInterrupted;
|
|
}
|
|
}
|
|
|
|
- (void)setIsInterrupted:(BOOL)isInterrupted {
|
|
@synchronized(self) {
|
|
if (_isInterrupted == isInterrupted) {
|
|
return;
|
|
}
|
|
_isInterrupted = isInterrupted;
|
|
}
|
|
}
|
|
|
|
- (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 = [RTC_OBJC_TYPE(RTCAudioSession) lockError];
|
|
}
|
|
return NO;
|
|
}
|
|
return YES;
|
|
}
|
|
|
|
- (BOOL)beginWebRTCSession:(NSError **)outError {
|
|
if (outError) {
|
|
*outError = nil;
|
|
}
|
|
if (![self checkLock:outError]) {
|
|
return NO;
|
|
}
|
|
rtc::AtomicOps::Increment(&_webRTCSessionCount);
|
|
[self notifyDidStartPlayOrRecord];
|
|
return YES;
|
|
}
|
|
|
|
- (BOOL)endWebRTCSession:(NSError **)outError {
|
|
if (outError) {
|
|
*outError = nil;
|
|
}
|
|
if (![self checkLock:outError]) {
|
|
return NO;
|
|
}
|
|
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.");
|
|
|
|
// Configure the AVAudioSession and activate it.
|
|
// Provide an error even if there isn't one so we can log it.
|
|
NSError *error = nil;
|
|
RTC_OBJC_TYPE(RTCAudioSessionConfiguration) *webRTCConfig =
|
|
[RTC_OBJC_TYPE(RTCAudioSessionConfiguration) webRTCConfiguration];
|
|
if (![self setConfiguration:webRTCConfig active:YES error:&error]) {
|
|
RTCLogError(@"Failed to set WebRTC audio configuration: %@",
|
|
error.localizedDescription);
|
|
// Do not call setActive:NO if setActive:YES failed.
|
|
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;
|
|
}
|
|
|
|
// It can happen (e.g. in combination with BT devices) that the attempt to set
|
|
// the preferred sample rate for WebRTC (48kHz) fails. If so, make a new
|
|
// configuration attempt using the sample rate that worked using the active
|
|
// audio session. A typical case is that only 8 or 16kHz can be set, e.g. in
|
|
// combination with BT headsets. Using this "trick" seems to avoid a state
|
|
// where Core Audio asks for a different number of audio frames than what the
|
|
// session's I/O buffer duration corresponds to.
|
|
// TODO(henrika): this fix resolves bugs.webrtc.org/6004 but it has only been
|
|
// tested on a limited set of iOS devices and BT devices.
|
|
double sessionSampleRate = self.sampleRate;
|
|
double preferredSampleRate = webRTCConfig.sampleRate;
|
|
if (sessionSampleRate != preferredSampleRate) {
|
|
RTCLogWarning(
|
|
@"Current sample rate (%.2f) is not the preferred rate (%.2f)",
|
|
sessionSampleRate, preferredSampleRate);
|
|
if (![self setPreferredSampleRate:sessionSampleRate
|
|
error:&error]) {
|
|
RTCLogError(@"Failed to set preferred sample rate: %@",
|
|
error.localizedDescription);
|
|
if (outError) {
|
|
*outError = error;
|
|
}
|
|
}
|
|
}
|
|
|
|
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)audioSessionDidActivate:(AVAudioSession *)session {
|
|
if (_session != session) {
|
|
RTCLogError(@"audioSessionDidActivate called on different AVAudioSession");
|
|
}
|
|
RTCLog(@"Audio session was externally activated.");
|
|
[self incrementActivationCount];
|
|
self.isActive = YES;
|
|
// When a CallKit call begins, it's possible that we receive an interruption
|
|
// begin without a corresponding end. Since we know that we have an activated
|
|
// audio session at this point, just clear any saved interruption flag since
|
|
// the app may never be foregrounded during the duration of the call.
|
|
if (self.isInterrupted) {
|
|
RTCLog(@"Clearing interrupted state due to external activation.");
|
|
self.isInterrupted = NO;
|
|
}
|
|
// Treat external audio session activation as an end interruption event.
|
|
[self notifyDidEndInterruptionWithShouldResumeSession:YES];
|
|
}
|
|
|
|
- (void)audioSessionDidDeactivate:(AVAudioSession *)session {
|
|
if (_session != session) {
|
|
RTCLogError(@"audioSessionDidDeactivate called on different AVAudioSession");
|
|
}
|
|
RTCLog(@"Audio session was externally deactivated.");
|
|
self.isActive = NO;
|
|
[self decrementActivationCount];
|
|
}
|
|
|
|
- (void)observeValueForKeyPath:(NSString *)keyPath
|
|
ofObject:(id)object
|
|
change:(NSDictionary *)change
|
|
context:(void *)context {
|
|
if (context == (__bridge void *)RTC_OBJC_TYPE(RTCAudioSession).class) {
|
|
if (object == _session) {
|
|
NSNumber *newVolume = change[NSKeyValueChangeNewKey];
|
|
RTCLog(@"OutputVolumeDidChange to %f", newVolume.floatValue);
|
|
[self notifyDidChangeOutputVolume:newVolume.floatValue];
|
|
}
|
|
} else {
|
|
[super observeValueForKeyPath:keyPath
|
|
ofObject:object
|
|
change:change
|
|
context:context];
|
|
}
|
|
}
|
|
|
|
- (void)notifyDidBeginInterruption {
|
|
for (auto delegate : self.delegates) {
|
|
SEL sel = @selector(audioSessionDidBeginInterruption:);
|
|
if ([delegate respondsToSelector:sel]) {
|
|
[delegate audioSessionDidBeginInterruption:self];
|
|
}
|
|
}
|
|
}
|
|
|
|
- (void)notifyDidEndInterruptionWithShouldResumeSession:
|
|
(BOOL)shouldResumeSession {
|
|
for (auto delegate : self.delegates) {
|
|
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) {
|
|
SEL sel = @selector(audioSessionDidChangeRoute:reason:previousRoute:);
|
|
if ([delegate respondsToSelector:sel]) {
|
|
[delegate audioSessionDidChangeRoute:self
|
|
reason:reason
|
|
previousRoute:previousRoute];
|
|
}
|
|
}
|
|
}
|
|
|
|
- (void)notifyMediaServicesWereLost {
|
|
for (auto delegate : self.delegates) {
|
|
SEL sel = @selector(audioSessionMediaServerTerminated:);
|
|
if ([delegate respondsToSelector:sel]) {
|
|
[delegate audioSessionMediaServerTerminated:self];
|
|
}
|
|
}
|
|
}
|
|
|
|
- (void)notifyMediaServicesWereReset {
|
|
for (auto delegate : self.delegates) {
|
|
SEL sel = @selector(audioSessionMediaServerReset:);
|
|
if ([delegate respondsToSelector:sel]) {
|
|
[delegate audioSessionMediaServerReset:self];
|
|
}
|
|
}
|
|
}
|
|
|
|
- (void)notifyDidChangeCanPlayOrRecord:(BOOL)canPlayOrRecord {
|
|
for (auto delegate : self.delegates) {
|
|
SEL sel = @selector(audioSession:didChangeCanPlayOrRecord:);
|
|
if ([delegate respondsToSelector:sel]) {
|
|
[delegate audioSession:self didChangeCanPlayOrRecord:canPlayOrRecord];
|
|
}
|
|
}
|
|
}
|
|
|
|
- (void)notifyDidStartPlayOrRecord {
|
|
for (auto delegate : self.delegates) {
|
|
SEL sel = @selector(audioSessionDidStartPlayOrRecord:);
|
|
if ([delegate respondsToSelector:sel]) {
|
|
[delegate audioSessionDidStartPlayOrRecord:self];
|
|
}
|
|
}
|
|
}
|
|
|
|
- (void)notifyDidStopPlayOrRecord {
|
|
for (auto delegate : self.delegates) {
|
|
SEL sel = @selector(audioSessionDidStopPlayOrRecord:);
|
|
if ([delegate respondsToSelector:sel]) {
|
|
[delegate audioSessionDidStopPlayOrRecord:self];
|
|
}
|
|
}
|
|
}
|
|
|
|
- (void)notifyDidChangeOutputVolume:(float)volume {
|
|
for (auto delegate : self.delegates) {
|
|
SEL sel = @selector(audioSession:didChangeOutputVolume:);
|
|
if ([delegate respondsToSelector:sel]) {
|
|
[delegate audioSession:self didChangeOutputVolume:volume];
|
|
}
|
|
}
|
|
}
|
|
|
|
- (void)notifyDidDetectPlayoutGlitch:(int64_t)totalNumberOfGlitches {
|
|
for (auto delegate : self.delegates) {
|
|
SEL sel = @selector(audioSession:didDetectPlayoutGlitch:);
|
|
if ([delegate respondsToSelector:sel]) {
|
|
[delegate audioSession:self didDetectPlayoutGlitch:totalNumberOfGlitches];
|
|
}
|
|
}
|
|
}
|
|
|
|
- (void)notifyWillSetActive:(BOOL)active {
|
|
for (id delegate : self.delegates) {
|
|
SEL sel = @selector(audioSession:willSetActive:);
|
|
if ([delegate respondsToSelector:sel]) {
|
|
[delegate audioSession:self willSetActive:active];
|
|
}
|
|
}
|
|
}
|
|
|
|
- (void)notifyDidSetActive:(BOOL)active {
|
|
for (id delegate : self.delegates) {
|
|
SEL sel = @selector(audioSession:didSetActive:);
|
|
if ([delegate respondsToSelector:sel]) {
|
|
[delegate audioSession:self didSetActive:active];
|
|
}
|
|
}
|
|
}
|
|
|
|
- (void)notifyFailedToSetActive:(BOOL)active error:(NSError *)error {
|
|
for (id delegate : self.delegates) {
|
|
SEL sel = @selector(audioSession:failedToSetActive:error:);
|
|
if ([delegate respondsToSelector:sel]) {
|
|
[delegate audioSession:self failedToSetActive:active error:error];
|
|
}
|
|
}
|
|
}
|
|
|
|
@end
|