WiredAccessoryManagerpublic final class WiredAccessoryManager extends Object implements com.android.server.input.InputManagerService.WiredAccessoryCallbacksWiredAccessoryManager monitors for a wired headset on the main board or dock using
both the InputManagerService notifyWiredAccessoryChanged interface and the UEventObserver
subsystem. |
Fields Summary |
---|
private static final String | TAG | private static final boolean | LOG | private static final int | BIT_HEADSET | private static final int | BIT_HEADSET_NO_MIC | private static final int | BIT_USB_HEADSET_ANLG | private static final int | BIT_USB_HEADSET_DGTL | private static final int | BIT_HDMI_AUDIO | private static final int | BIT_LINEOUT | private static final int | SUPPORTED_HEADSETS | private static final String | NAME_H2W | private static final String | NAME_USB_AUDIO | private static final String | NAME_HDMI_AUDIO | private static final String | NAME_HDMI | private static final int | MSG_NEW_DEVICE_STATE | private static final int | MSG_SYSTEM_READY | private final Object | mLock | private final android.os.PowerManager.WakeLock | mWakeLock | private final android.media.AudioManager | mAudioManager | private int | mHeadsetState | private int | mSwitchValues | private final WiredAccessoryObserver | mObserver | private final com.android.server.input.InputManagerService | mInputManager | private final boolean | mUseDevInputEventForAudioJack | private final android.os.Handler | mHandler |
Constructors Summary |
---|
public WiredAccessoryManager(android.content.Context context, com.android.server.input.InputManagerService inputManager)
PowerManager pm = (PowerManager)context.getSystemService(Context.POWER_SERVICE);
mWakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "WiredAccessoryManager");
mWakeLock.setReferenceCounted(false);
mAudioManager = (AudioManager)context.getSystemService(Context.AUDIO_SERVICE);
mInputManager = inputManager;
mUseDevInputEventForAudioJack =
context.getResources().getBoolean(R.bool.config_useDevInputEventForAudioJack);
mObserver = new WiredAccessoryObserver();
|
Methods Summary |
---|
public void | notifyWiredAccessoryChanged(long whenNanos, int switchValues, int switchMask)
if (LOG) Slog.v(TAG, "notifyWiredAccessoryChanged: when=" + whenNanos
+ " bits=" + switchCodeToString(switchValues, switchMask)
+ " mask=" + Integer.toHexString(switchMask));
synchronized (mLock) {
int headset;
mSwitchValues = (mSwitchValues & ~switchMask) | switchValues;
switch (mSwitchValues &
(SW_HEADPHONE_INSERT_BIT | SW_MICROPHONE_INSERT_BIT | SW_LINEOUT_INSERT_BIT)) {
case 0:
headset = 0;
break;
case SW_HEADPHONE_INSERT_BIT:
headset = BIT_HEADSET_NO_MIC;
break;
case SW_LINEOUT_INSERT_BIT:
headset = BIT_LINEOUT;
break;
case SW_HEADPHONE_INSERT_BIT | SW_MICROPHONE_INSERT_BIT:
headset = BIT_HEADSET;
break;
case SW_MICROPHONE_INSERT_BIT:
headset = BIT_HEADSET;
break;
default:
headset = 0;
break;
}
updateLocked(NAME_H2W,
(mHeadsetState & ~(BIT_HEADSET | BIT_HEADSET_NO_MIC | BIT_LINEOUT)) | headset);
}
| private void | onSystemReady()
if (mUseDevInputEventForAudioJack) {
int switchValues = 0;
if (mInputManager.getSwitchState(-1, InputDevice.SOURCE_ANY, SW_HEADPHONE_INSERT) == 1) {
switchValues |= SW_HEADPHONE_INSERT_BIT;
}
if (mInputManager.getSwitchState(-1, InputDevice.SOURCE_ANY, SW_MICROPHONE_INSERT) == 1) {
switchValues |= SW_MICROPHONE_INSERT_BIT;
}
if (mInputManager.getSwitchState(-1, InputDevice.SOURCE_ANY, SW_LINEOUT_INSERT) == 1) {
switchValues |= SW_LINEOUT_INSERT_BIT;
}
notifyWiredAccessoryChanged(0, switchValues,
SW_HEADPHONE_INSERT_BIT | SW_MICROPHONE_INSERT_BIT | SW_LINEOUT_INSERT_BIT);
}
mObserver.init();
| private void | setDeviceStateLocked(int headset, int headsetState, int prevHeadsetState, java.lang.String headsetName)
if ((headsetState & headset) != (prevHeadsetState & headset)) {
int outDevice = 0;
int inDevice = 0;
int state;
if ((headsetState & headset) != 0) {
state = 1;
} else {
state = 0;
}
if (headset == BIT_HEADSET) {
outDevice = AudioManager.DEVICE_OUT_WIRED_HEADSET;
inDevice = AudioManager.DEVICE_IN_WIRED_HEADSET;
} else if (headset == BIT_HEADSET_NO_MIC){
outDevice = AudioManager.DEVICE_OUT_WIRED_HEADPHONE;
} else if (headset == BIT_LINEOUT){
outDevice = AudioManager.DEVICE_OUT_LINE;
} else if (headset == BIT_USB_HEADSET_ANLG) {
outDevice = AudioManager.DEVICE_OUT_ANLG_DOCK_HEADSET;
} else if (headset == BIT_USB_HEADSET_DGTL) {
outDevice = AudioManager.DEVICE_OUT_DGTL_DOCK_HEADSET;
} else if (headset == BIT_HDMI_AUDIO) {
outDevice = AudioManager.DEVICE_OUT_HDMI;
} else {
Slog.e(TAG, "setDeviceState() invalid headset type: "+headset);
return;
}
if (LOG)
Slog.v(TAG, "device "+headsetName+((state == 1) ? " connected" : " disconnected"));
if (outDevice != 0) {
mAudioManager.setWiredDeviceConnectionState(outDevice, state, headsetName);
}
if (inDevice != 0) {
mAudioManager.setWiredDeviceConnectionState(inDevice, state, headsetName);
}
}
| private void | setDevicesState(int headsetState, int prevHeadsetState, java.lang.String headsetName)
synchronized (mLock) {
int allHeadsets = SUPPORTED_HEADSETS;
for (int curHeadset = 1; allHeadsets != 0; curHeadset <<= 1) {
if ((curHeadset & allHeadsets) != 0) {
setDeviceStateLocked(curHeadset, headsetState, prevHeadsetState, headsetName);
allHeadsets &= ~curHeadset;
}
}
}
| private java.lang.String | switchCodeToString(int switchValues, int switchMask)
StringBuffer sb = new StringBuffer();
if ((switchMask & SW_HEADPHONE_INSERT_BIT) != 0 &&
(switchValues & SW_HEADPHONE_INSERT_BIT) != 0) {
sb.append("SW_HEADPHONE_INSERT ");
}
if ((switchMask & SW_MICROPHONE_INSERT_BIT) != 0 &&
(switchValues & SW_MICROPHONE_INSERT_BIT) != 0) {
sb.append("SW_MICROPHONE_INSERT");
}
return sb.toString();
| public void | systemReady()
synchronized (mLock) {
mWakeLock.acquire();
Message msg = mHandler.obtainMessage(MSG_SYSTEM_READY, 0, 0, null);
mHandler.sendMessage(msg);
}
| private void | updateLocked(java.lang.String newName, int newState)Compare the existing headset state with the new state and pass along accordingly. Note
that this only supports a single headset at a time. Inserting both a usb and jacked headset
results in support for the last one plugged in. Similarly, unplugging either is seen as
unplugging all.
// Retain only relevant bits
int headsetState = newState & SUPPORTED_HEADSETS;
int usb_headset_anlg = headsetState & BIT_USB_HEADSET_ANLG;
int usb_headset_dgtl = headsetState & BIT_USB_HEADSET_DGTL;
int h2w_headset = headsetState & (BIT_HEADSET | BIT_HEADSET_NO_MIC | BIT_LINEOUT);
boolean h2wStateChange = true;
boolean usbStateChange = true;
if (LOG) Slog.v(TAG, "newName=" + newName
+ " newState=" + newState
+ " headsetState=" + headsetState
+ " prev headsetState=" + mHeadsetState);
if (mHeadsetState == headsetState) {
Log.e(TAG, "No state change.");
return;
}
// reject all suspect transitions: only accept state changes from:
// - a: 0 headset to 1 headset
// - b: 1 headset to 0 headset
if (h2w_headset == (BIT_HEADSET | BIT_HEADSET_NO_MIC | BIT_LINEOUT)) {
Log.e(TAG, "Invalid combination, unsetting h2w flag");
h2wStateChange = false;
}
// - c: 0 usb headset to 1 usb headset
// - d: 1 usb headset to 0 usb headset
if (usb_headset_anlg == BIT_USB_HEADSET_ANLG && usb_headset_dgtl == BIT_USB_HEADSET_DGTL) {
Log.e(TAG, "Invalid combination, unsetting usb flag");
usbStateChange = false;
}
if (!h2wStateChange && !usbStateChange) {
Log.e(TAG, "invalid transition, returning ...");
return;
}
mWakeLock.acquire();
Message msg = mHandler.obtainMessage(MSG_NEW_DEVICE_STATE, headsetState,
mHeadsetState, newName);
mHandler.sendMessage(msg);
mHeadsetState = headsetState;
|
|