src/com/android/phone/AudioRouter.java - platform/packages/services/Telephony - Git at Google

 /*
  * Copyright (C) 2013 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.phone;

 import com.google.common.collect.Lists;

 import android.content.Context;
 import android.os.SystemProperties;
 import android.provider.MediaStore.Audio;
 import android.util.Log;

 import com.android.internal.telephony.CallManager;
 import com.android.internal.telephony.PhoneConstants;
 import com.android.phone.BluetoothManager.BluetoothIndicatorListener;
 import com.android.phone.WiredHeadsetManager.WiredHeadsetListener;
 import com.android.services.telephony.common.AudioMode;

 import java.util.List;

 /**
  * Responsible for Routing in-call audio and maintaining routing state.
  */
 /* package */ class AudioRouter implements BluetoothIndicatorListener, WiredHeadsetListener {

     private static String LOG_TAG = AudioRouter.class.getSimpleName();
     private static final boolean DBG =
             (PhoneGlobals.DBG_LEVEL >= 1) && (SystemProperties.getInt("ro.debuggable", 0) == 1);
     private static final boolean VDBG = (PhoneGlobals.DBG_LEVEL >= 2);

     private static final boolean ON = true;
     private static final boolean OFF = false;

     private final Context mContext;
     private final BluetoothManager mBluetoothManager;
     private final WiredHeadsetManager mWiredHeadsetManager;
     private final CallManager mCallManager;
     private final List<AudioModeListener> mListeners = Lists.newArrayList();
     private int mAudioMode = AudioMode.EARPIECE;
     private int mPreviousMode = AudioMode.EARPIECE;
     private int mSupportedModes = AudioMode.ALL_MODES;

     public AudioRouter(Context context, BluetoothManager bluetoothManager,
             WiredHeadsetManager wiredHeadsetManager, CallManager callManager) {
         mContext = context;
         mBluetoothManager = bluetoothManager;
         mWiredHeadsetManager = wiredHeadsetManager;
         mCallManager = callManager;

         init();
     }

     /**
      * Return the current audio mode.
      */
     public int getAudioMode() {
         return mAudioMode;
     }

     /**
      * Returns the currently supported audio modes.
      */
     public int getSupportedAudioModes() {
         return mSupportedModes;
     }

     /**
      * Returns the current mute state.
      */
     public boolean getMute() {
         return PhoneUtils.getMute();
     }

     /**
      * Add a listener to audio mode changes.
      */
     public void addAudioModeListener(AudioModeListener listener) {
         if (!mListeners.contains(listener)) {
             mListeners.add(listener);

             // For first notification, mPreviousAudioMode doesn't make sense.
             listener.onAudioModeChange(mAudioMode, getMute());
             listener.onSupportedAudioModeChange(mSupportedModes);
         }
     }

     /**
      * Remove  listener.
      */
     public void removeAudioModeListener(AudioModeListener listener) {
         if (mListeners.contains(listener)) {
             mListeners.remove(listener);
         }
     }

     /**
      * Sets the audio mode to the mode that is passed in.
      */
     public void setAudioMode(int mode) {
         logD("setAudioMode " + AudioMode.toString(mode));
         boolean error = false;

         // changes WIRED_OR_EARPIECE to appropriate single entry WIRED_HEADSET or EARPIECE
         mode = selectWiredOrEarpiece(mode);

         // If mode is unsupported, do nothing.
         if ((calculateSupportedModes() | mode) == 0) {
             Log.wtf(LOG_TAG, "Asking to set to a mode that is unsupported: " + mode);
             return;
         }

         if (AudioMode.SPEAKER == mode) {
             turnOnOffBluetooth(OFF);
             turnOnOffSpeaker(ON);

         } else if (AudioMode.BLUETOOTH == mode) {
             if (mBluetoothManager.isBluetoothAvailable()) {
                 // Manually turn the speaker phone off, instead of allowing the
                 // Bluetooth audio routing to handle it, since there's other
                 // important state-updating that needs to happen in the
                 // PhoneUtils.turnOnSpeaker() method.
                 // (Similarly, whenever the user turns *on* the speaker, we
                 // manually disconnect the active bluetooth headset;
                 // see toggleSpeaker() and/or switchInCallAudio().)
                 turnOnOffSpeaker(OFF);
                 if (!turnOnOffBluetooth(ON)) {
                     error = true;
                 }
             } else {
                 Log.e(LOG_TAG, "Asking to turn on bluetooth when no bluetooth available. " +
                         "supportedModes: " + AudioMode.toString(calculateSupportedModes()));
                 error = true;
             }

         // Wired headset and earpiece work the same way
         } else if (AudioMode.EARPIECE == mode || AudioMode.WIRED_HEADSET == mode) {
             turnOnOffBluetooth(OFF);
             turnOnOffSpeaker(OFF);

         } else {
             error = true;
         }

         if (error) {
             mode = calculateModeFromCurrentState();
             Log.e(LOG_TAG, "There was an error in setting new audio mode. " +
                     "Resetting mode to " + AudioMode.toString(mode) + ".");

         }

         updateAudioModeTo(mode);
     }

     /**
      * Turns on speaker.
      */
     public void setSpeaker(boolean on) {
         logD("setSpeaker " + on);

         if (on) {
             setAudioMode(AudioMode.SPEAKER);
         } else {
             setAudioMode(AudioMode.WIRED_OR_EARPIECE);
         }
     }

     public void onMuteChange(boolean muted) {
         logD("onMuteChange: " + muted);
         notifyListeners();
     }

     /**
      * Called when the bluetooth connection changes.
      * We adjust the audio mode according to the state we receive.
      */
     @Override
     public void onBluetoothIndicationChange(boolean isConnected, BluetoothManager btManager) {
         logD("onBluetoothIndicationChange " + isConnected);

         // this will read the new bluetooth mode appropriately
         updateAudioModeTo(calculateModeFromCurrentState());
     }

     /**
      * Called when the state of the wired headset changes.
      */
     @Override
     public void onWiredHeadsetConnection(boolean pluggedIn) {
         logD("onWireHeadsetConnection " + pluggedIn);

         // Since the presence of a wired headset or bluetooth affects the
         // speakerphone, update the "speaker" state.  We ONLY want to do
         // this on the wired headset connect / disconnect events for now
         // though.
         final boolean isOffhook = (mCallManager.getState() == PhoneConstants.State.OFFHOOK);

         int newMode = mAudioMode;

         // Change state only if we are not using bluetooth
         if (!mBluetoothManager.isBluetoothHeadsetAudioOn()) {

             // Do special logic with speakerphone if we have an ongoing (offhook) call.
             if (isOffhook) {
                 if (!pluggedIn) {
                     // if the state is "not connected", restore the speaker state.
                     PhoneUtils.restoreSpeakerMode(mContext);

                     if (PhoneUtils.isSpeakerOn(mContext)) {
                         newMode = AudioMode.SPEAKER;
                     } else {
                         newMode = AudioMode.EARPIECE;
                     }
                 } else {
                     // if the state is "connected", force the speaker off without
                     // storing the state.
                     PhoneUtils.turnOnSpeaker(mContext, false, false);

                     newMode = AudioMode.WIRED_HEADSET;
                 }

             // if we are outside of a phone call, the logic is simpler
             } else {
                 newMode = pluggedIn ? AudioMode.WIRED_HEADSET : AudioMode.EARPIECE;
             }
         }

         updateAudioModeTo(newMode);
     }

     /**
      * Changes WIRED_OR_EARPIECE to appropriate single entry WIRED_HEADSET or EARPIECE.
      * If mode passed it is not WIRED_OR_EARPIECE, this is a no-op and simply returns
      * the unchanged mode parameter.
      */
     private int selectWiredOrEarpiece(int mode) {
         // Since they are mutually exclusive and one is ALWAYS valid, we allow a special input of
         // WIRED_OR_EARPIECE so that callers dont have to make a call to check which is supported
         // before calling setAudioMode.
         if (mode == AudioMode.WIRED_OR_EARPIECE) {
             mode = AudioMode.WIRED_OR_EARPIECE & mSupportedModes;

             if (mode == 0) {
                 Log.wtf(LOG_TAG, "One of wired headset or earpiece should always be valid.");
                 // assume earpiece in this case.
                 mode = AudioMode.EARPIECE;
             }
         }

         return mode;
     }

     /**
      * Turns on/off bluetooth.  If bluetooth is already in the correct mode, this does
      * nothing.
      */
     private boolean turnOnOffBluetooth(boolean onOff) {
         if (mBluetoothManager.isBluetoothAvailable()) {
             final boolean isAlreadyOn = mBluetoothManager.isBluetoothAudioConnected();

             if (onOff && !isAlreadyOn) {
                 mBluetoothManager.connectBluetoothAudio();
             } else if (!onOff && isAlreadyOn) {
                 mBluetoothManager.disconnectBluetoothAudio();
             }
         } else if (onOff) {
             Log.e(LOG_TAG, "Asking to turn on bluetooth, but there is no bluetooth availabled.");
             return false;
         }

         return true;
     }

     /**
      * Turn on/off speaker.
      */
     private void turnOnOffSpeaker(boolean onOff) {
         if (PhoneUtils.isSpeakerOn(mContext) != onOff) {
             PhoneUtils.turnOnSpeaker(mContext, onOff, true /* storeState */);
         }
     }

     private void init() {
         mBluetoothManager.addBluetoothIndicatorListener(this);
         mWiredHeadsetManager.addWiredHeadsetListener(this);
     }

     /**
      * Reads the state of the world to determine Audio mode.
      */
     private int calculateModeFromCurrentState() {

         int mode = AudioMode.EARPIECE;

         // There is a very specific ordering here
         if (mBluetoothManager.showBluetoothIndication()) {
             mode = AudioMode.BLUETOOTH;
         } else if (PhoneUtils.isSpeakerOn(mContext)) {
             mode = AudioMode.SPEAKER;
         } else if (mWiredHeadsetManager.isHeadsetPlugged()) {
             mode = AudioMode.WIRED_HEADSET;
         }

         logD("calculateModeFromCurrentState " + AudioMode.toString(mode));

         return mode;
     }

     /**
      * Changes the audio mode to the mode in the parameter.
      */
     private void updateAudioModeTo(int mode) {
         int oldSupportedModes = mSupportedModes;

         mSupportedModes = calculateSupportedModes();

         // This is a weird state that shouldn't happen, but we get called here
         // once we've changed the audio layers so lets log the error, but assume
         // that it went through. If it happens it is likely it is a race condition
         // that will resolve itself when we get updates on the mode change.
         if ((mSupportedModes & mode) == 0) {
             Log.e(LOG_TAG, "Setting audio mode to an unsupported mode: " +
                     AudioMode.toString(mode) + ", supported (" +
                     AudioMode.toString(mSupportedModes) + ")");
         }

         boolean doNotify = oldSupportedModes != mSupportedModes;

         // only update if it really changed.
         if (mAudioMode != mode) {
             Log.i(LOG_TAG, "Audio mode changing to " + AudioMode.toString(mode));
             doNotify = true;
         }

         mPreviousMode = mAudioMode;
         mAudioMode = mode;

         if (doNotify) {
             notifyListeners();
         }
     }

     /**
      * Gets the updates supported modes from the state of the audio systems.
      */
     private int calculateSupportedModes() {
         // speaker phone always a supported state
         int supportedModes = AudioMode.SPEAKER;

         if (mWiredHeadsetManager.isHeadsetPlugged()) {
             supportedModes |= AudioMode.WIRED_HEADSET;
         } else {
             supportedModes |= AudioMode.EARPIECE;
         }

         if (mBluetoothManager.isBluetoothAvailable()) {
             supportedModes |= AudioMode.BLUETOOTH;
         }

         return supportedModes;
     }

     private void notifyListeners() {
         logD("AudioMode: " + AudioMode.toString(mAudioMode));
         logD("Supported AudioMode: " + AudioMode.toString(mSupportedModes));

         for (int i = 0; i < mListeners.size(); i++) {
             mListeners.get(i).onAudioModeChange(mAudioMode, getMute());
             mListeners.get(i).onSupportedAudioModeChange(mSupportedModes);
         }
     }

     public interface AudioModeListener {
         void onAudioModeChange(int newMode, boolean muted);
         void onSupportedAudioModeChange(int modeMask);
     }

     private void logD(String msg) {
         if (DBG) {
             Log.d(LOG_TAG, msg);
         }
     }
 }
	/*
	* Copyright (C) 2013 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.phone;

	import com.google.common.collect.Lists;

	import android.content.Context;
	import android.os.SystemProperties;
	import android.provider.MediaStore.Audio;
	import android.util.Log;

	import com.android.internal.telephony.CallManager;
	import com.android.internal.telephony.PhoneConstants;
	import com.android.phone.BluetoothManager.BluetoothIndicatorListener;
	import com.android.phone.WiredHeadsetManager.WiredHeadsetListener;
	import com.android.services.telephony.common.AudioMode;

	import java.util.List;

	/**
	* Responsible for Routing in-call audio and maintaining routing state.
	*/
	/* package */ class AudioRouter implements BluetoothIndicatorListener, WiredHeadsetListener {

	private static String LOG_TAG = AudioRouter.class.getSimpleName();
	private static final boolean DBG =
	(PhoneGlobals.DBG_LEVEL >= 1) && (SystemProperties.getInt("ro.debuggable", 0) == 1);
	private static final boolean VDBG = (PhoneGlobals.DBG_LEVEL >= 2);

	private static final boolean ON = true;
	private static final boolean OFF = false;

	private final Context mContext;
	private final BluetoothManager mBluetoothManager;
	private final WiredHeadsetManager mWiredHeadsetManager;
	private final CallManager mCallManager;
	private final List<AudioModeListener> mListeners = Lists.newArrayList();
	private int mAudioMode = AudioMode.EARPIECE;
	private int mPreviousMode = AudioMode.EARPIECE;
	private int mSupportedModes = AudioMode.ALL_MODES;

	public AudioRouter(Context context, BluetoothManager bluetoothManager,
	WiredHeadsetManager wiredHeadsetManager, CallManager callManager) {
	mContext = context;
	mBluetoothManager = bluetoothManager;
	mWiredHeadsetManager = wiredHeadsetManager;
	mCallManager = callManager;

	init();
	}

	/**
	* Return the current audio mode.
	*/
	public int getAudioMode() {
	return mAudioMode;
	}

	/**
	* Returns the currently supported audio modes.
	*/
	public int getSupportedAudioModes() {
	return mSupportedModes;
	}

	/**
	* Returns the current mute state.
	*/
	public boolean getMute() {
	return PhoneUtils.getMute();
	}

	/**
	* Add a listener to audio mode changes.
	*/
	public void addAudioModeListener(AudioModeListener listener) {
	if (!mListeners.contains(listener)) {
	mListeners.add(listener);

	// For first notification, mPreviousAudioMode doesn't make sense.
	listener.onAudioModeChange(mAudioMode, getMute());
	listener.onSupportedAudioModeChange(mSupportedModes);
	}
	}

	/**
	* Remove listener.
	*/
	public void removeAudioModeListener(AudioModeListener listener) {
	if (mListeners.contains(listener)) {
	mListeners.remove(listener);
	}
	}

	/**
	* Sets the audio mode to the mode that is passed in.
	*/
	public void setAudioMode(int mode) {
	logD("setAudioMode " + AudioMode.toString(mode));
	boolean error = false;

	// changes WIRED_OR_EARPIECE to appropriate single entry WIRED_HEADSET or EARPIECE
	mode = selectWiredOrEarpiece(mode);

	// If mode is unsupported, do nothing.
	if ((calculateSupportedModes() \| mode) == 0) {
	Log.wtf(LOG_TAG, "Asking to set to a mode that is unsupported: " + mode);
	return;
	}

	if (AudioMode.SPEAKER == mode) {
	turnOnOffBluetooth(OFF);
	turnOnOffSpeaker(ON);

	} else if (AudioMode.BLUETOOTH == mode) {
	if (mBluetoothManager.isBluetoothAvailable()) {
	// Manually turn the speaker phone off, instead of allowing the
	// Bluetooth audio routing to handle it, since there's other
	// important state-updating that needs to happen in the
	// PhoneUtils.turnOnSpeaker() method.
	// (Similarly, whenever the user turns on the speaker, we
	// manually disconnect the active bluetooth headset;
	// see toggleSpeaker() and/or switchInCallAudio().)
	turnOnOffSpeaker(OFF);
	if (!turnOnOffBluetooth(ON)) {
	error = true;
	}
	} else {
	Log.e(LOG_TAG, "Asking to turn on bluetooth when no bluetooth available. " +
	"supportedModes: " + AudioMode.toString(calculateSupportedModes()));
	error = true;
	}

	// Wired headset and earpiece work the same way
	} else if (AudioMode.EARPIECE == mode \|\| AudioMode.WIRED_HEADSET == mode) {
	turnOnOffBluetooth(OFF);
	turnOnOffSpeaker(OFF);

	} else {
	error = true;
	}

	if (error) {
	mode = calculateModeFromCurrentState();
	Log.e(LOG_TAG, "There was an error in setting new audio mode. " +
	"Resetting mode to " + AudioMode.toString(mode) + ".");

	}

	updateAudioModeTo(mode);
	}

	/**
	* Turns on speaker.
	*/
	public void setSpeaker(boolean on) {
	logD("setSpeaker " + on);

	if (on) {
	setAudioMode(AudioMode.SPEAKER);
	} else {
	setAudioMode(AudioMode.WIRED_OR_EARPIECE);
	}
	}

	public void onMuteChange(boolean muted) {
	logD("onMuteChange: " + muted);
	notifyListeners();
	}

	/**
	* Called when the bluetooth connection changes.
	* We adjust the audio mode according to the state we receive.
	*/
	@Override
	public void onBluetoothIndicationChange(boolean isConnected, BluetoothManager btManager) {
	logD("onBluetoothIndicationChange " + isConnected);

	// this will read the new bluetooth mode appropriately
	updateAudioModeTo(calculateModeFromCurrentState());
	}

	/**
	* Called when the state of the wired headset changes.
	*/
	@Override
	public void onWiredHeadsetConnection(boolean pluggedIn) {
	logD("onWireHeadsetConnection " + pluggedIn);

	// Since the presence of a wired headset or bluetooth affects the
	// speakerphone, update the "speaker" state. We ONLY want to do
	// this on the wired headset connect / disconnect events for now
	// though.
	final boolean isOffhook = (mCallManager.getState() == PhoneConstants.State.OFFHOOK);

	int newMode = mAudioMode;

	// Change state only if we are not using bluetooth
	if (!mBluetoothManager.isBluetoothHeadsetAudioOn()) {

	// Do special logic with speakerphone if we have an ongoing (offhook) call.
	if (isOffhook) {
	if (!pluggedIn) {
	// if the state is "not connected", restore the speaker state.
	PhoneUtils.restoreSpeakerMode(mContext);

	if (PhoneUtils.isSpeakerOn(mContext)) {
	newMode = AudioMode.SPEAKER;
	} else {
	newMode = AudioMode.EARPIECE;
	}
	} else {
	// if the state is "connected", force the speaker off without
	// storing the state.
	PhoneUtils.turnOnSpeaker(mContext, false, false);

	newMode = AudioMode.WIRED_HEADSET;
	}

	// if we are outside of a phone call, the logic is simpler
	} else {
	newMode = pluggedIn ? AudioMode.WIRED_HEADSET : AudioMode.EARPIECE;
	}
	}

	updateAudioModeTo(newMode);
	}

	/**
	* Changes WIRED_OR_EARPIECE to appropriate single entry WIRED_HEADSET or EARPIECE.
	* If mode passed it is not WIRED_OR_EARPIECE, this is a no-op and simply returns
	* the unchanged mode parameter.
	*/
	private int selectWiredOrEarpiece(int mode) {
	// Since they are mutually exclusive and one is ALWAYS valid, we allow a special input of
	// WIRED_OR_EARPIECE so that callers dont have to make a call to check which is supported
	// before calling setAudioMode.
	if (mode == AudioMode.WIRED_OR_EARPIECE) {
	mode = AudioMode.WIRED_OR_EARPIECE & mSupportedModes;

	if (mode == 0) {
	Log.wtf(LOG_TAG, "One of wired headset or earpiece should always be valid.");
	// assume earpiece in this case.
	mode = AudioMode.EARPIECE;
	}
	}

	return mode;
	}

	/**
	* Turns on/off bluetooth. If bluetooth is already in the correct mode, this does
	* nothing.
	*/
	private boolean turnOnOffBluetooth(boolean onOff) {
	if (mBluetoothManager.isBluetoothAvailable()) {
	final boolean isAlreadyOn = mBluetoothManager.isBluetoothAudioConnected();

	if (onOff && !isAlreadyOn) {
	mBluetoothManager.connectBluetoothAudio();
	} else if (!onOff && isAlreadyOn) {
	mBluetoothManager.disconnectBluetoothAudio();
	}
	} else if (onOff) {
	Log.e(LOG_TAG, "Asking to turn on bluetooth, but there is no bluetooth availabled.");
	return false;
	}

	return true;
	}

	/**
	* Turn on/off speaker.
	*/
	private void turnOnOffSpeaker(boolean onOff) {
	if (PhoneUtils.isSpeakerOn(mContext) != onOff) {
	PhoneUtils.turnOnSpeaker(mContext, onOff, true /* storeState */);
	}
	}

	private void init() {
	mBluetoothManager.addBluetoothIndicatorListener(this);
	mWiredHeadsetManager.addWiredHeadsetListener(this);
	}

	/**
	* Reads the state of the world to determine Audio mode.
	*/
	private int calculateModeFromCurrentState() {

	int mode = AudioMode.EARPIECE;

	// There is a very specific ordering here
	if (mBluetoothManager.showBluetoothIndication()) {
	mode = AudioMode.BLUETOOTH;
	} else if (PhoneUtils.isSpeakerOn(mContext)) {
	mode = AudioMode.SPEAKER;
	} else if (mWiredHeadsetManager.isHeadsetPlugged()) {
	mode = AudioMode.WIRED_HEADSET;
	}

	logD("calculateModeFromCurrentState " + AudioMode.toString(mode));

	return mode;
	}

	/**
	* Changes the audio mode to the mode in the parameter.
	*/
	private void updateAudioModeTo(int mode) {
	int oldSupportedModes = mSupportedModes;

	mSupportedModes = calculateSupportedModes();

	// This is a weird state that shouldn't happen, but we get called here
	// once we've changed the audio layers so lets log the error, but assume
	// that it went through. If it happens it is likely it is a race condition
	// that will resolve itself when we get updates on the mode change.
	if ((mSupportedModes & mode) == 0) {
	Log.e(LOG_TAG, "Setting audio mode to an unsupported mode: " +
	AudioMode.toString(mode) + ", supported (" +
	AudioMode.toString(mSupportedModes) + ")");
	}

	boolean doNotify = oldSupportedModes != mSupportedModes;

	// only update if it really changed.
	if (mAudioMode != mode) {
	Log.i(LOG_TAG, "Audio mode changing to " + AudioMode.toString(mode));
	doNotify = true;
	}

	mPreviousMode = mAudioMode;
	mAudioMode = mode;

	if (doNotify) {
	notifyListeners();
	}
	}

	/**
	* Gets the updates supported modes from the state of the audio systems.
	*/
	private int calculateSupportedModes() {
	// speaker phone always a supported state
	int supportedModes = AudioMode.SPEAKER;

	if (mWiredHeadsetManager.isHeadsetPlugged()) {
	supportedModes \|= AudioMode.WIRED_HEADSET;
	} else {
	supportedModes \|= AudioMode.EARPIECE;
	}

	if (mBluetoothManager.isBluetoothAvailable()) {
	supportedModes \|= AudioMode.BLUETOOTH;
	}

	return supportedModes;
	}

	private void notifyListeners() {
	logD("AudioMode: " + AudioMode.toString(mAudioMode));
	logD("Supported AudioMode: " + AudioMode.toString(mSupportedModes));

	for (int i = 0; i < mListeners.size(); i++) {
	mListeners.get(i).onAudioModeChange(mAudioMode, getMute());
	mListeners.get(i).onSupportedAudioModeChange(mSupportedModes);
	}
	}

	public interface AudioModeListener {
	void onAudioModeChange(int newMode, boolean muted);
	void onSupportedAudioModeChange(int modeMask);
	}

	private void logD(String msg) {
	if (DBG) {
	Log.d(LOG_TAG, msg);
	}
	}
	}