Merge "Improve support for external keyboards." (80cdb941) · Commits · e / os / android_frameworks_native-old

include/ui/EventHub.h

+65 −55

Original line number	Diff line number	Diff line
		@@ -18,8 +18,11 @@
		#ifndef _RUNTIME_EVENT_HUB_H
		#define _RUNTIME_EVENT_HUB_H

		#include <android/input.h>
		#include <ui/Input.h>
		#include <ui/Keyboard.h>
		#include <ui/KeyLayoutMap.h>
		#include <ui/KeyCharacterMap.h>
		#include <ui/VirtualKeyMap.h>
		#include <utils/String8.h>
		#include <utils/threads.h>
		#include <utils/Log.h>
		@@ -27,6 +30,7 @@
		#include <utils/List.h>
		#include <utils/Errors.h>
		#include <utils/PropertyMap.h>
		#include <utils/Vector.h>

		#include <linux/input.h>

		@@ -59,8 +63,6 @@ struct pollfd;

		namespace android {

		class KeyLayoutMap;

		/*
		* A raw event as retrieved from the EventHub.
		*/
		@@ -194,6 +196,9 @@ public:
		virtual bool hasLed(int32_t deviceId, int32_t led) const = 0;
		virtual void setLedState(int32_t deviceId, int32_t led, bool on) = 0;

		virtual void getVirtualKeyDefinitions(int32_t deviceId,
		Vector<VirtualKeyDefinition>& outVirtualKeys) const = 0;

		virtual void dump(String8& dump) = 0;
		};

		@@ -230,6 +235,9 @@ public:
		virtual bool hasLed(int32_t deviceId, int32_t led) const;
		virtual void setLedState(int32_t deviceId, int32_t led, bool on);

		virtual void getVirtualKeyDefinitions(int32_t deviceId,
		Vector<VirtualKeyDefinition>& outVirtualKeys) const;

		virtual void dump(String8& dump);

		protected:
		@@ -238,63 +246,65 @@ protected:
		private:
		bool openPlatformInput(void);

		int openDevice(const char *device);
		int closeDevice(const char *device);
		int openDevice(const char *devicePath);
		int closeDevice(const char *devicePath);
		int scanDir(const char *dirname);
		int readNotify(int nfd);

		status_t mError;

		struct device_t {
		struct Device {
		Device* next;

		int fd;
		const int32_t id;
		const String8 path;
		String8 name;
		const InputDeviceIdentifier identifier;

		uint32_t classes;
		uint8_t* keyBitmask;
		KeyLayoutMap* layoutMap;
		String8 configurationFile;
		PropertyMap* configuration;
		KeyMapInfo keyMapInfo;
		int fd;
		device_t* next;
		VirtualKeyMap* virtualKeyMap;
		KeyMap keyMap;

		device_t(int32_t _id, const char* _path, const char* name);
		~device_t();
		Device(int fd, int32_t id, const String8& path, const InputDeviceIdentifier& identifier);
		~Device();

		void close();
		};

		device_t* getDeviceLocked(int32_t deviceId) const;
		bool hasKeycodeLocked(device_t* device, int keycode) const;
		Device* getDeviceLocked(int32_t deviceId) const;
		bool hasKeycodeLocked(Device* device, int keycode) const;

		int32_t getScanCodeStateLocked(device_t* device, int32_t scanCode) const;
		int32_t getKeyCodeStateLocked(device_t* device, int32_t keyCode) const;
		int32_t getSwitchStateLocked(device_t* device, int32_t sw) const;
		bool markSupportedKeyCodesLocked(device_t* device, size_t numCodes,
		int32_t getScanCodeStateLocked(Device* device, int32_t scanCode) const;
		int32_t getKeyCodeStateLocked(Device* device, int32_t keyCode) const;
		int32_t getSwitchStateLocked(Device* device, int32_t sw) const;
		bool markSupportedKeyCodesLocked(Device* device, size_t numCodes,
		const int32_t* keyCodes, uint8_t* outFlags) const;

		void loadConfiguration(device_t* device);
		void configureKeyMap(device_t* device);
		void setKeyboardProperties(device_t* device, bool firstKeyboard);
		void clearKeyboardProperties(device_t* device, bool firstKeyboard);
		void loadConfiguration(Device* device);
		status_t loadVirtualKeyMap(Device* device);
		status_t loadKeyMap(Device* device);
		void setKeyboardProperties(Device* device, bool builtInKeyboard);
		void clearKeyboardProperties(Device* device, bool builtInKeyboard);

		// Protect all internal state.
		mutable Mutex mLock;

		bool mHaveFirstKeyboard;
		int32_t mFirstKeyboardId; // the API is that the built-in keyboard is id 0, so map it
		// The actual id of the built-in keyboard, or -1 if none.
		// EventHub remaps the built-in keyboard to id 0 externally as required by the API.
		int32_t mBuiltInKeyboardId;

		struct device_ent {
		device_t* device;
		uint32_t seq;
		};
		device_ent *mDevicesById;
		int mNumDevicesById;
		int32_t mNextDeviceId;

		device_t *mOpeningDevices;
		device_t *mClosingDevices;
		// Parallel arrays of fds and devices.
		// First index is reserved for inotify.
		Vector<struct pollfd> mFds;
		Vector<Device*> mDevices;

		device_t **mDevices;
		struct pollfd *mFDs;
		int mFDCount;
		Device *mOpeningDevices;
		Device *mClosingDevices;

		bool mOpened;
		bool mNeedToSendFinishedDeviceScan;
		@@ -307,9 +317,9 @@ private:

		static const int INPUT_BUFFER_SIZE = 64;
		struct input_event mInputBufferData[INPUT_BUFFER_SIZE];
		int32_t mInputBufferIndex;
		int32_t mInputBufferCount;
		int32_t mInputDeviceIndex;
		size_t mInputBufferIndex;
		size_t mInputBufferCount;
		size_t mInputFdIndex;
		};

		}; // namespace android

