implements Watchdog.Monitor, DisplayManagerService.InputManagerFuncs {

static final String TAG = "InputManager";

static final boolean DEBUG = false;

private static final String EXCLUDED_DEVICES_PATH = "etc/excluded-input-devices.xml";

private static final int MSG_DELIVER_INPUT_DEVICES_CHANGED = 1;

private static final int MSG_SWITCH_KEYBOARD_LAYOUT = 2;

private static final int MSG_RELOAD_KEYBOARD_LAYOUTS = 3;

private static final int MSG_UPDATE_KEYBOARD_LAYOUTS = 4;

private static final int MSG_RELOAD_DEVICE_ALIASES = 5;

// Pointer to native input manager service object.

private final int mPtr;

private final Context mContext;

private final InputManagerHandler mHandler;

private WindowManagerCallbacks mWindowManagerCallbacks;

private WiredAccessoryCallbacks mWiredAccessoryCallbacks;

private boolean mSystemReady;

private NotificationManager mNotificationManager;

// Persistent data store. Must be locked each time during use.

private final PersistentDataStore mDataStore = new PersistentDataStore();

// List of currently registered input devices changed listeners by process id.

private Object mInputDevicesLock = new Object();

private boolean mInputDevicesChangedPending; // guarded by mInputDevicesLock

private InputDevice[] mInputDevices = new InputDevice[0];

private final SparseArray<InputDevicesChangedListenerRecord> mInputDevicesChangedListeners =

new SparseArray<InputDevicesChangedListenerRecord>(); // guarded by mInputDevicesLock

private final ArrayList<InputDevicesChangedListenerRecord>

mTempInputDevicesChangedListenersToNotify =

new ArrayList<InputDevicesChangedListenerRecord>(); // handler thread only

private final ArrayList<InputDevice>

mTempFullKeyboards = new ArrayList<InputDevice>(); // handler thread only

private boolean mKeyboardLayoutNotificationShown;

private PendingIntent mKeyboardLayoutIntent;

private Toast mSwitchedKeyboardLayoutToast;

// State for vibrator tokens.

private Object mVibratorLock = new Object();

private HashMap<IBinder, VibratorToken> mVibratorTokens =

new HashMap<IBinder, VibratorToken>();

private int mNextVibratorTokenValue;

// State for the currently installed input filter.

final Object mInputFilterLock = new Object();

IInputFilter mInputFilter; // guarded by mInputFilterLock

InputFilterHost mInputFilterHost; // guarded by mInputFilterLock

private static native int nativeInit(InputManagerService service,

Context context, MessageQueue messageQueue);

private static native void nativeStart(int ptr);

private static native void nativeSetDisplayViewport(int ptr, boolean external,

int displayId, int rotation,

int logicalLeft, int logicalTop, int logicalRight, int logicalBottom,

int physicalLeft, int physicalTop, int physicalRight, int physicalBottom,

int deviceWidth, int deviceHeight);

private static native int nativeGetScanCodeState(int ptr,

int deviceId, int sourceMask, int scanCode);

private static native int nativeGetKeyCodeState(int ptr,

int deviceId, int sourceMask, int keyCode);

private static native int nativeGetSwitchState(int ptr,

int deviceId, int sourceMask, int sw);

private static native boolean nativeHasKeys(int ptr,

int deviceId, int sourceMask, int[] keyCodes, boolean[] keyExists);

private static native void nativeRegisterInputChannel(int ptr, InputChannel inputChannel,

InputWindowHandle inputWindowHandle, boolean monitor);

private static native void nativeUnregisterInputChannel(int ptr, InputChannel inputChannel);

private static native void nativeSetInputFilterEnabled(int ptr, boolean enable);

private static native int nativeInjectInputEvent(int ptr, InputEvent event,

int injectorPid, int injectorUid, int syncMode, int timeoutMillis,

int policyFlags);

private static native void nativeSetInputWindows(int ptr, InputWindowHandle[] windowHandles);

private static native void nativeSetInputDispatchMode(int ptr, boolean enabled, boolean frozen);

private static native void nativeSetSystemUiVisibility(int ptr, int visibility);

private static native void nativeSetFocusedApplication(int ptr,

InputApplicationHandle application);

private static native boolean nativeTransferTouchFocus(int ptr,

InputChannel fromChannel, InputChannel toChannel);

private static native void nativeSetPointerSpeed(int ptr, int speed);

private static native void nativeSetShowTouches(int ptr, boolean enabled);

private static native void nativeVibrate(int ptr, int deviceId, long[] pattern,

int repeat, int token);

private static native void nativeCancelVibrate(int ptr, int deviceId, int token);

private static native void nativeReloadKeyboardLayouts(int ptr);

private static native void nativeReloadDeviceAliases(int ptr);

private static native String nativeDump(int ptr);

private static native void nativeMonitor(int ptr);

// Input event injection constants defined in InputDispatcher.h.

private static final int INPUT_EVENT_INJECTION_SUCCEEDED = 0;

private static final int INPUT_EVENT_INJECTION_PERMISSION_DENIED = 1;

private static final int INPUT_EVENT_INJECTION_FAILED = 2;

private static final int INPUT_EVENT_INJECTION_TIMED_OUT = 3;

// Maximum number of milliseconds to wait for input event injection.

private static final int INJECTION_TIMEOUT_MILLIS = 30 * 1000;

// Key states (may be returned by queries about the current state of a

// particular key code, scan code or switch).

/** The key state is unknown or the requested key itself is not supported. */

public static final int KEY_STATE_UNKNOWN = -1;

/** The key is up. /*/

public static final int KEY_STATE_UP = 0;

/** The key is down. */

public static final int KEY_STATE_DOWN = 1;

/** The key is down but is a virtual key press that is being emulated by the system. */

public static final int KEY_STATE_VIRTUAL = 2;

/** Scan code: Mouse / trackball button. */

public static final int BTN_MOUSE = 0x110;

// Switch code values must match bionic/libc/kernel/common/linux/input.h

/** Switch code: Lid switch. When set, lid is shut. */

public static final int SW_LID = 0x00;

/** Switch code: Keypad slide. When set, keyboard is exposed. */

public static final int SW_KEYPAD_SLIDE = 0x0a;

/** Switch code: Headphone. When set, headphone is inserted. */

public static final int SW_HEADPHONE_INSERT = 0x02;

/** Switch code: Microphone. When set, microphone is inserted. */

public static final int SW_MICROPHONE_INSERT = 0x04;

/** Switch code: Headphone/Microphone Jack. When set, something is inserted. */

public static final int SW_JACK_PHYSICAL_INSERT = 0x07;

public static final int SW_LID_BIT = 1 << SW_LID;

public static final int SW_KEYPAD_SLIDE_BIT = 1 << SW_KEYPAD_SLIDE;

public static final int SW_HEADPHONE_INSERT_BIT = 1 << SW_HEADPHONE_INSERT;

public static final int SW_MICROPHONE_INSERT_BIT = 1 << SW_MICROPHONE_INSERT;

public static final int SW_JACK_PHYSICAL_INSERT_BIT = 1 << SW_JACK_PHYSICAL_INSERT;

public static final int SW_JACK_BITS =

SW_HEADPHONE_INSERT_BIT | SW_MICROPHONE_INSERT_BIT | SW_JACK_PHYSICAL_INSERT_BIT;

/** Whether to use the dev/input/event or uevent subsystem for the audio jack. */

final boolean mUseDevInputEventForAudioJack;

public InputManagerService(Context context, Handler handler) {

this.mContext = context;

this.mHandler = new InputManagerHandler(handler.getLooper());

mUseDevInputEventForAudioJack =

context.getResources().getBoolean(R.bool.config_useDevInputEventForAudioJack);

Slog.i(TAG, "Initializing input manager, mUseDevInputEventForAudioJack="

+ mUseDevInputEventForAudioJack);

mPtr = nativeInit(this, mContext, mHandler.getLooper().getQueue());

}

public void setWindowManagerCallbacks(WindowManagerCallbacks callbacks) {

mWindowManagerCallbacks = callbacks;

}

public void setWiredAccessoryCallbacks(WiredAccessoryCallbacks callbacks) {

mWiredAccessoryCallbacks = callbacks;

}

public void start() {

Slog.i(TAG, "Starting input manager");

nativeStart(mPtr);

// Add ourself to the Watchdog monitors.

Watchdog.getInstance().addMonitor(this);

registerPointerSpeedSettingObserver();

registerShowTouchesSettingObserver();

mContext.registerReceiver(new BroadcastReceiver() {

@Override

public void onReceive(Context context, Intent intent) {

updatePointerSpeedFromSettings();

updateShowTouchesFromSettings();

}

}, new IntentFilter(Intent.ACTION_USER_SWITCHED), null, mHandler);

updatePointerSpeedFromSettings();

updateShowTouchesFromSettings();

}

// TODO(BT) Pass in paramter for bluetooth system

public void systemReady() {

if (DEBUG) {

Slog.d(TAG, "System ready.");

}

mNotificationManager = (NotificationManager)mContext.getSystemService(

Context.NOTIFICATION_SERVICE);

mSystemReady = true;

IntentFilter filter = new IntentFilter(Intent.ACTION_PACKAGE_ADDED);

filter.addAction(Intent.ACTION_PACKAGE_REMOVED);

filter.addAction(Intent.ACTION_PACKAGE_CHANGED);

filter.addDataScheme("package");

mContext.registerReceiver(new BroadcastReceiver() {

@Override

public void onReceive(Context context, Intent intent) {

updateKeyboardLayouts();

}

}, filter, null, mHandler);

filter = new IntentFilter(BluetoothDevice.ACTION_ALIAS_CHANGED);

mContext.registerReceiver(new BroadcastReceiver() {

@Override

public void onReceive(Context context, Intent intent) {

reloadDeviceAliases();

}

}, filter, null, mHandler);

mHandler.sendEmptyMessage(MSG_RELOAD_DEVICE_ALIASES);

mHandler.sendEmptyMessage(MSG_UPDATE_KEYBOARD_LAYOUTS);

}

private void reloadKeyboardLayouts() {

if (DEBUG) {

Slog.d(TAG, "Reloading keyboard layouts.");

}

nativeReloadKeyboardLayouts(mPtr);

}

private void reloadDeviceAliases() {

if (DEBUG) {

Slog.d(TAG, "Reloading device names.");

}

nativeReloadDeviceAliases(mPtr);

}

@Override

public void setDisplayViewports(DisplayViewport defaultViewport,

DisplayViewport externalTouchViewport) {

if (defaultViewport.valid) {

setDisplayViewport(false, defaultViewport);

}

if (externalTouchViewport.valid) {

setDisplayViewport(true, externalTouchViewport);

} else if (defaultViewport.valid) {

setDisplayViewport(true, defaultViewport);

}

}

private void setDisplayViewport(boolean external, DisplayViewport viewport) {

nativeSetDisplayViewport(mPtr, external,

viewport.displayId, viewport.orientation,

viewport.logicalFrame.left, viewport.logicalFrame.top,

viewport.logicalFrame.right, viewport.logicalFrame.bottom,

viewport.physicalFrame.left, viewport.physicalFrame.top,

viewport.physicalFrame.right, viewport.physicalFrame.bottom,

viewport.deviceWidth, viewport.deviceHeight);

}

/**

public int getKeyCodeState(int deviceId, int sourceMask, int keyCode) {

return nativeGetKeyCodeState(mPtr, deviceId, sourceMask, keyCode);

}

/**

public int getScanCodeState(int deviceId, int sourceMask, int scanCode) {

return nativeGetScanCodeState(mPtr, deviceId, sourceMask, scanCode);

}

/**

public int getSwitchState(int deviceId, int sourceMask, int switchCode) {

return nativeGetSwitchState(mPtr, deviceId, sourceMask, switchCode);

}

/**

@Override // Binder call

public boolean hasKeys(int deviceId, int sourceMask, int[] keyCodes, boolean[] keyExists) {

if (keyCodes == null) {

throw new IllegalArgumentException("keyCodes must not be null.");

}

if (keyExists == null || keyExists.length < keyCodes.length) {

throw new IllegalArgumentException("keyExists must not be null and must be at "

+ "least as large as keyCodes.");

}

return nativeHasKeys(mPtr, deviceId, sourceMask, keyCodes, keyExists);

}

/**

public InputChannel monitorInput(String inputChannelName) {

if (inputChannelName == null) {

throw new IllegalArgumentException("inputChannelName must not be null.");

}

InputChannel[] inputChannels = InputChannel.openInputChannelPair(inputChannelName);

nativeRegisterInputChannel(mPtr, inputChannels[0], null, true);

inputChannels[0].dispose(); // don't need to retain the Java object reference

return inputChannels[1];

}

/**

public void registerInputChannel(InputChannel inputChannel,

InputWindowHandle inputWindowHandle) {

if (inputChannel == null) {

throw new IllegalArgumentException("inputChannel must not be null.");

}

nativeRegisterInputChannel(mPtr, inputChannel, inputWindowHandle, false);

}

/**

public void unregisterInputChannel(InputChannel inputChannel) {

if (inputChannel == null) {

throw new IllegalArgumentException("inputChannel must not be null.");

}

nativeUnregisterInputChannel(mPtr, inputChannel);

}

/**

public void setInputFilter(IInputFilter filter) {

synchronized (mInputFilterLock) {

final IInputFilter oldFilter = mInputFilter;

if (oldFilter == filter) {

return; // nothing to do

}

if (oldFilter != null) {

mInputFilter = null;

mInputFilterHost.disconnectLocked();

mInputFilterHost = null;

try {

oldFilter.uninstall();

} catch (RemoteException re) {

/* ignore */

}

}

