Merge "frameworks/base refactoring." (11b79e14) · Commits · e / os / android_frameworks_native

include/ui/Input.h

deleted100644 → 0

+0 −897

File deleted.

Preview size limit exceeded, changes collapsed.

include/ui/InputTransport.h

deleted100644 → 0

+0 −335

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_INPUT_TRANSPORT_H
		#define _UI_INPUT_TRANSPORT_H

		/**
		* Native input transport.
		*
		* The InputChannel provides a mechanism for exchanging InputMessage structures across processes.
		*
		* The InputPublisher and InputConsumer each handle one end-point of an input channel.
		* The InputPublisher is used by the input dispatcher to send events to the application.
		* The InputConsumer is used by the application to receive events from the input dispatcher.
		*/

		#include <ui/Input.h>
		#include <utils/Errors.h>
		#include <utils/Timers.h>
		#include <utils/RefBase.h>
		#include <utils/String8.h>

		namespace android {

		/*
		* Intermediate representation used to send input events and related signals.
		*/
		struct InputMessage {
		enum {
		TYPE_KEY = 1,
		TYPE_MOTION = 2,
		TYPE_FINISHED = 3,
		};

		struct Header {
		uint32_t type;
		uint32_t padding; // 8 byte alignment for the body that follows
		} header;

		union Body {
		struct Key {
		uint32_t seq;
		nsecs_t eventTime;
		int32_t deviceId;
		int32_t source;
		int32_t action;
		int32_t flags;
		int32_t keyCode;
		int32_t scanCode;
		int32_t metaState;
		int32_t repeatCount;
		nsecs_t downTime;

		inline size_t size() const {
		return sizeof(Key);
		}
		} key;

		struct Motion {
		uint32_t seq;
		nsecs_t eventTime;
		int32_t deviceId;
		int32_t source;
		int32_t action;
		int32_t flags;
		int32_t metaState;
		int32_t buttonState;
		int32_t edgeFlags;
		nsecs_t downTime;
		float xOffset;
		float yOffset;
		float xPrecision;
		float yPrecision;
		size_t pointerCount;
		struct Pointer {
		PointerProperties properties;
		PointerCoords coords;
		} pointers[MAX_POINTERS];

		inline size_t size() const {
		return sizeof(Motion) - sizeof(Pointer) * MAX_POINTERS
		+ sizeof(Pointer) * pointerCount;
		}
		} motion;

		struct Finished {
		uint32_t seq;
		bool handled;

		inline size_t size() const {
		return sizeof(Finished);
		}
		} finished;
		} body;

		bool isValid(size_t actualSize) const;
		size_t size() const;
		};

		/*
		* An input channel consists of a local unix domain socket used to send and receive
		* input messages across processes. Each channel has a descriptive name for debugging purposes.
		*
		* Each endpoint has its own InputChannel object that specifies its file descriptor.
		*
		* The input channel is closed when all references to it are released.
		*/
		class InputChannel : public RefBase {
		protected:
		virtual ~InputChannel();

		public:
		InputChannel(const String8& name, int fd);

		/* Creates a pair of input channels.
		*
		* Returns OK on success.
		*/
		static status_t openInputChannelPair(const String8& name,
		sp<InputChannel>& outServerChannel, sp<InputChannel>& outClientChannel);

		inline String8 getName() const { return mName; }
		inline int getFd() const { return mFd; }

		/* Sends a message to the other endpoint.
		*
		* If the channel is full then the message is guaranteed not to have been sent at all.
		* Try again after the consumer has sent a finished signal indicating that it has
		* consumed some of the pending messages from the channel.
		*
		* Returns OK on success.
		* Returns WOULD_BLOCK if the channel is full.
		* Returns DEAD_OBJECT if the channel's peer has been closed.
		* Other errors probably indicate that the channel is broken.
		*/
		status_t sendMessage(const InputMessage* msg);

		/* Receives a message sent by the other endpoint.
		*
		* If there is no message present, try again after poll() indicates that the fd
		* is readable.
		*
		* Returns OK on success.
		* Returns WOULD_BLOCK if there is no message present.
		* Returns DEAD_OBJECT if the channel's peer has been closed.
		* Other errors probably indicate that the channel is broken.
		*/
		status_t receiveMessage(InputMessage* msg);

		private:
		String8 mName;
		int mFd;
		};

		/*
		* Publishes input events to an input channel.
		*/
		class InputPublisher {
		public:
		/* Creates a publisher associated with an input channel. */
		explicit InputPublisher(const sp<InputChannel>& channel);

		/* Destroys the publisher and releases its input channel. */
		~InputPublisher();

		/* Gets the underlying input channel. */
		inline sp<InputChannel> getChannel() { return mChannel; }

		/* Publishes a key event to the input channel.
		*
		* Returns OK on success.
		* Returns WOULD_BLOCK if the channel is full.
		* Returns DEAD_OBJECT if the channel's peer has been closed.
		* Returns BAD_VALUE if seq is 0.
		* Other errors probably indicate that the channel is broken.
		*/
		status_t publishKeyEvent(
		uint32_t seq,
		int32_t deviceId,
		int32_t source,
		int32_t action,
		int32_t flags,
		int32_t keyCode,
		int32_t scanCode,
		int32_t metaState,
		int32_t repeatCount,
		nsecs_t downTime,
		nsecs_t eventTime);

		/* Publishes a motion event to the input channel.
		*
		* Returns OK on success.
		* Returns WOULD_BLOCK if the channel is full.
		* Returns DEAD_OBJECT if the channel's peer has been closed.
		* Returns BAD_VALUE if seq is 0 or if pointerCount is less than 1 or greater than MAX_POINTERS.
		* Other errors probably indicate that the channel is broken.
		*/
		status_t publishMotionEvent(
		uint32_t seq,
		int32_t deviceId,
		int32_t source,
		int32_t action,
		int32_t flags,
		int32_t edgeFlags,
		int32_t metaState,
		int32_t buttonState,
		float xOffset,
		float yOffset,
		float xPrecision,
		float yPrecision,
		nsecs_t downTime,
		nsecs_t eventTime,
		size_t pointerCount,
		const PointerProperties* pointerProperties,
		const PointerCoords* pointerCoords);

		/* Receives the finished signal from the consumer in reply to the original dispatch signal.
		* If a signal was received, returns the message sequence number,
		* and whether the consumer handled the message.
		*
		* The returned sequence number is never 0 unless the operation failed.
		*
		* Returns OK on success.
		* Returns WOULD_BLOCK if there is no signal present.
		* Returns DEAD_OBJECT if the channel's peer has been closed.
		* Other errors probably indicate that the channel is broken.
		*/
		status_t receiveFinishedSignal(uint32_t* outSeq, bool* outHandled);

		private:
		sp<InputChannel> mChannel;
		};

		/*
		* Consumes input events from an input channel.
		*/
		class InputConsumer {
		public:
		/* Creates a consumer associated with an input channel. */
		explicit InputConsumer(const sp<InputChannel>& channel);

		/* Destroys the consumer and releases its input channel. */
		~InputConsumer();

		/* Gets the underlying input channel. */
		inline sp<InputChannel> getChannel() { return mChannel; }

		/* Consumes an input event from the input channel and copies its contents into
		* an InputEvent object created using the specified factory.
		*
		* Tries to combine a series of move events into larger batches whenever possible.
		*
		* If consumeBatches is false, then defers consuming pending batched events if it
		* is possible for additional samples to be added to them later. Call hasPendingBatch()
		* to determine whether a pending batch is available to be consumed.
		*
		* If consumeBatches is true, then events are still batched but they are consumed
		* immediately as soon as the input channel is exhausted.
		*
		* The returned sequence number is never 0 unless the operation failed.
		*
		* Returns OK on success.
		* Returns WOULD_BLOCK if there is no event present.
		* Returns DEAD_OBJECT if the channel's peer has been closed.
		* Returns NO_MEMORY if the event could not be created.
		* Other errors probably indicate that the channel is broken.
		*/
		status_t consume(InputEventFactoryInterface* factory, bool consumeBatches,
		uint32_t* outSeq, InputEvent** outEvent);

		/* Sends a finished signal to the publisher to inform it that the message
		* with the specified sequence number has finished being process and whether
		* the message was handled by the consumer.
		*
		* Returns OK on success.
		* Returns BAD_VALUE if seq is 0.
		* Other errors probably indicate that the channel is broken.
		*/
		status_t sendFinishedSignal(uint32_t seq, bool handled);

		/* Returns true if there is a pending batch. */
		bool hasPendingBatch() const;

		private:
		sp<InputChannel> mChannel;

		// The current input message.
		InputMessage mMsg;

		// True if mMsg contains a valid input message that was deferred from the previous
		// call to consume and that still needs to be handled.
		bool mMsgDeferred;

		// Batched motion events per device and source.
		struct Batch {
		uint32_t seq; // sequence number of last input message batched in the event
		MotionEvent event;
		};
		Vector<Batch> mBatches;

		// Chain of batched sequence numbers. When multiple input messages are combined into
		// a batch, we append a record here that associates the last sequence number in the
		// batch with the previous one. When the finished signal is sent, we traverse the
		// chain to individually finish all input messages that were part of the batch.
		struct SeqChain {
		uint32_t seq; // sequence number of batched input message
		uint32_t chain; // sequence number of previous batched input message
		};
		Vector<SeqChain> mSeqChains;

		ssize_t findBatch(int32_t deviceId, int32_t source) const;
		status_t sendUnchainedFinishedSignal(uint32_t seq, bool handled);

		static void initializeKeyEvent(KeyEvent* event, const InputMessage* msg);
		static void initializeMotionEvent(MotionEvent* event, const InputMessage* msg);
		static bool canAppendSamples(const MotionEvent* event, const InputMessage* msg);
		static void appendSamples(MotionEvent* event, const InputMessage* msg);
		};

		} // namespace android

		#endif // _UI_INPUT_TRANSPORT_H