include/ui/Input.h

+35 −3

Original line number	Diff line number	Diff line
		@@ -497,6 +497,23 @@ private:
		KeyedVector<int32_t, MotionRange> mMotionRanges;
		};

		/*
		* Identifies a device.
		*/
		struct InputDeviceIdentifier {
		inline InputDeviceIdentifier() :
		bus(0), vendor(0), product(0), version(0) {
		}

		String8 name;
		String8 location;
		String8 uniqueId;
		uint16_t bus;
		uint16_t vendor;
		uint16_t product;
		uint16_t version;
		};

		/* Types of input device configuration files. */
		enum InputDeviceConfigurationFileType {
		INPUT_DEVICE_CONFIGURATION_FILE_TYPE_CONFIGURATION = 0, /* .idc file */
		@@ -505,13 +522,28 @@ enum InputDeviceConfigurationFileType {
		};

		/*
		* Get the path of an input device configuration file, if one is available.
		* Spaces in the name are replaced with underscores.
		* Gets the path of an input device configuration file, if one is available.
		* Considers both system provided and user installed configuration files.
		*
		* The device identifier is used to construct several default configuration file
		* names to try based on the device name, vendor, product, and version.
		*
		* Returns an empty string if not found.
		*/
		extern String8 getInputDeviceConfigurationFilePathByDeviceIdentifier(
		const InputDeviceIdentifier& deviceIdentifier,
		InputDeviceConfigurationFileType type);

		/*
		* Gets the path of an input device configuration file, if one is available.
		* Considers both system provided and user installed configuration files.
		*
		* The name is case-sensitive and is used to construct the filename to resolve.
		* All characters except 'a'-'z', 'A'-'Z', '0'-'9', '-', and '_' are replaced by underscores.
		*
		* Returns an empty string if not found.
		*/
		extern String8 getInputDeviceConfigurationFilePath(
		extern String8 getInputDeviceConfigurationFilePathByName(
		const String8& name, InputDeviceConfigurationFileType type);

		} // namespace android

include/ui/InputReader.h

+0 −15

Original line number	Diff line number	Diff line
		@@ -35,17 +35,6 @@ namespace android {
		class InputDevice;
		class InputMapper;

		/* Describes a virtual key. */
		struct VirtualKeyDefinition {
		int32_t scanCode;

		// configured position data, specified in display coords
		int32_t centerX;
		int32_t centerY;
		int32_t width;
		int32_t height;
		};


		/*
		* Input reader policy interface.
		@@ -86,10 +75,6 @@ public:
		*/
		virtual bool filterJumpyTouchEvents() = 0;

		/* Gets the configured virtual key definitions for an input device. */
		virtual void getVirtualKeyDefinitions(const String8& deviceName,
		Vector<VirtualKeyDefinition>& outVirtualKeyDefinitions) = 0;

		/* Gets the excluded device names for the platform. */
		virtual void getExcludedDeviceNames(Vector<String8>& outExcludedDeviceNames) = 0;
		};

include/ui/Keyboard.h

+38 −10

Original line number	Diff line number	Diff line
		@@ -33,30 +33,58 @@ enum {
		DEVICE_ID_VIRTUAL_KEYBOARD = -1,
		};

		struct KeyMapInfo {
		class KeyLayoutMap;
		class KeyCharacterMap;

		/**
		* Loads the key layout map and key character map for a keyboard device.
		*/
		class KeyMap {
		public:
		String8 keyLayoutFile;
		KeyLayoutMap* keyLayoutMap;

		String8 keyCharacterMapFile;
		bool isDefaultKeyMap;
		KeyCharacterMap* keyCharacterMap;

		KeyMap();
		~KeyMap();

		KeyMapInfo() : isDefaultKeyMap(false) {
		status_t load(const InputDeviceIdentifier& deviceIdenfier,
		const PropertyMap* deviceConfiguration);

		inline bool haveKeyLayout() const {
		return !keyLayoutFile.isEmpty();
		}

		inline bool haveKeyCharacterMap() const {
		return !keyCharacterMapFile.isEmpty();
		}

		bool isComplete() {
		return !keyLayoutFile.isEmpty() && !keyCharacterMapFile.isEmpty();
		inline bool isComplete() const {
		return haveKeyLayout() && haveKeyCharacterMap();
		}

		private:
		bool probeKeyMap(const InputDeviceIdentifier& deviceIdentifier, const String8& name);
		status_t loadKeyLayout(const InputDeviceIdentifier& deviceIdentifier, const String8& name);
		status_t loadKeyCharacterMap(const InputDeviceIdentifier& deviceIdentifier,
		const String8& name);
		String8 getPath(const InputDeviceIdentifier& deviceIdentifier,
		const String8& name, InputDeviceConfigurationFileType type);
		};

		/**
		* Resolves the key map to use for a particular keyboard device.
		* Returns true if the keyboard is eligible for use as a built-in keyboard.
		*/
		extern status_t resolveKeyMap(const String8& deviceName,
		const PropertyMap* deviceConfiguration, KeyMapInfo& outKeyMapInfo);
		extern bool isEligibleBuiltInKeyboard(const InputDeviceIdentifier& deviceIdentifier,
		const PropertyMap* deviceConfiguration, const KeyMap* keyMap);

		/**
		* Sets keyboard system properties.
		*/
		extern void setKeyboardProperties(int32_t deviceId, const String8& deviceName,
		const KeyMapInfo& keyMapInfo);
		extern void setKeyboardProperties(int32_t deviceId, const InputDeviceIdentifier& deviceIdentifier,
		const String8& keyLayoutFile, const String8& keyCharacterMapFile);

		/**
		* Clears keyboard system properties.

include/ui/VirtualKeyMap.h

0 → 100644

+79 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2010 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.
		*/

		#ifndef _UI_VIRTUAL_KEY_MAP_H
		#define _UI_VIRTUAL_KEY_MAP_H

		#include <stdint.h>

		#include <ui/Input.h>
		#include <utils/Errors.h>
		#include <utils/KeyedVector.h>
		#include <utils/Tokenizer.h>
		#include <utils/String8.h>
		#include <utils/Unicode.h>

		namespace android {

		/* Describes a virtual key. */
		struct VirtualKeyDefinition {
		int32_t scanCode;

		// configured position data, specified in display coords
		int32_t centerX;
		int32_t centerY;
		int32_t width;
		int32_t height;
		};


		/**
		* Describes a collection of virtual keys on a touch screen in terms of
		* virtual scan codes and hit rectangles.
		*/
		class VirtualKeyMap {
		public:
		~VirtualKeyMap();

		static status_t load(const String8& filename, VirtualKeyMap** outMap);

		inline const Vector<VirtualKeyDefinition>& getVirtualKeys() const {
		return mVirtualKeys;
		}

		private:
		class Parser {
		VirtualKeyMap* mMap;
		Tokenizer* mTokenizer;

		public:
		Parser(VirtualKeyMap* map, Tokenizer* tokenizer);
		~Parser();
		status_t parse();

		private:
		bool consumeFieldDelimiterAndSkipWhitespace();
		bool parseNextIntField(int32_t* outValue);
		};

		Vector<VirtualKeyDefinition> mVirtualKeys;

		VirtualKeyMap();
		};

		} // namespace android

		#endif // _UI_KEY_CHARACTER_MAP_H