if (filter != null) {

mInputFilter = filter;

mInputFilterHost = new InputFilterHost();

try {

filter.install(mInputFilterHost);

} catch (RemoteException re) {

/* ignore */

}

}

nativeSetInputFilterEnabled(mPtr, filter != null);

}

}

@Override // Binder call

public boolean injectInputEvent(InputEvent event, int mode) {

if (event == null) {

throw new IllegalArgumentException("event must not be null");

}

if (mode != InputManager.INJECT_INPUT_EVENT_MODE_ASYNC

&& mode != InputManager.INJECT_INPUT_EVENT_MODE_WAIT_FOR_FINISH

&& mode != InputManager.INJECT_INPUT_EVENT_MODE_WAIT_FOR_RESULT) {

throw new IllegalArgumentException("mode is invalid");

}

final int pid = Binder.getCallingPid();

final int uid = Binder.getCallingUid();

final long ident = Binder.clearCallingIdentity();

final int result;

try {

result = nativeInjectInputEvent(mPtr, event, pid, uid, mode,

INJECTION_TIMEOUT_MILLIS, WindowManagerPolicy.FLAG_DISABLE_KEY_REPEAT);

} finally {

Binder.restoreCallingIdentity(ident);

}

switch (result) {

case INPUT_EVENT_INJECTION_PERMISSION_DENIED:

Slog.w(TAG, "Input event injection from pid " + pid + " permission denied.");

throw new SecurityException(

"Injecting to another application requires INJECT_EVENTS permission");

case INPUT_EVENT_INJECTION_SUCCEEDED:

return true;

case INPUT_EVENT_INJECTION_TIMED_OUT:

Slog.w(TAG, "Input event injection from pid " + pid + " timed out.");

return false;

case INPUT_EVENT_INJECTION_FAILED:

default:

Slog.w(TAG, "Input event injection from pid " + pid + " failed.");

return false;

}

}