include/ui/KeyCharacterMap.h

deleted100644 → 0

+0 −199

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2008 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_KEY_CHARACTER_MAP_H
		#define _UI_KEY_CHARACTER_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 mapping from Android key codes to characters.
		* Also specifies other functions of the keyboard such as the keyboard type
		* and key modifier semantics.
		*/
		class KeyCharacterMap {
		public:
		enum KeyboardType {
		KEYBOARD_TYPE_UNKNOWN = 0,
		KEYBOARD_TYPE_NUMERIC = 1,
		KEYBOARD_TYPE_PREDICTIVE = 2,
		KEYBOARD_TYPE_ALPHA = 3,
		KEYBOARD_TYPE_FULL = 4,
		KEYBOARD_TYPE_SPECIAL_FUNCTION = 5,
		};

		// Substitute key code and meta state for fallback action.
		struct FallbackAction {
		int32_t keyCode;
		int32_t metaState;
		};

		~KeyCharacterMap();

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

		/* Gets the keyboard type. */
		int32_t getKeyboardType() const;

		/* Gets the primary character for this key as in the label physically printed on it.
		* Returns 0 if none (eg. for non-printing keys). */
		char16_t getDisplayLabel(int32_t keyCode) const;

		/* Gets the Unicode character for the number or symbol generated by the key
		* when the keyboard is used as a dialing pad.
		* Returns 0 if no number or symbol is generated.
		*/
		char16_t getNumber(int32_t keyCode) const;

		/* Gets the Unicode character generated by the key and meta key modifiers.
		* Returns 0 if no character is generated.
		*/
		char16_t getCharacter(int32_t keyCode, int32_t metaState) const;

		/* Gets the fallback action to use by default if the application does not
		* handle the specified key.
		* Returns true if an action was available, false if none.
		*/
		bool getFallbackAction(int32_t keyCode, int32_t metaState,
		FallbackAction* outFallbackAction) const;

		/* Gets the first matching Unicode character that can be generated by the key,
		* preferring the one with the specified meta key modifiers.
		* Returns 0 if no matching character is generated.
		*/
		char16_t getMatch(int32_t keyCode, const char16_t* chars,
		size_t numChars, int32_t metaState) const;

		/* Gets a sequence of key events that could plausibly generate the specified
		* character sequence. Returns false if some of the characters cannot be generated.
		*/
		bool getEvents(int32_t deviceId, const char16_t* chars, size_t numChars,
		Vector<KeyEvent>& outEvents) const;

		private:
		struct Behavior {
		Behavior();

		/* The next behavior in the list, or NULL if none. */
		Behavior* next;

		/* The meta key modifiers for this behavior. */
		int32_t metaState;

		/* The character to insert. */
		char16_t character;

		/* The fallback keycode if the key is not handled. */
		int32_t fallbackKeyCode;
		};

		struct Key {
		Key();
		~Key();

		/* The single character label printed on the key, or 0 if none. */
		char16_t label;

		/* The number or symbol character generated by the key, or 0 if none. */
		char16_t number;

		/* The list of key behaviors sorted from most specific to least specific
		* meta key binding. */
		Behavior* firstBehavior;
		};

		class Parser {
		enum State {
		STATE_TOP = 0,
		STATE_KEY = 1,
		};

		enum {
		PROPERTY_LABEL = 1,
		PROPERTY_NUMBER = 2,
		PROPERTY_META = 3,
		};

		struct Property {
		inline Property(int32_t property = 0, int32_t metaState = 0) :
		property(property), metaState(metaState) { }

		int32_t property;
		int32_t metaState;
		};

		KeyCharacterMap* mMap;
		Tokenizer* mTokenizer;
		State mState;
		int32_t mKeyCode;

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

		private:
		status_t parseType();
		status_t parseKey();
		status_t parseKeyProperty();
		status_t parseModifier(const String8& token, int32_t* outMetaState);
		status_t parseCharacterLiteral(char16_t* outCharacter);
		};

		KeyedVector<int32_t, Key*> mKeys;
		int mType;

		KeyCharacterMap();

		bool getKey(int32_t keyCode, const Key** outKey) const;
		bool getKeyBehavior(int32_t keyCode, int32_t metaState,
		const Key outKey, const Behavior outBehavior) const;

		bool findKey(char16_t ch, int32_t* outKeyCode, int32_t* outMetaState) const;

		static void addKey(Vector<KeyEvent>& outEvents,
		int32_t deviceId, int32_t keyCode, int32_t metaState, bool down, nsecs_t time);
		static void addMetaKeys(Vector<KeyEvent>& outEvents,
		int32_t deviceId, int32_t metaState, bool down, nsecs_t time,
		int32_t* currentMetaState);
		static bool addSingleEphemeralMetaKey(Vector<KeyEvent>& outEvents,
		int32_t deviceId, int32_t metaState, bool down, nsecs_t time,
		int32_t keyCode, int32_t keyMetaState,
		int32_t* currentMetaState);
		static void addDoubleEphemeralMetaKey(Vector<KeyEvent>& outEvents,
		int32_t deviceId, int32_t metaState, bool down, nsecs_t time,
		int32_t leftKeyCode, int32_t leftKeyMetaState,
		int32_t rightKeyCode, int32_t rightKeyMetaState,
		int32_t eitherKeyMetaState,
		int32_t* currentMetaState);
		static void addLockedMetaKey(Vector<KeyEvent>& outEvents,
		int32_t deviceId, int32_t metaState, nsecs_t time,
		int32_t keyCode, int32_t keyMetaState,
		int32_t* currentMetaState);
		};

		} // namespace android

		#endif // _UI_KEY_CHARACTER_MAP_H

