/* * Copyright (C) 2014 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package com.android.server.telecom; import android.app.ActivityManagerNative; import android.content.Context; import android.content.pm.UserInfo; import android.media.AudioManager; import android.media.IAudioService; import android.os.Binder; import android.os.Handler; import android.os.IBinder; import android.os.Looper; import android.os.Message; import android.os.RemoteException; import android.os.ServiceManager; import android.os.UserHandle; import android.telecom.CallAudioState; import com.android.internal.util.IndentingPrintWriter; import com.android.internal.util.Preconditions; import java.util.Objects; /** * This class manages audio modes, streams and other properties. */ final class CallAudioManager extends CallsManagerListenerBase implements WiredHeadsetManager.Listener, DockManager.Listener { private static final int STREAM_NONE = -1; private static final String STREAM_DESCRIPTION_NONE = "STEAM_NONE"; private static final String STREAM_DESCRIPTION_ALARM = "STEAM_ALARM"; private static final String STREAM_DESCRIPTION_BLUETOOTH_SCO = "STREAM_BLUETOOTH_SCO"; private static final String STREAM_DESCRIPTION_DTMF = "STREAM_DTMF"; private static final String STREAM_DESCRIPTION_MUSIC = "STREAM_MUSIC"; private static final String STREAM_DESCRIPTION_NOTIFICATION = "STREAM_NOTIFICATION"; private static final String STREAM_DESCRIPTION_RING = "STREAM_RING"; private static final String STREAM_DESCRIPTION_SYSTEM = "STREAM_SYSTEM"; private static final String STREAM_DESCRIPTION_VOICE_CALL = "STREAM_VOICE_CALL"; private static final String MODE_DESCRIPTION_INVALID = "MODE_INVALID"; private static final String MODE_DESCRIPTION_CURRENT = "MODE_CURRENT"; private static final String MODE_DESCRIPTION_NORMAL = "MODE_NORMAL"; private static final String MODE_DESCRIPTION_RINGTONE = "MODE_RINGTONE"; private static final String MODE_DESCRIPTION_IN_CALL = "MODE_IN_CALL"; private static final String MODE_DESCRIPTION_IN_COMMUNICATION = "MODE_IN_COMMUNICATION"; private static final int MSG_AUDIO_MANAGER_INITIALIZE = 0; private static final int MSG_AUDIO_MANAGER_TURN_ON_SPEAKER = 1; private static final int MSG_AUDIO_MANAGER_ABANDON_AUDIO_FOCUS_FOR_CALL = 2; private static final int MSG_AUDIO_MANAGER_SET_MICROPHONE_MUTE = 3; private static final int MSG_AUDIO_MANAGER_REQUEST_AUDIO_FOCUS_FOR_CALL = 4; private static final int MSG_AUDIO_MANAGER_SET_MODE = 5; private final Handler mAudioManagerHandler = new Handler(Looper.getMainLooper()) { private AudioManager mAudioManager; @Override public void handleMessage(Message msg) { switch (msg.what) { case MSG_AUDIO_MANAGER_INITIALIZE: { mAudioManager = (AudioManager) mContext.getSystemService(Context.AUDIO_SERVICE); break; } case MSG_AUDIO_MANAGER_TURN_ON_SPEAKER: { boolean on = (msg.arg1 != 0); // Wired headset and earpiece work the same way if (mAudioManager.isSpeakerphoneOn() != on) { Log.i(this, "turning speaker phone %s", on); mAudioManager.setSpeakerphoneOn(on); } break; } case MSG_AUDIO_MANAGER_ABANDON_AUDIO_FOCUS_FOR_CALL: { mAudioManager.abandonAudioFocusForCall(); break; } case MSG_AUDIO_MANAGER_SET_MICROPHONE_MUTE: { boolean mute = (msg.arg1 != 0); if (mute != mAudioManager.isMicrophoneMute()) { IAudioService audio = getAudioService(); Log.i(this, "changing microphone mute state to: %b [serviceIsNull=%b]", mute, audio == null); if (audio != null) { try { // We use the audio service directly here so that we can specify // the current user. Telecom runs in the system_server process which // may run as a separate user from the foreground user. If we // used AudioManager directly, we would change mute for the system's // user and not the current foreground, which we want to avoid. audio.setMicrophoneMute( mute, mContext.getOpPackageName(), getCurrentUserId()); } catch (RemoteException e) { Log.e(this, e, "Remote exception while toggling mute."); } // TODO: Check microphone state after attempting to set to ensure that // our state corroborates AudioManager's state. } } break; } case MSG_AUDIO_MANAGER_REQUEST_AUDIO_FOCUS_FOR_CALL: { int stream = msg.arg1; mAudioManager.requestAudioFocusForCall( stream, AudioManager.AUDIOFOCUS_GAIN_TRANSIENT); break; } case MSG_AUDIO_MANAGER_SET_MODE: { int newMode = msg.arg1; int oldMode = mAudioManager.getMode(); Log.v(this, "Request to change audio mode from %s to %s", modeToString(oldMode), modeToString(newMode)); if (oldMode != newMode) { if (oldMode == AudioManager.MODE_IN_CALL && newMode == AudioManager.MODE_RINGTONE) { Log.i(this, "Transition from IN_CALL -> RINGTONE." + " Resetting to NORMAL first."); mAudioManager.setMode(AudioManager.MODE_NORMAL); } mAudioManager.setMode(newMode); synchronized (mLock) { mMostRecentlyUsedMode = newMode; } } break; } default: break; } } }; private final Context mContext; private final TelecomSystem.SyncRoot mLock; private final StatusBarNotifier mStatusBarNotifier; private final BluetoothManager mBluetoothManager; private final WiredHeadsetManager mWiredHeadsetManager; private final DockManager mDockManager; private final CallsManager mCallsManager; private CallAudioState mCallAudioState; private int mAudioFocusStreamType; private boolean mIsRinging; private boolean mIsTonePlaying; private boolean mWasSpeakerOn; private int mMostRecentlyUsedMode = AudioManager.MODE_IN_CALL; private Call mCallToSpeedUpMTAudio = null; CallAudioManager( Context context, TelecomSystem.SyncRoot lock, StatusBarNotifier statusBarNotifier, WiredHeadsetManager wiredHeadsetManager, DockManager dockManager, CallsManager callsManager) { mContext = context; mLock = lock; mAudioManagerHandler.obtainMessage(MSG_AUDIO_MANAGER_INITIALIZE, 0, 0).sendToTarget(); mStatusBarNotifier = statusBarNotifier; mBluetoothManager = new BluetoothManager(context, this); mWiredHeadsetManager = wiredHeadsetManager; mCallsManager = callsManager; mWiredHeadsetManager.addListener(this); mDockManager = dockManager; mDockManager.addListener(this); saveAudioState(getInitialAudioState(null)); mAudioFocusStreamType = STREAM_NONE; } CallAudioState getCallAudioState() { return mCallAudioState; } @Override public void onCallAdded(Call call) { Log.v(this, "onCallAdded"); onCallUpdated(call); if (hasFocus() && getForegroundCall() == call) { if (!call.isIncoming()) { // Unmute new outgoing call. setSystemAudioState(false, mCallAudioState.getRoute(), mCallAudioState.getSupportedRouteMask()); } } } @Override public void onCallRemoved(Call call) { Log.v(this, "onCallRemoved"); // If we didn't already have focus, there's nothing to do. if (hasFocus()) { if (mCallsManager.getCalls().isEmpty()) { Log.v(this, "all calls removed, resetting system audio to default state"); setInitialAudioState(null, false /* force */); mWasSpeakerOn = false; } updateAudioStreamAndMode(call); } } @Override public void onCallStateChanged(Call call, int oldState, int newState) { Log.v(this, "onCallStateChanged : oldState = %d, newState = %d", oldState, newState); onCallUpdated(call); } @Override public void onIncomingCallAnswered(Call call) { Log.v(this, "onIncomingCallAnswered"); int route = mCallAudioState.getRoute(); // We do two things: // (1) If this is the first call, then we can to turn on bluetooth if available. // (2) Unmute the audio for the new incoming call. boolean isOnlyCall = mCallsManager.getCalls().size() == 1; if (isOnlyCall && mBluetoothManager.isBluetoothAvailable()) { mBluetoothManager.connectBluetoothAudio(); route = CallAudioState.ROUTE_BLUETOOTH; } setSystemAudioState(false /* isMute */, route, mCallAudioState.getSupportedRouteMask()); if (call.can(android.telecom.Call.Details.CAPABILITY_SPEED_UP_MT_AUDIO)) { Log.v(this, "Speed up audio setup for IMS MT call."); mCallToSpeedUpMTAudio = call; updateAudioStreamAndMode(call); } } @Override public void onForegroundCallChanged(Call oldForegroundCall, Call newForegroundCall) { onCallUpdated(newForegroundCall); // Ensure that the foreground call knows about the latest audio state. updateAudioForForegroundCall(); } @Override public void onIsVoipAudioModeChanged(Call call) { updateAudioStreamAndMode(call); } /** * Updates the audio route when the headset plugged in state changes. For example, if audio is * being routed over speakerphone and a headset is plugged in then switch to wired headset. */ @Override public void onWiredHeadsetPluggedInChanged(boolean oldIsPluggedIn, boolean newIsPluggedIn) { // This can happen even when there are no calls and we don't have focus. if (!hasFocus()) { return; } boolean isCurrentlyWiredHeadset = mCallAudioState.getRoute() == CallAudioState.ROUTE_WIRED_HEADSET; int newRoute = mCallAudioState.getRoute(); // start out with existing route if (newIsPluggedIn) { newRoute = CallAudioState.ROUTE_WIRED_HEADSET; } else if (isCurrentlyWiredHeadset) { Call call = getForegroundCall(); boolean hasLiveCall = call != null && call.isAlive(); if (hasLiveCall) { // In order of preference when a wireless headset is unplugged. if (mWasSpeakerOn) { newRoute = CallAudioState.ROUTE_SPEAKER; } else { newRoute = CallAudioState.ROUTE_EARPIECE; } // We don't automatically connect to bluetooth when user unplugs their wired headset // and they were previously using the wired. Wired and earpiece are effectively the // same choice in that they replace each other as an option when wired headsets // are plugged in and out. This means that keeping it earpiece is a bit more // consistent with the status quo. Bluetooth also has more danger associated with // choosing it in the wrong curcumstance because bluetooth devices can be // semi-public (like in a very-occupied car) where earpiece doesn't carry that risk. } } // We need to call this every time even if we do not change the route because the supported // routes changed either to include or not include WIRED_HEADSET. setSystemAudioState(mCallAudioState.isMuted(), newRoute, calculateSupportedRoutes()); } @Override public void onDockChanged(boolean isDocked) { // This can happen even when there are no calls and we don't have focus. if (!hasFocus()) { return; } if (isDocked) { // Device just docked, turn to speakerphone. Only do so if the route is currently // earpiece so that we dont switch out of a BT headset or a wired headset. if (mCallAudioState.getRoute() == CallAudioState.ROUTE_EARPIECE) { setAudioRoute(CallAudioState.ROUTE_SPEAKER); } } else { // Device just undocked, remove from speakerphone if possible. if (mCallAudioState.getRoute() == CallAudioState.ROUTE_SPEAKER) { setAudioRoute(CallAudioState.ROUTE_WIRED_OR_EARPIECE); } } } void toggleMute() { mute(!mCallAudioState.isMuted()); } void mute(boolean shouldMute) { if (!hasFocus()) { return; } Log.v(this, "mute, shouldMute: %b", shouldMute); // Don't mute if there are any emergency calls. if (mCallsManager.hasEmergencyCall()) { shouldMute = false; Log.v(this, "ignoring mute for emergency call"); } if (mCallAudioState.isMuted() != shouldMute) { // We user CallsManager's foreground call so that we dont ignore ringing calls // for logging purposes Log.event(mCallsManager.getForegroundCall(), Log.Events.MUTE, shouldMute ? "on" : "off"); setSystemAudioState(shouldMute, mCallAudioState.getRoute(), mCallAudioState.getSupportedRouteMask()); } } /** * Changed the audio route, for example from earpiece to speaker phone. * * @param route The new audio route to use. See {@link CallAudioState}. */ void setAudioRoute(int route) { // This can happen even when there are no calls and we don't have focus. if (!hasFocus()) { return; } Log.v(this, "setAudioRoute, route: %s", CallAudioState.audioRouteToString(route)); // Change ROUTE_WIRED_OR_EARPIECE to a single entry. int newRoute = selectWiredOrEarpiece(route, mCallAudioState.getSupportedRouteMask()); // If route is unsupported, do nothing. if ((mCallAudioState.getSupportedRouteMask() | newRoute) == 0) { Log.wtf(this, "Asking to set to a route that is unsupported: %d", newRoute); return; } if (mCallAudioState.getRoute() != newRoute) { // Remember the new speaker state so it can be restored when the user plugs and unplugs // a headset. mWasSpeakerOn = newRoute == CallAudioState.ROUTE_SPEAKER; setSystemAudioState(mCallAudioState.isMuted(), newRoute, mCallAudioState.getSupportedRouteMask()); } } /** * Sets the audio stream and mode based on whether a call is ringing. * * @param call The call which changed ringing state. * @param isRinging {@code true} if the call is ringing, {@code false} otherwise. */ void setIsRinging(Call call, boolean isRinging) { if (mIsRinging != isRinging) { Log.i(this, "setIsRinging %b -> %b (call = %s)", mIsRinging, isRinging, call); mIsRinging = isRinging; updateAudioStreamAndMode(call); } } /** * Sets the tone playing status. Some tones can play even when there are no live calls and this * status indicates that we should keep audio focus even for tones that play beyond the life of * calls. * * @param isPlayingNew The status to set. */ void setIsTonePlaying(boolean isPlayingNew) { if (mIsTonePlaying != isPlayingNew) { Log.v(this, "mIsTonePlaying %b -> %b.", mIsTonePlaying, isPlayingNew); mIsTonePlaying = isPlayingNew; updateAudioStreamAndMode(); } } /** * Updates the audio routing according to the bluetooth state. */ void onBluetoothStateChange(BluetoothManager bluetoothManager) { // This can happen even when there are no calls and we don't have focus. if (!hasFocus()) { return; } int supportedRoutes = calculateSupportedRoutes(); int newRoute = mCallAudioState.getRoute(); if (bluetoothManager.isBluetoothAudioConnectedOrPending()) { newRoute = CallAudioState.ROUTE_BLUETOOTH; } else if (mCallAudioState.getRoute() == CallAudioState.ROUTE_BLUETOOTH) { newRoute = selectWiredOrEarpiece(CallAudioState.ROUTE_WIRED_OR_EARPIECE, supportedRoutes); // Do not switch to speaker when bluetooth disconnects. mWasSpeakerOn = false; } setSystemAudioState(mCallAudioState.isMuted(), newRoute, supportedRoutes); } boolean isBluetoothAudioOn() { return mBluetoothManager.isBluetoothAudioConnected(); } boolean isBluetoothDeviceAvailable() { return mBluetoothManager.isBluetoothAvailable(); } private void saveAudioState(CallAudioState callAudioState) { mCallAudioState = callAudioState; mStatusBarNotifier.notifyMute(mCallAudioState.isMuted()); mStatusBarNotifier.notifySpeakerphone(mCallAudioState.getRoute() == CallAudioState.ROUTE_SPEAKER); } private void onCallUpdated(Call call) { updateAudioStreamAndMode(call); if (call != null && call.getState() == CallState.ACTIVE && call == mCallToSpeedUpMTAudio) { mCallToSpeedUpMTAudio = null; } } private void setSystemAudioState(boolean isMuted, int route, int supportedRouteMask) { setSystemAudioState(false /* force */, isMuted, route, supportedRouteMask); } private void setSystemAudioState( boolean force, boolean isMuted, int route, int supportedRouteMask) { if (!hasFocus()) { return; } CallAudioState oldAudioState = mCallAudioState; saveAudioState(new CallAudioState(isMuted, route, supportedRouteMask)); if (!force && Objects.equals(oldAudioState, mCallAudioState)) { return; } Log.i(this, "setSystemAudioState: changing from %s to %s", oldAudioState, mCallAudioState); Log.event(mCallsManager.getForegroundCall(), Log.Events.AUDIO_ROUTE, CallAudioState.audioRouteToString(mCallAudioState.getRoute())); mAudioManagerHandler.obtainMessage( MSG_AUDIO_MANAGER_SET_MICROPHONE_MUTE, mCallAudioState.isMuted() ? 1 : 0, 0) .sendToTarget(); // Audio route. if (mCallAudioState.getRoute() == CallAudioState.ROUTE_BLUETOOTH) { turnOnSpeaker(false); turnOnBluetooth(true); } else if (mCallAudioState.getRoute() == CallAudioState.ROUTE_SPEAKER) { turnOnBluetooth(false); turnOnSpeaker(true); } else if (mCallAudioState.getRoute() == CallAudioState.ROUTE_EARPIECE || mCallAudioState.getRoute() == CallAudioState.ROUTE_WIRED_HEADSET) { turnOnBluetooth(false); turnOnSpeaker(false); } if (!oldAudioState.equals(mCallAudioState)) { mCallsManager.onCallAudioStateChanged(oldAudioState, mCallAudioState); updateAudioForForegroundCall(); } } private void turnOnSpeaker(boolean on) { mAudioManagerHandler.obtainMessage(MSG_AUDIO_MANAGER_TURN_ON_SPEAKER, on ? 1 : 0, 0) .sendToTarget(); } private void turnOnBluetooth(boolean on) { if (mBluetoothManager.isBluetoothAvailable()) { boolean isAlreadyOn = mBluetoothManager.isBluetoothAudioConnectedOrPending(); if (on != isAlreadyOn) { Log.i(this, "connecting bluetooth %s", on); if (on) { mBluetoothManager.connectBluetoothAudio(); } else { mBluetoothManager.disconnectBluetoothAudio(); } } } } private void updateAudioStreamAndMode() { updateAudioStreamAndMode(null /* call */); } private void updateAudioStreamAndMode(Call callToUpdate) { Log.i(this, "updateAudioStreamAndMode : mIsRinging: %b, mIsTonePlaying: %b, call: %s", mIsRinging, mIsTonePlaying, callToUpdate); boolean wasVoiceCall = mAudioFocusStreamType == AudioManager.STREAM_VOICE_CALL; if (mIsRinging) { Log.i(this, "updateAudioStreamAndMode : ringing"); requestAudioFocusAndSetMode(AudioManager.STREAM_RING, AudioManager.MODE_RINGTONE); } else { Call foregroundCall = getForegroundCall(); Call waitingForAccountSelectionCall = mCallsManager .getFirstCallWithState(CallState.SELECT_PHONE_ACCOUNT); Call call = mCallsManager.getForegroundCall(); if (foregroundCall == null && call != null && call == mCallToSpeedUpMTAudio) { Log.v(this, "updateAudioStreamAndMode : no foreground, speeding up MT audio."); requestAudioFocusAndSetMode(AudioManager.STREAM_VOICE_CALL, AudioManager.MODE_IN_CALL); } else if (foregroundCall != null && !foregroundCall.isDisconnected() && waitingForAccountSelectionCall == null) { // In the case where there is a call that is waiting for account selection, // this will fall back to abandonAudioFocus() below, which temporarily exits // the in-call audio mode. This is to allow TalkBack to speak the "Call with" // dialog information at media volume as opposed to through the earpiece. // Once exiting the "Call with" dialog, the audio focus will return to an in-call // audio mode when this method (updateAudioStreamAndMode) is called again. int mode = foregroundCall.getIsVoipAudioMode() ? AudioManager.MODE_IN_COMMUNICATION : AudioManager.MODE_IN_CALL; Log.v(this, "updateAudioStreamAndMode : foreground"); requestAudioFocusAndSetMode(AudioManager.STREAM_VOICE_CALL, mode); } else if (mIsTonePlaying) { // There is no call, however, we are still playing a tone, so keep focus. // Since there is no call from which to determine the mode, use the most // recently used mode instead. Log.v(this, "updateAudioStreamAndMode : tone playing"); requestAudioFocusAndSetMode( AudioManager.STREAM_VOICE_CALL, mMostRecentlyUsedMode); } else if (!hasRingingForegroundCall() && mCallsManager.hasOnlyDisconnectedCalls()) { Log.v(this, "updateAudioStreamAndMode : no ringing call"); abandonAudioFocus(); } else { // mIsRinging is false, but there is a foreground ringing call present. Don't // abandon audio focus immediately to prevent audio focus from getting lost between // the time it takes for the foreground call to transition from RINGING to ACTIVE/ // DISCONNECTED. When the call eventually transitions to the next state, audio // focus will be correctly abandoned by the if clause above. } } boolean isVoiceCall = mAudioFocusStreamType == AudioManager.STREAM_VOICE_CALL; // If we transition from not a voice call to a voice call, we need to set an initial audio // state for the call. if (!wasVoiceCall && isVoiceCall) { setInitialAudioState(callToUpdate, true /* force */); } } private void requestAudioFocusAndSetMode(int stream, int mode) { Log.v(this, "requestAudioFocusAndSetMode : stream: %s -> %s, mode: %s", streamTypeToString(mAudioFocusStreamType), streamTypeToString(stream), modeToString(mode)); Preconditions.checkState(stream != STREAM_NONE); // Even if we already have focus, if the stream is different we update audio manager to give // it a hint about the purpose of our focus. if (mAudioFocusStreamType != stream) { Log.i(this, "requestAudioFocusAndSetMode : requesting stream: %s -> %s", streamTypeToString(mAudioFocusStreamType), streamTypeToString(stream)); mAudioManagerHandler.obtainMessage( MSG_AUDIO_MANAGER_REQUEST_AUDIO_FOCUS_FOR_CALL, stream, 0) .sendToTarget(); } mAudioFocusStreamType = stream; setMode(mode); } private void abandonAudioFocus() { if (hasFocus()) { setMode(AudioManager.MODE_NORMAL); Log.v(this, "abandoning audio focus"); mAudioManagerHandler.obtainMessage(MSG_AUDIO_MANAGER_ABANDON_AUDIO_FOCUS_FOR_CALL, 0, 0) .sendToTarget(); mAudioFocusStreamType = STREAM_NONE; mCallToSpeedUpMTAudio = null; } } /** * Sets the audio mode. * * @param newMode Mode constant from AudioManager.MODE_*. */ private void setMode(int newMode) { Preconditions.checkState(hasFocus()); mAudioManagerHandler.obtainMessage(MSG_AUDIO_MANAGER_SET_MODE, newMode, 0).sendToTarget(); } private int selectWiredOrEarpiece(int route, int supportedRouteMask) { // Since they are mutually exclusive and one is ALWAYS valid, we allow a special input of // ROUTE_WIRED_OR_EARPIECE so that callers dont have to make a call to check which is // supported before calling setAudioRoute. if (route == CallAudioState.ROUTE_WIRED_OR_EARPIECE) { route = CallAudioState.ROUTE_WIRED_OR_EARPIECE & supportedRouteMask; if (route == 0) { Log.wtf(this, "One of wired headset or earpiece should always be valid."); // assume earpiece in this case. route = CallAudioState.ROUTE_EARPIECE; } } return route; } private int calculateSupportedRoutes() { int routeMask = CallAudioState.ROUTE_SPEAKER; if (mWiredHeadsetManager.isPluggedIn()) { routeMask |= CallAudioState.ROUTE_WIRED_HEADSET; } else { routeMask |= CallAudioState.ROUTE_EARPIECE; } if (mBluetoothManager.isBluetoothAvailable()) { routeMask |= CallAudioState.ROUTE_BLUETOOTH; } return routeMask; } private CallAudioState getInitialAudioState(Call call) { int supportedRouteMask = calculateSupportedRoutes(); int route = selectWiredOrEarpiece( CallAudioState.ROUTE_WIRED_OR_EARPIECE, supportedRouteMask); // We want the UI to indicate that "bluetooth is in use" in two slightly different cases: // (a) The obvious case: if a bluetooth headset is currently in use for an ongoing call. // (b) The not-so-obvious case: if an incoming call is ringing, and we expect that audio // *will* be routed to a bluetooth headset once the call is answered. In this case, just // check if the headset is available. Note this only applies when we are dealing with // the first call. if (call != null && mBluetoothManager.isBluetoothAvailable()) { switch(call.getState()) { case CallState.ACTIVE: case CallState.ON_HOLD: case CallState.DIALING: case CallState.CONNECTING: case CallState.RINGING: route = CallAudioState.ROUTE_BLUETOOTH; break; default: break; } } return new CallAudioState(false, route, supportedRouteMask); } private void setInitialAudioState(Call call, boolean force) { CallAudioState audioState = getInitialAudioState(call); Log.i(this, "setInitialAudioState : audioState = %s, call = %s", audioState, call); setSystemAudioState( force, audioState.isMuted(), audioState.getRoute(), audioState.getSupportedRouteMask()); } private void updateAudioForForegroundCall() { Call call = mCallsManager.getForegroundCall(); if (call != null && call.getConnectionService() != null) { call.getConnectionService().onCallAudioStateChanged(call, mCallAudioState); } } /** * Returns the current foreground call in order to properly set the audio mode. */ private Call getForegroundCall() { Call call = mCallsManager.getForegroundCall(); // We ignore any foreground call that is in the ringing state because we deal with ringing // calls exclusively through the mIsRinging variable set by {@link Ringer}. if (call != null && call.getState() == CallState.RINGING) { return null; } return call; } private boolean hasRingingForegroundCall() { Call call = mCallsManager.getForegroundCall(); return call != null && call.getState() == CallState.RINGING; } private boolean hasFocus() { return mAudioFocusStreamType != STREAM_NONE; } private IAudioService getAudioService() { return IAudioService.Stub.asInterface(ServiceManager.getService(Context.AUDIO_SERVICE)); } private int getCurrentUserId() { final long ident = Binder.clearCallingIdentity(); try { UserInfo currentUser = ActivityManagerNative.getDefault().getCurrentUser(); return currentUser.id; } catch (RemoteException e) { // Activity manager not running, nothing we can do assume user 0. } finally { Binder.restoreCallingIdentity(ident); } return UserHandle.USER_OWNER; } /** * Translates an {@link AudioManager} stream type to a human-readable string description. * * @param streamType The stream type. * @return Human readable description. */ private String streamTypeToString(int streamType) { switch (streamType) { case STREAM_NONE: return STREAM_DESCRIPTION_NONE; case AudioManager.STREAM_ALARM: return STREAM_DESCRIPTION_ALARM; case AudioManager.STREAM_BLUETOOTH_SCO: return STREAM_DESCRIPTION_BLUETOOTH_SCO; case AudioManager.STREAM_DTMF: return STREAM_DESCRIPTION_DTMF; case AudioManager.STREAM_MUSIC: return STREAM_DESCRIPTION_MUSIC; case AudioManager.STREAM_NOTIFICATION: return STREAM_DESCRIPTION_NOTIFICATION; case AudioManager.STREAM_RING: return STREAM_DESCRIPTION_RING; case AudioManager.STREAM_SYSTEM: return STREAM_DESCRIPTION_SYSTEM; case AudioManager.STREAM_VOICE_CALL: return STREAM_DESCRIPTION_VOICE_CALL; default: return "STEAM_OTHER_" + streamType; } } /** * Translates an {@link AudioManager} mode into a human readable string. * * @param mode The mode. * @return The string. */ private String modeToString(int mode) { switch (mode) { case AudioManager.MODE_INVALID: return MODE_DESCRIPTION_INVALID; case AudioManager.MODE_CURRENT: return MODE_DESCRIPTION_CURRENT; case AudioManager.MODE_NORMAL: return MODE_DESCRIPTION_NORMAL; case AudioManager.MODE_RINGTONE: return MODE_DESCRIPTION_RINGTONE; case AudioManager.MODE_IN_CALL: return MODE_DESCRIPTION_IN_CALL; case AudioManager.MODE_IN_COMMUNICATION: return MODE_DESCRIPTION_IN_COMMUNICATION; default: return "MODE_OTHER_" + mode; } } /** * Dumps the state of the {@link CallAudioManager}. * * @param pw The {@code IndentingPrintWriter} to write the state to. */ public void dump(IndentingPrintWriter pw) { pw.println("mAudioState: " + mCallAudioState); pw.println("mBluetoothManager:"); pw.increaseIndent(); mBluetoothManager.dump(pw); pw.decreaseIndent(); if (mWiredHeadsetManager != null) { pw.println("mWiredHeadsetManager:"); pw.increaseIndent(); mWiredHeadsetManager.dump(pw); pw.decreaseIndent(); } else { pw.println("mWiredHeadsetManager: null"); } pw.println("mAudioFocusStreamType: " + streamTypeToString(mAudioFocusStreamType)); pw.println("mIsRinging: " + mIsRinging); pw.println("mIsTonePlaying: " + mIsTonePlaying); pw.println("mWasSpeakerOn: " + mWasSpeakerOn); pw.println("mMostRecentlyUsedMode: " + modeToString(mMostRecentlyUsedMode)); } }