/**

@Override // Binder call

public InputDevice getInputDevice(int deviceId) {

synchronized (mInputDevicesLock) {

final int count = mInputDevices.length;

for (int i = 0; i < count; i++) {

final InputDevice inputDevice = mInputDevices[i];

if (inputDevice.getId() == deviceId) {

return inputDevice;

}

}

}

return null;

}

/**

@Override // Binder call

public int[] getInputDeviceIds() {

synchronized (mInputDevicesLock) {

final int count = mInputDevices.length;

int[] ids = new int[count];

for (int i = 0; i < count; i++) {

ids[i] = mInputDevices[i].getId();

}

return ids;

}

}

/**

public InputDevice[] getInputDevices() {

synchronized (mInputDevicesLock) {

return mInputDevices;

}

}

@Override // Binder call

public void registerInputDevicesChangedListener(IInputDevicesChangedListener listener) {

if (listener == null) {

throw new IllegalArgumentException("listener must not be null");

}

synchronized (mInputDevicesLock) {

int callingPid = Binder.getCallingPid();

if (mInputDevicesChangedListeners.get(callingPid) != null) {

throw new SecurityException("The calling process has already "

+ "registered an InputDevicesChangedListener.");

}

InputDevicesChangedListenerRecord record =

new InputDevicesChangedListenerRecord(callingPid, listener);

try {

IBinder binder = listener.asBinder();

binder.linkToDeath(record, 0);

} catch (RemoteException ex) {

// give up

throw new RuntimeException(ex);

}

mInputDevicesChangedListeners.put(callingPid, record);

}

}

private void onInputDevicesChangedListenerDied(int pid) {

synchronized (mInputDevicesLock) {

mInputDevicesChangedListeners.remove(pid);

}

}

// Must be called on handler.

private void deliverInputDevicesChanged(InputDevice[] oldInputDevices) {

// Scan for changes.

int numFullKeyboardsAdded = 0;

mTempInputDevicesChangedListenersToNotify.clear();

mTempFullKeyboards.clear();

final int numListeners;

final int[] deviceIdAndGeneration;

synchronized (mInputDevicesLock) {

if (!mInputDevicesChangedPending) {

return;

}

mInputDevicesChangedPending = false;

numListeners = mInputDevicesChangedListeners.size();

for (int i = 0; i < numListeners; i++) {

mTempInputDevicesChangedListenersToNotify.add(

mInputDevicesChangedListeners.valueAt(i));

}

final int numDevices = mInputDevices.length;

deviceIdAndGeneration = new int[numDevices * 2];

for (int i = 0; i < numDevices; i++) {

final InputDevice inputDevice = mInputDevices[i];

deviceIdAndGeneration[i * 2] = inputDevice.getId();

deviceIdAndGeneration[i * 2 + 1] = inputDevice.getGeneration();

if (!inputDevice.isVirtual() && inputDevice.isFullKeyboard()) {

if (!containsInputDeviceWithDescriptor(oldInputDevices,

inputDevice.getDescriptor())) {

mTempFullKeyboards.add(numFullKeyboardsAdded++, inputDevice);

} else {

mTempFullKeyboards.add(inputDevice);

}

}

}

}

// Notify listeners.

for (int i = 0; i < numListeners; i++) {

mTempInputDevicesChangedListenersToNotify.get(i).notifyInputDevicesChanged(

deviceIdAndGeneration);

}

mTempInputDevicesChangedListenersToNotify.clear();

// Check for missing keyboard layouts.

if (mNotificationManager != null) {

final int numFullKeyboards = mTempFullKeyboards.size();

boolean missingLayoutForExternalKeyboard = false;

boolean missingLayoutForExternalKeyboardAdded = false;

synchronized (mDataStore) {

for (int i = 0; i < numFullKeyboards; i++) {

final InputDevice inputDevice = mTempFullKeyboards.get(i);

if (mDataStore.getCurrentKeyboardLayout(inputDevice.getDescriptor()) == null) {

missingLayoutForExternalKeyboard = true;

if (i < numFullKeyboardsAdded) {

missingLayoutForExternalKeyboardAdded = true;

}

}

}

}

if (missingLayoutForExternalKeyboard) {

if (missingLayoutForExternalKeyboardAdded) {

showMissingKeyboardLayoutNotification();

}

} else if (mKeyboardLayoutNotificationShown) {

hideMissingKeyboardLayoutNotification();

}

}

mTempFullKeyboards.clear();

}

// Must be called on handler.

private void showMissingKeyboardLayoutNotification() {

if (!mKeyboardLayoutNotificationShown) {

if (mKeyboardLayoutIntent == null) {

final Intent intent = new Intent("android.settings.INPUT_METHOD_SETTINGS");

intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK

| Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED

| Intent.FLAG_ACTIVITY_CLEAR_TOP);

mKeyboardLayoutIntent = PendingIntent.getActivityAsUser(mContext, 0,

intent, 0, null, UserHandle.CURRENT);

}

Resources r = mContext.getResources();

Notification notification = new Notification.Builder(mContext)

.setContentTitle(r.getString(

R.string.select_keyboard_layout_notification_title))

.setContentText(r.getString(

R.string.select_keyboard_layout_notification_message))

.setContentIntent(mKeyboardLayoutIntent)

.setSmallIcon(R.drawable.ic_settings_language)

.setPriority(Notification.PRIORITY_LOW)

.build();

mNotificationManager.notifyAsUser(null,

R.string.select_keyboard_layout_notification_title,

notification, UserHandle.ALL);

mKeyboardLayoutNotificationShown = true;

}

}

// Must be called on handler.

private void hideMissingKeyboardLayoutNotification() {

if (mKeyboardLayoutNotificationShown) {

mKeyboardLayoutNotificationShown = false;

mNotificationManager.cancelAsUser(null,

R.string.select_keyboard_layout_notification_title,

UserHandle.ALL);

}

}

// Must be called on handler.

private void updateKeyboardLayouts() {

// Scan all input devices state for keyboard layouts that have been uninstalled.

final HashSet<String> availableKeyboardLayouts = new HashSet<String>();

visitAllKeyboardLayouts(new KeyboardLayoutVisitor() {

@Override

public void visitKeyboardLayout(Resources resources,

String descriptor, String label, String collection, int keyboardLayoutResId) {

availableKeyboardLayouts.add(descriptor);

}

});

synchronized (mDataStore) {

try {

mDataStore.removeUninstalledKeyboardLayouts(availableKeyboardLayouts);

} finally {

mDataStore.saveIfNeeded();

}

}

// Reload keyboard layouts.

reloadKeyboardLayouts();

}

private static boolean containsInputDeviceWithDescriptor(InputDevice[] inputDevices,

String descriptor) {

final int numDevices = inputDevices.length;

for (int i = 0; i < numDevices; i++) {

final InputDevice inputDevice = inputDevices[i];

if (inputDevice.getDescriptor().equals(descriptor)) {

return true;

}

}

return false;

}

@Override // Binder call

public KeyboardLayout[] getKeyboardLayouts() {

final ArrayList<KeyboardLayout> list = new ArrayList<KeyboardLayout>();

visitAllKeyboardLayouts(new KeyboardLayoutVisitor() {

@Override

public void visitKeyboardLayout(Resources resources,

String descriptor, String label, String collection, int keyboardLayoutResId) {

list.add(new KeyboardLayout(descriptor, label, collection));

}

});

return list.toArray(new KeyboardLayout[list.size()]);

}

@Override // Binder call

public KeyboardLayout getKeyboardLayout(String keyboardLayoutDescriptor) {

if (keyboardLayoutDescriptor == null) {

throw new IllegalArgumentException("keyboardLayoutDescriptor must not be null");

}

final KeyboardLayout[] result = new KeyboardLayout[1];

visitKeyboardLayout(keyboardLayoutDescriptor, new KeyboardLayoutVisitor() {

@Override

public void visitKeyboardLayout(Resources resources,

String descriptor, String label, String collection, int keyboardLayoutResId) {

result[0] = new KeyboardLayout(descriptor, label, collection);

}

});

if (result[0] == null) {

Log.w(TAG, "Could not get keyboard layout with descriptor '"

+ keyboardLayoutDescriptor + "'.");

}

return result[0];

}

private void visitAllKeyboardLayouts(KeyboardLayoutVisitor visitor) {

final PackageManager pm = mContext.getPackageManager();

Intent intent = new Intent(InputManager.ACTION_QUERY_KEYBOARD_LAYOUTS);

for (ResolveInfo resolveInfo : pm.queryBroadcastReceivers(intent,

PackageManager.GET_META_DATA)) {

visitKeyboardLayoutsInPackage(pm, resolveInfo.activityInfo, null, visitor);

}

}

private void visitKeyboardLayout(String keyboardLayoutDescriptor,

KeyboardLayoutVisitor visitor) {

KeyboardLayoutDescriptor d = KeyboardLayoutDescriptor.parse(keyboardLayoutDescriptor);

if (d != null) {

final PackageManager pm = mContext.getPackageManager();

try {

ActivityInfo receiver = pm.getReceiverInfo(

new ComponentName(d.packageName, d.receiverName),

PackageManager.GET_META_DATA);

visitKeyboardLayoutsInPackage(pm, receiver, d.keyboardLayoutName, visitor);

} catch (NameNotFoundException ex) {

}

}

}

private void visitKeyboardLayoutsInPackage(PackageManager pm, ActivityInfo receiver,

String keyboardName, KeyboardLayoutVisitor visitor) {

Bundle metaData = receiver.metaData;

if (metaData == null) {

return;

}

int configResId = metaData.getInt(InputManager.META_DATA_KEYBOARD_LAYOUTS);

if (configResId == 0) {

Log.w(TAG, "Missing meta-data '" + InputManager.META_DATA_KEYBOARD_LAYOUTS

+ "' on receiver " + receiver.packageName + "/" + receiver.name);

return;

}

CharSequence receiverLabel = receiver.loadLabel(pm);

String collection = receiverLabel != null ? receiverLabel.toString() : "";

try {

Resources resources = pm.getResourcesForApplication(receiver.applicationInfo);

XmlResourceParser parser = resources.getXml(configResId);

try {

XmlUtils.beginDocument(parser, "keyboard-layouts");

for (;;) {

XmlUtils.nextElement(parser);

String element = parser.getName();

if (element == null) {

break;

}

if (element.equals("keyboard-layout")) {

TypedArray a = resources.obtainAttributes(

parser, com.android.internal.R.styleable.KeyboardLayout);

try {

String name = a.getString(

com.android.internal.R.styleable.KeyboardLayout_name);

String label = a.getString(

com.android.internal.R.styleable.KeyboardLayout_label);

int keyboardLayoutResId = a.getResourceId(

com.android.internal.R.styleable.KeyboardLayout_keyboardLayout,

0);

if (name == null || label == null || keyboardLayoutResId == 0) {

Log.w(TAG, "Missing required 'name', 'label' or 'keyboardLayout' "

+ "attributes in keyboard layout "

+ "resource from receiver "

+ receiver.packageName + "/" + receiver.name);

} else {

String descriptor = KeyboardLayoutDescriptor.format(

receiver.packageName, receiver.name, name);

if (keyboardName == null || name.equals(keyboardName)) {

visitor.visitKeyboardLayout(resources, descriptor,

label, collection, keyboardLayoutResId);

}

}

} finally {

a.recycle();

}

} else {

Log.w(TAG, "Skipping unrecognized element '" + element

+ "' in keyboard layout resource from receiver "

+ receiver.packageName + "/" + receiver.name);

}

}

} finally {

parser.close();

}

} catch (Exception ex) {

Log.w(TAG, "Could not parse keyboard layout resource from receiver "

+ receiver.packageName + "/" + receiver.name, ex);

}

}

@Override // Binder call

public String getCurrentKeyboardLayoutForInputDevice(String inputDeviceDescriptor) {

if (inputDeviceDescriptor == null) {

throw new IllegalArgumentException("inputDeviceDescriptor must not be null");

}

synchronized (mDataStore) {

return mDataStore.getCurrentKeyboardLayout(inputDeviceDescriptor);

}

}

@Override // Binder call

public void setCurrentKeyboardLayoutForInputDevice(String inputDeviceDescriptor,

String keyboardLayoutDescriptor) {

if (!checkCallingPermission(android.Manifest.permission.SET_KEYBOARD_LAYOUT,

"setCurrentKeyboardLayoutForInputDevice()")) {

throw new SecurityException("Requires SET_KEYBOARD_LAYOUT permission");

}

if (inputDeviceDescriptor == null) {

throw new IllegalArgumentException("inputDeviceDescriptor must not be null");

}

if (keyboardLayoutDescriptor == null) {

throw new IllegalArgumentException("keyboardLayoutDescriptor must not be null");

}

synchronized (mDataStore) {

try {

if (mDataStore.setCurrentKeyboardLayout(

inputDeviceDescriptor, keyboardLayoutDescriptor)) {

mHandler.sendEmptyMessage(MSG_RELOAD_KEYBOARD_LAYOUTS);

}

} finally {

mDataStore.saveIfNeeded();

}

}

}

@Override // Binder call

public String[] getKeyboardLayoutsForInputDevice(String inputDeviceDescriptor) {

if (inputDeviceDescriptor == null) {

throw new IllegalArgumentException("inputDeviceDescriptor must not be null");

}

synchronized (mDataStore) {

return mDataStore.getKeyboardLayouts(inputDeviceDescriptor);

}

}

@Override // Binder call

public void addKeyboardLayoutForInputDevice(String inputDeviceDescriptor,

String keyboardLayoutDescriptor) {

if (!checkCallingPermission(android.Manifest.permission.SET_KEYBOARD_LAYOUT,

"addKeyboardLayoutForInputDevice()")) {

throw new SecurityException("Requires SET_KEYBOARD_LAYOUT permission");

}

if (inputDeviceDescriptor == null) {

throw new IllegalArgumentException("inputDeviceDescriptor must not be null");

}

if (keyboardLayoutDescriptor == null) {

throw new IllegalArgumentException("keyboardLayoutDescriptor must not be null");

}

synchronized (mDataStore) {

try {

String oldLayout = mDataStore.getCurrentKeyboardLayout(inputDeviceDescriptor);

if (mDataStore.addKeyboardLayout(inputDeviceDescriptor, keyboardLayoutDescriptor)

&& !Objects.equal(oldLayout,

mDataStore.getCurrentKeyboardLayout(inputDeviceDescriptor))) {

mHandler.sendEmptyMessage(MSG_RELOAD_KEYBOARD_LAYOUTS);

}

} finally {

mDataStore.saveIfNeeded();

}

}

}

@Override // Binder call

public void removeKeyboardLayoutForInputDevice(String inputDeviceDescriptor,

String keyboardLayoutDescriptor) {

if (!checkCallingPermission(android.Manifest.permission.SET_KEYBOARD_LAYOUT,

"removeKeyboardLayoutForInputDevice()")) {

throw new SecurityException("Requires SET_KEYBOARD_LAYOUT permission");

}

if (inputDeviceDescriptor == null) {

throw new IllegalArgumentException("inputDeviceDescriptor must not be null");

}

if (keyboardLayoutDescriptor == null) {

throw new IllegalArgumentException("keyboardLayoutDescriptor must not be null");

}

synchronized (mDataStore) {

try {

String oldLayout = mDataStore.getCurrentKeyboardLayout(inputDeviceDescriptor);

if (mDataStore.removeKeyboardLayout(inputDeviceDescriptor,

keyboardLayoutDescriptor)

&& !Objects.equal(oldLayout,

mDataStore.getCurrentKeyboardLayout(inputDeviceDescriptor))) {

mHandler.sendEmptyMessage(MSG_RELOAD_KEYBOARD_LAYOUTS);

}

} finally {

mDataStore.saveIfNeeded();

}

}

}

public void switchKeyboardLayout(int deviceId, int direction) {

mHandler.obtainMessage(MSG_SWITCH_KEYBOARD_LAYOUT, deviceId, direction).sendToTarget();