Merge "Notify applications when input devices change." (88273597) · Commits · e / os / android_frameworks_base

Android.mk

+1 −0

Original line number	Diff line number	Diff line
		@@ -111,6 +111,7 @@ LOCAL_SRC_FILES += \
		core/java/android/database/IContentObserver.aidl \
		core/java/android/hardware/ISerialManager.aidl \
		core/java/android/hardware/input/IInputManager.aidl \
		core/java/android/hardware/input/IInputDevicesChangedListener.aidl \
		core/java/android/hardware/usb/IUsbManager.aidl \
		core/java/android/net/IConnectivityManager.aidl \
		core/java/android/net/INetworkManagementEventObserver.aidl \

api/current.txt

+10 −0

Original line number	Diff line number	Diff line
		@@ -9822,10 +9822,20 @@ package android.hardware {
		package android.hardware.input {

		public final class InputManager {
		method public android.view.InputDevice getInputDevice(int);
		method public int[] getInputDeviceIds();
		method public void registerInputDeviceListener(android.hardware.input.InputManager.InputDeviceListener, android.os.Handler);
		method public void unregisterInputDeviceListener(android.hardware.input.InputManager.InputDeviceListener);
		field public static final java.lang.String ACTION_QUERY_KEYBOARD_LAYOUTS = "android.hardware.input.action.QUERY_KEYBOARD_LAYOUTS";
		field public static final java.lang.String META_DATA_KEYBOARD_LAYOUTS = "android.hardware.input.metadata.KEYBOARD_LAYOUTS";
		}

		public static abstract interface InputManager.InputDeviceListener {
		method public abstract void onInputDeviceAdded(int);
		method public abstract void onInputDeviceChanged(int);
		method public abstract void onInputDeviceRemoved(int);
		}

		}

		package android.hardware.usb {

core/java/android/hardware/input/IInputDevicesChangedListener.aidl

0 → 100644

+29 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2012 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 android.hardware.input;

		/** @hide */
		interface IInputDevicesChangedListener {
		/* Called when input devices changed, such as a device being added,
		* removed or changing configuration.
		*
		* The parameter is an array of pairs (deviceId, generation) indicating the current
		* device id and generation of all input devices. The client can determine what
		* has happened by comparing the result to its prior observations.
		*/
		oneway void onInputDevicesChanged(in int[] deviceIdAndGeneration);
		}

core/java/android/hardware/input/IInputManager.aidl

+4 −0

Original line number	Diff line number	Diff line
		@@ -17,6 +17,7 @@
		package android.hardware.input;

		import android.hardware.input.KeyboardLayout;
		import android.hardware.input.IInputDevicesChangedListener;
		import android.view.InputDevice;
		import android.view.InputEvent;

		@@ -42,4 +43,7 @@ interface IInputManager {
		String getKeyboardLayoutForInputDevice(String inputDeviceDescriptor);
		void setKeyboardLayoutForInputDevice(String inputDeviceDescriptor,
		String keyboardLayoutDescriptor);

		// Registers an input devices changed listener.
		void registerInputDevicesChangedListener(IInputDevicesChangedListener listener);
		}

core/java/android/hardware/input/InputManager.java

+261 −45

Original line number	Diff line number	Diff line
		@@ -19,7 +19,10 @@ package android.hardware.input;
		import android.annotation.SdkConstant;
		import android.annotation.SdkConstant.SdkConstantType;
		import android.content.Context;
		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.provider.Settings;
		@@ -29,6 +32,8 @@ import android.util.SparseArray;
		import android.view.InputDevice;
		import android.view.InputEvent;

		import java.util.ArrayList;

		/**
		* Provides information about input devices and available key layouts.
		* <p>
		@@ -40,11 +45,22 @@ import android.view.InputEvent;
		*/
		public final class InputManager {
		private static final String TAG = "InputManager";
		private static final boolean DEBUG = false;

		private static final int MSG_DEVICE_ADDED = 1;
		private static final int MSG_DEVICE_REMOVED = 2;
		private static final int MSG_DEVICE_CHANGED = 3;

		private static InputManager sInstance;

		private final IInputManager mIm;
		private final SparseArray<InputDevice> mInputDevices = new SparseArray<InputDevice>();

		// Guarded by mInputDevicesLock
		private final Object mInputDevicesLock = new Object();
		private SparseArray<InputDevice> mInputDevices;
		private InputDevicesChangedListener mInputDevicesChangedListener;
		private final ArrayList<InputDeviceListenerDelegate> mInputDeviceListeners =
		new ArrayList<InputDeviceListenerDelegate>();

		/**
		* Broadcast Action: Query available keyboard layouts.
		@@ -168,6 +184,103 @@ public final class InputManager {
		}
		}

		/**
		* Gets information about the input device with the specified id.
		* @param id The device id.
		* @return The input device or null if not found.
		*/
		public InputDevice getInputDevice(int id) {
		synchronized (mInputDevicesLock) {
		populateInputDevicesLocked();

		int index = mInputDevices.indexOfKey(id);
		if (index < 0) {
		return null;
		}

		InputDevice inputDevice = mInputDevices.valueAt(index);
		if (inputDevice == null) {
		try {
		inputDevice = mIm.getInputDevice(id);
		} catch (RemoteException ex) {
		throw new RuntimeException("Could not get input device information.", ex);
		}
		}
		mInputDevices.setValueAt(index, inputDevice);
		return inputDevice;
		}
		}

		/**
		* Gets the ids of all input devices in the system.
		* @return The input device ids.
		*/
		public int[] getInputDeviceIds() {
		synchronized (mInputDevicesLock) {
		populateInputDevicesLocked();

		final int count = mInputDevices.size();
		final int[] ids = new int[count];
		for (int i = 0; i < count; i++) {
		ids[i] = mInputDevices.keyAt(i);
		}
		return ids;
		}
		}

		/**
		* Registers an input device listener to receive notifications about when
		* input devices are added, removed or changed.
		*
		* @param listener The listener to register.
		* @param handler The handler on which the listener should be invoked, or null
		* if the listener should be invoked on the calling thread's looper.
		*
		* @see #unregisterInputDeviceListener
		*/
		public void registerInputDeviceListener(InputDeviceListener listener, Handler handler) {
		if (listener == null) {
		throw new IllegalArgumentException("listener must not be null");
		}

		synchronized (mInputDevicesLock) {
		int index = findInputDeviceListenerLocked(listener);
		if (index < 0) {
		mInputDeviceListeners.add(new InputDeviceListenerDelegate(listener, handler));
		}
		}
		}

		/**
		* Unregisters an input device listener.
		*
		* @param listener The listener to unregister.
		*
		* @see #registerInputDeviceListener
		*/
		public void unregisterInputDeviceListener(InputDeviceListener listener) {
		if (listener == null) {
		throw new IllegalArgumentException("listener must not be null");
		}

		synchronized (mInputDevicesLock) {
		int index = findInputDeviceListenerLocked(listener);
		if (index >= 0) {
		mInputDeviceListeners.remove(index);
		}
		}
		}

		private int findInputDeviceListenerLocked(InputDeviceListener listener) {
		final int numListeners = mInputDeviceListeners.size();
		for (int i = 0; i < numListeners; i++) {
		if (mInputDeviceListeners.get(i).mListener == listener) {
		return i;
		}
		}
		return -1;
		}

		/**
		* Gets information about all supported keyboard layouts.
		* <p>
		@@ -326,50 +439,6 @@ public final class InputManager {
		}
		}

		/**
		* Gets information about the input device with the specified id.
		* @param id The device id.
		* @return The input device or null if not found.
		*
		* @hide
		*/
		public InputDevice getInputDevice(int id) {
		synchronized (mInputDevices) {
		InputDevice inputDevice = mInputDevices.get(id);
		if (inputDevice != null) {
		return inputDevice;
		}
		}
		final InputDevice newInputDevice;
		try {
		newInputDevice = mIm.getInputDevice(id);
		} catch (RemoteException ex) {
		throw new RuntimeException("Could not get input device information.", ex);
		}
		synchronized (mInputDevices) {
		InputDevice inputDevice = mInputDevices.get(id);
		if (inputDevice != null) {
		return inputDevice;
		}
		mInputDevices.put(id, newInputDevice);
		return newInputDevice;
		}
		}

		/**
		* Gets the ids of all input devices in the system.
		* @return The input device ids.
		*
		* @hide
		*/
		public int[] getInputDeviceIds() {
		try {
		return mIm.getInputDeviceIds();
		} catch (RemoteException ex) {
		throw new RuntimeException("Could not get input device ids.", ex);
		}
		}

		/**
		* Queries the framework about whether any physical keys exist on the
		* any keyboard attached to the device that are capable of producing the given
		@@ -429,4 +498,151 @@ public final class InputManager {
		return false;
		}
		}

		private void populateInputDevicesLocked() {
		if (mInputDevicesChangedListener == null) {
		final InputDevicesChangedListener listener = new InputDevicesChangedListener();
		try {
		mIm.registerInputDevicesChangedListener(listener);
		} catch (RemoteException ex) {
		throw new RuntimeException(
		"Could not get register input device changed listener", ex);
		}
		mInputDevicesChangedListener = listener;
		}

		if (mInputDevices == null) {
		final int[] ids;
		try {
		ids = mIm.getInputDeviceIds();
		} catch (RemoteException ex) {
		throw new RuntimeException("Could not get input device ids.", ex);
		}

		mInputDevices = new SparseArray<InputDevice>();
		for (int i = 0; i < ids.length; i++) {
		mInputDevices.put(ids[i], null);
		}
		}
		}

		private void onInputDevicesChanged(int[] deviceIdAndGeneration) {
		if (DEBUG) {
		Log.d(TAG, "Received input devices changed.");
		}

		synchronized (mInputDevicesLock) {
		for (int i = mInputDevices.size(); --i > 0; ) {
		final int deviceId = mInputDevices.keyAt(i);
		if (!containsDeviceId(deviceIdAndGeneration, deviceId)) {
		if (DEBUG) {
		Log.d(TAG, "Device removed: " + deviceId);
		}
		mInputDevices.removeAt(i);
		sendMessageToInputDeviceListenersLocked(MSG_DEVICE_REMOVED, deviceId);
		}
		}

		for (int i = 0; i < deviceIdAndGeneration.length; i += 2) {
		final int deviceId = deviceIdAndGeneration[i];
		int index = mInputDevices.indexOfKey(deviceId);
		if (index >= 0) {
		final InputDevice device = mInputDevices.valueAt(index);
		if (device != null) {
		final int generation = deviceIdAndGeneration[i + 1];
		if (device.getGeneration() != generation) {
		if (DEBUG) {
		Log.d(TAG, "Device changed: " + deviceId);
		}
		mInputDevices.setValueAt(index, null);
		sendMessageToInputDeviceListenersLocked(MSG_DEVICE_CHANGED, deviceId);
		}
		}
		} else {
		if (DEBUG) {
		Log.d(TAG, "Device added: " + deviceId);
		}
		mInputDevices.put(deviceId, null);
		sendMessageToInputDeviceListenersLocked(MSG_DEVICE_ADDED, deviceId);
		}
		}
		}
		}

		private void sendMessageToInputDeviceListenersLocked(int what, int deviceId) {
		final int numListeners = mInputDeviceListeners.size();
		for (int i = 0; i < numListeners; i++) {
		InputDeviceListenerDelegate listener = mInputDeviceListeners.get(i);
		listener.sendMessage(listener.obtainMessage(what, deviceId, 0));
		}
		}

		private static boolean containsDeviceId(int[] deviceIdAndGeneration, int deviceId) {
		for (int i = 0; i < deviceIdAndGeneration.length; i += 2) {
		if (deviceIdAndGeneration[i] == deviceId) {
		return true;
		}
		}
		return false;
		}

		/**
		* Listens for changes in input devices.
		*/
		public interface InputDeviceListener {
		/**
		* Called whenever an input device has been added to the system.
		* Use {@link InputManager#getInputDevice} to get more information about the device.
		*
		* @param deviceId The id of the input device that was added.
		*/
		void onInputDeviceAdded(int deviceId);

		/**
		* Called whenever an input device has been removed from the system.
		*
		* @param deviceId The id of the input device that was removed.
		*/
		void onInputDeviceRemoved(int deviceId);

		/**
		* Called whenever the properties of an input device have changed since they
		* were last queried. Use {@link InputManager#getInputDevice} to get
		* a fresh {@link InputDevice} object with the new properties.
		*
		* @param deviceId The id of the input device that changed.
		*/
		void onInputDeviceChanged(int deviceId);
		}

		private final class InputDevicesChangedListener extends IInputDevicesChangedListener.Stub {
		@Override
		public void onInputDevicesChanged(int[] deviceIdAndGeneration) throws RemoteException {
		InputManager.this.onInputDevicesChanged(deviceIdAndGeneration);
		}
		}

		private static final class InputDeviceListenerDelegate extends Handler {
		public final InputDeviceListener mListener;

		public InputDeviceListenerDelegate(InputDeviceListener listener, Handler handler) {
		super(handler != null ? handler.getLooper() : Looper.myLooper());
		mListener = listener;
		}

		@Override
		public void handleMessage(Message msg) {
		switch (msg.what) {
		case MSG_DEVICE_ADDED:
		mListener.onInputDeviceAdded(msg.arg1);
		break;
		case MSG_DEVICE_REMOVED:
		mListener.onInputDeviceRemoved(msg.arg1);
		break;
		case MSG_DEVICE_CHANGED:
		mListener.onInputDeviceChanged(msg.arg1);
		break;
		}
		}
		}
		}