include/ui/KeyLayoutMap.h

deleted100644 → 0

+0 −99

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2008 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_KEY_LAYOUT_MAP_H
		#define _UI_KEY_LAYOUT_MAP_H

		#include <stdint.h>
		#include <utils/Errors.h>
		#include <utils/KeyedVector.h>
		#include <utils/Tokenizer.h>

		namespace android {

		struct AxisInfo {
		enum Mode {
		// Axis value is reported directly.
		MODE_NORMAL = 0,
		// Axis value should be inverted before reporting.
		MODE_INVERT = 1,
		// Axis value should be split into two axes
		MODE_SPLIT = 2,
		};

		// Axis mode.
		Mode mode;

		// Axis id.
		// When split, this is the axis used for values smaller than the split position.
		int32_t axis;

		// When split, this is the axis used for values after higher than the split position.
		int32_t highAxis;

		// The split value, or 0 if not split.
		int32_t splitValue;

		// The flat value, or -1 if none.
		int32_t flatOverride;

		AxisInfo() : mode(MODE_NORMAL), axis(-1), highAxis(-1), splitValue(0), flatOverride(-1) {
		}
		};

		/**
		* Describes a mapping from keyboard scan codes and joystick axes to Android key codes and axes.
		*/
		class KeyLayoutMap {
		public:
		~KeyLayoutMap();

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

		status_t mapKey(int32_t scanCode, int32_t* keyCode, uint32_t* flags) const;
		status_t findScanCodesForKey(int32_t keyCode, Vector<int32_t>* outScanCodes) const;

		status_t mapAxis(int32_t scanCode, AxisInfo* outAxisInfo) const;

		private:
		struct Key {
		int32_t keyCode;
		uint32_t flags;
		};

		KeyedVector<int32_t, Key> mKeys;
		KeyedVector<int32_t, AxisInfo> mAxes;

		KeyLayoutMap();

		class Parser {
		KeyLayoutMap* mMap;
		Tokenizer* mTokenizer;

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

		private:
		status_t parseKey();
		status_t parseAxis();
		};
		};

		} // namespace android

		#endif // _UI_KEY_LAYOUT_MAP_H

include/ui/Keyboard.h

deleted100644 → 0

+0 −119

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_KEYBOARD_H
		#define _UI_KEYBOARD_H

		#include <ui/Input.h>
		#include <utils/Errors.h>
		#include <utils/String8.h>
		#include <utils/PropertyMap.h>

		namespace android {

		enum {
		/* Device id of the built in keyboard. */
		DEVICE_ID_BUILT_IN_KEYBOARD = 0,

		/* Device id of a generic virtual keyboard with a full layout that can be used
		* to synthesize key events. */
		DEVICE_ID_VIRTUAL_KEYBOARD = -1,
		};

		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;
		KeyCharacterMap* keyCharacterMap;

		KeyMap();
		~KeyMap();

		status_t load(const InputDeviceIdentifier& deviceIdenfier,
		const PropertyMap* deviceConfiguration);

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

		inline bool haveKeyCharacterMap() const {
		return !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);
		};

		/**
		* Returns true if the keyboard is eligible for use as a built-in keyboard.
		*/
		extern bool isEligibleBuiltInKeyboard(const InputDeviceIdentifier& deviceIdentifier,
		const PropertyMap* deviceConfiguration, const KeyMap* keyMap);

		/**
		* Gets a key code by its short form label, eg. "HOME".
		* Returns 0 if unknown.
		*/
		extern int32_t getKeyCodeByLabel(const char* label);

		/**
		* Gets a key flag by its short form label, eg. "WAKE".
		* Returns 0 if unknown.
		*/
		extern uint32_t getKeyFlagByLabel(const char* label);

		/**
		* Gets a axis by its short form label, eg. "X".
		* Returns -1 if unknown.
		*/
		extern int32_t getAxisByLabel(const char* label);

		/**
		* Gets a axis label by its id.
		* Returns NULL if unknown.
		*/
		extern const char* getAxisLabel(int32_t axisId);

		/**
		* Updates a meta state field when a key is pressed or released.
		*/
		extern int32_t updateMetaState(int32_t keyCode, bool down, int32_t oldMetaState);

		/**
		* Returns true if a key is a meta key like ALT or CAPS_LOCK.
		*/
		extern bool isMetaKey(int32_t keyCode);

		} // namespace android

		#endif // _UI_KEYBOARD_H