Revert "Move inputservice over to frameworks/native"
This reverts commit 2dceb67f1f.
This commit is contained in:
Michael Wright
parent
2dceb67f1f
commit
1b1fe314c4
|
|
@ -16,13 +16,6 @@ LOCAL_PATH:= $(call my-dir)
|
|||
include $(CLEAR_VARS)
|
||||
|
||||
LOCAL_SRC_FILES:= \
|
||||
EventHub.cpp \
|
||||
InputApplication.cpp \
|
||||
InputDispatcher.cpp \
|
||||
InputListener.cpp \
|
||||
InputManager.cpp \
|
||||
InputReader.cpp \
|
||||
InputWindow.cpp \
|
||||
InputFlinger.cpp
|
||||
|
||||
LOCAL_SHARED_LIBRARIES := \
|
||||
|
|
@ -30,13 +23,9 @@ LOCAL_SHARED_LIBRARIES := \
|
|||
libcutils \
|
||||
libinput \
|
||||
liblog \
|
||||
libutils \
|
||||
libui \
|
||||
libhardware_legacy
|
||||
libutils
|
||||
|
||||
|
||||
# TODO: Move inputflinger to its own process and mark it hidden
|
||||
#LOCAL_CFLAGS += -fvisibility=hidden
|
||||
LOCAL_CFLAGS += -fvisibility=hidden
|
||||
|
||||
LOCAL_EXPORT_C_INCLUDE_DIRS := $(LOCAL_PATH)
|
||||
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load Diff
|
|
@ -1,457 +0,0 @@
|
|||
/*
|
||||
* Copyright (C) 2005 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 _RUNTIME_EVENT_HUB_H
|
||||
#define _RUNTIME_EVENT_HUB_H
|
||||
|
||||
#include <input/Input.h>
|
||||
#include <input/InputDevice.h>
|
||||
#include <input/Keyboard.h>
|
||||
#include <input/KeyLayoutMap.h>
|
||||
#include <input/KeyCharacterMap.h>
|
||||
#include <input/VirtualKeyMap.h>
|
||||
#include <utils/String8.h>
|
||||
#include <utils/threads.h>
|
||||
#include <utils/Log.h>
|
||||
#include <utils/threads.h>
|
||||
#include <utils/List.h>
|
||||
#include <utils/Errors.h>
|
||||
#include <utils/PropertyMap.h>
|
||||
#include <utils/Vector.h>
|
||||
#include <utils/KeyedVector.h>
|
||||
#include <utils/BitSet.h>
|
||||
|
||||
#include <linux/input.h>
|
||||
#include <sys/epoll.h>
|
||||
|
||||
/* Convenience constants. */
|
||||
|
||||
#define BTN_FIRST 0x100 // first button code
|
||||
#define BTN_LAST 0x15f // last button code
|
||||
|
||||
/*
|
||||
* These constants are used privately in Android to pass raw timestamps
|
||||
* through evdev from uinput device drivers because there is currently no
|
||||
* other way to transfer this information. The evdev driver automatically
|
||||
* timestamps all input events with the time they were posted and clobbers
|
||||
* whatever information was passed in.
|
||||
*
|
||||
* For the purposes of this hack, the timestamp is specified in the
|
||||
* CLOCK_MONOTONIC timebase and is split into two EV_MSC events specifying
|
||||
* seconds and microseconds.
|
||||
*/
|
||||
#define MSC_ANDROID_TIME_SEC 0x6
|
||||
#define MSC_ANDROID_TIME_USEC 0x7
|
||||
|
||||
namespace android {
|
||||
|
||||
enum {
|
||||
// Device id of a special "virtual" keyboard that is always present.
|
||||
VIRTUAL_KEYBOARD_ID = -1,
|
||||
// Device id of the "built-in" keyboard if there is one.
|
||||
BUILT_IN_KEYBOARD_ID = 0,
|
||||
};
|
||||
|
||||
/*
|
||||
* A raw event as retrieved from the EventHub.
|
||||
*/
|
||||
struct RawEvent {
|
||||
nsecs_t when;
|
||||
int32_t deviceId;
|
||||
int32_t type;
|
||||
int32_t code;
|
||||
int32_t value;
|
||||
};
|
||||
|
||||
/* Describes an absolute axis. */
|
||||
struct RawAbsoluteAxisInfo {
|
||||
bool valid; // true if the information is valid, false otherwise
|
||||
|
||||
int32_t minValue; // minimum value
|
||||
int32_t maxValue; // maximum value
|
||||
int32_t flat; // center flat position, eg. flat == 8 means center is between -8 and 8
|
||||
int32_t fuzz; // error tolerance, eg. fuzz == 4 means value is +/- 4 due to noise
|
||||
int32_t resolution; // resolution in units per mm or radians per mm
|
||||
|
||||
inline void clear() {
|
||||
valid = false;
|
||||
minValue = 0;
|
||||
maxValue = 0;
|
||||
flat = 0;
|
||||
fuzz = 0;
|
||||
resolution = 0;
|
||||
}
|
||||
};
|
||||
|
||||
/*
|
||||
* Input device classes.
|
||||
*/
|
||||
enum {
|
||||
/* The input device is a keyboard or has buttons. */
|
||||
INPUT_DEVICE_CLASS_KEYBOARD = 0x00000001,
|
||||
|
||||
/* The input device is an alpha-numeric keyboard (not just a dial pad). */
|
||||
INPUT_DEVICE_CLASS_ALPHAKEY = 0x00000002,
|
||||
|
||||
/* The input device is a touchscreen or a touchpad (either single-touch or multi-touch). */
|
||||
INPUT_DEVICE_CLASS_TOUCH = 0x00000004,
|
||||
|
||||
/* The input device is a cursor device such as a trackball or mouse. */
|
||||
INPUT_DEVICE_CLASS_CURSOR = 0x00000008,
|
||||
|
||||
/* The input device is a multi-touch touchscreen. */
|
||||
INPUT_DEVICE_CLASS_TOUCH_MT = 0x00000010,
|
||||
|
||||
/* The input device is a directional pad (implies keyboard, has DPAD keys). */
|
||||
INPUT_DEVICE_CLASS_DPAD = 0x00000020,
|
||||
|
||||
/* The input device is a gamepad (implies keyboard, has BUTTON keys). */
|
||||
INPUT_DEVICE_CLASS_GAMEPAD = 0x00000040,
|
||||
|
||||
/* The input device has switches. */
|
||||
INPUT_DEVICE_CLASS_SWITCH = 0x00000080,
|
||||
|
||||
/* The input device is a joystick (implies gamepad, has joystick absolute axes). */
|
||||
INPUT_DEVICE_CLASS_JOYSTICK = 0x00000100,
|
||||
|
||||
/* The input device has a vibrator (supports FF_RUMBLE). */
|
||||
INPUT_DEVICE_CLASS_VIBRATOR = 0x00000200,
|
||||
|
||||
/* The input device is virtual (not a real device, not part of UI configuration). */
|
||||
INPUT_DEVICE_CLASS_VIRTUAL = 0x40000000,
|
||||
|
||||
/* The input device is external (not built-in). */
|
||||
INPUT_DEVICE_CLASS_EXTERNAL = 0x80000000,
|
||||
};
|
||||
|
||||
/*
|
||||
* Gets the class that owns an axis, in cases where multiple classes might claim
|
||||
* the same axis for different purposes.
|
||||
*/
|
||||
extern uint32_t getAbsAxisUsage(int32_t axis, uint32_t deviceClasses);
|
||||
|
||||
/*
|
||||
* Grand Central Station for events.
|
||||
*
|
||||
* The event hub aggregates input events received across all known input
|
||||
* devices on the system, including devices that may be emulated by the simulator
|
||||
* environment. In addition, the event hub generates fake input events to indicate
|
||||
* when devices are added or removed.
|
||||
*
|
||||
* The event hub provides a stream of input events (via the getEvent function).
|
||||
* It also supports querying the current actual state of input devices such as identifying
|
||||
* which keys are currently down. Finally, the event hub keeps track of the capabilities of
|
||||
* individual input devices, such as their class and the set of key codes that they support.
|
||||
*/
|
||||
class EventHubInterface : public virtual RefBase {
|
||||
protected:
|
||||
EventHubInterface() { }
|
||||
virtual ~EventHubInterface() { }
|
||||
|
||||
public:
|
||||
// Synthetic raw event type codes produced when devices are added or removed.
|
||||
enum {
|
||||
// Sent when a device is added.
|
||||
DEVICE_ADDED = 0x10000000,
|
||||
// Sent when a device is removed.
|
||||
DEVICE_REMOVED = 0x20000000,
|
||||
// Sent when all added/removed devices from the most recent scan have been reported.
|
||||
// This event is always sent at least once.
|
||||
FINISHED_DEVICE_SCAN = 0x30000000,
|
||||
|
||||
FIRST_SYNTHETIC_EVENT = DEVICE_ADDED,
|
||||
};
|
||||
|
||||
virtual uint32_t getDeviceClasses(int32_t deviceId) const = 0;
|
||||
|
||||
virtual InputDeviceIdentifier getDeviceIdentifier(int32_t deviceId) const = 0;
|
||||
|
||||
virtual int32_t getDeviceControllerNumber(int32_t deviceId) const = 0;
|
||||
|
||||
virtual void getConfiguration(int32_t deviceId, PropertyMap* outConfiguration) const = 0;
|
||||
|
||||
virtual status_t getAbsoluteAxisInfo(int32_t deviceId, int axis,
|
||||
RawAbsoluteAxisInfo* outAxisInfo) const = 0;
|
||||
|
||||
virtual bool hasRelativeAxis(int32_t deviceId, int axis) const = 0;
|
||||
|
||||
virtual bool hasInputProperty(int32_t deviceId, int property) const = 0;
|
||||
|
||||
virtual status_t mapKey(int32_t deviceId, int32_t scanCode, int32_t usageCode,
|
||||
int32_t* outKeycode, uint32_t* outFlags) const = 0;
|
||||
|
||||
virtual status_t mapAxis(int32_t deviceId, int32_t scanCode,
|
||||
AxisInfo* outAxisInfo) const = 0;
|
||||
|
||||
// Sets devices that are excluded from opening.
|
||||
// This can be used to ignore input devices for sensors.
|
||||
virtual void setExcludedDevices(const Vector<String8>& devices) = 0;
|
||||
|
||||
/*
|
||||
* Wait for events to become available and returns them.
|
||||
* After returning, the EventHub holds onto a wake lock until the next call to getEvent.
|
||||
* This ensures that the device will not go to sleep while the event is being processed.
|
||||
* If the device needs to remain awake longer than that, then the caller is responsible
|
||||
* for taking care of it (say, by poking the power manager user activity timer).
|
||||
*
|
||||
* The timeout is advisory only. If the device is asleep, it will not wake just to
|
||||
* service the timeout.
|
||||
*
|
||||
* Returns the number of events obtained, or 0 if the timeout expired.
|
||||
*/
|
||||
virtual size_t getEvents(int timeoutMillis, RawEvent* buffer, size_t bufferSize) = 0;
|
||||
|
||||
/*
|
||||
* Query current input state.
|
||||
*/
|
||||
virtual int32_t getScanCodeState(int32_t deviceId, int32_t scanCode) const = 0;
|
||||
virtual int32_t getKeyCodeState(int32_t deviceId, int32_t keyCode) const = 0;
|
||||
virtual int32_t getSwitchState(int32_t deviceId, int32_t sw) const = 0;
|
||||
virtual status_t getAbsoluteAxisValue(int32_t deviceId, int32_t axis,
|
||||
int32_t* outValue) const = 0;
|
||||
|
||||
/*
|
||||
* Examine key input devices for specific framework keycode support
|
||||
*/
|
||||
virtual bool markSupportedKeyCodes(int32_t deviceId, size_t numCodes, const int32_t* keyCodes,
|
||||
uint8_t* outFlags) const = 0;
|
||||
|
||||
virtual bool hasScanCode(int32_t deviceId, int32_t scanCode) const = 0;
|
||||
|
||||
/* LED related functions expect Android LED constants, not scan codes or HID usages */
|
||||
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 sp<KeyCharacterMap> getKeyCharacterMap(int32_t deviceId) const = 0;
|
||||
virtual bool setKeyboardLayoutOverlay(int32_t deviceId, const sp<KeyCharacterMap>& map) = 0;
|
||||
|
||||
/* Control the vibrator. */
|
||||
virtual void vibrate(int32_t deviceId, nsecs_t duration) = 0;
|
||||
virtual void cancelVibrate(int32_t deviceId) = 0;
|
||||
|
||||
/* Requests the EventHub to reopen all input devices on the next call to getEvents(). */
|
||||
virtual void requestReopenDevices() = 0;
|
||||
|
||||
/* Wakes up getEvents() if it is blocked on a read. */
|
||||
virtual void wake() = 0;
|
||||
|
||||
/* Dump EventHub state to a string. */
|
||||
virtual void dump(String8& dump) = 0;
|
||||
|
||||
/* Called by the heatbeat to ensures that the reader has not deadlocked. */
|
||||
virtual void monitor() = 0;
|
||||
};
|
||||
|
||||
class EventHub : public EventHubInterface
|
||||
{
|
||||
public:
|
||||
EventHub();
|
||||
|
||||
virtual uint32_t getDeviceClasses(int32_t deviceId) const;
|
||||
|
||||
virtual InputDeviceIdentifier getDeviceIdentifier(int32_t deviceId) const;
|
||||
|
||||
virtual int32_t getDeviceControllerNumber(int32_t deviceId) const;
|
||||
|
||||
virtual void getConfiguration(int32_t deviceId, PropertyMap* outConfiguration) const;
|
||||
|
||||
virtual status_t getAbsoluteAxisInfo(int32_t deviceId, int axis,
|
||||
RawAbsoluteAxisInfo* outAxisInfo) const;
|
||||
|
||||
virtual bool hasRelativeAxis(int32_t deviceId, int axis) const;
|
||||
|
||||
virtual bool hasInputProperty(int32_t deviceId, int property) const;
|
||||
|
||||
virtual status_t mapKey(int32_t deviceId, int32_t scanCode, int32_t usageCode,
|
||||
int32_t* outKeycode, uint32_t* outFlags) const;
|
||||
|
||||
virtual status_t mapAxis(int32_t deviceId, int32_t scanCode,
|
||||
AxisInfo* outAxisInfo) const;
|
||||
|
||||
virtual void setExcludedDevices(const Vector<String8>& devices);
|
||||
|
||||
virtual int32_t getScanCodeState(int32_t deviceId, int32_t scanCode) const;
|
||||
virtual int32_t getKeyCodeState(int32_t deviceId, int32_t keyCode) const;
|
||||
virtual int32_t getSwitchState(int32_t deviceId, int32_t sw) const;
|
||||
virtual status_t getAbsoluteAxisValue(int32_t deviceId, int32_t axis, int32_t* outValue) const;
|
||||
|
||||
virtual bool markSupportedKeyCodes(int32_t deviceId, size_t numCodes,
|
||||
const int32_t* keyCodes, uint8_t* outFlags) const;
|
||||
|
||||
virtual size_t getEvents(int timeoutMillis, RawEvent* buffer, size_t bufferSize);
|
||||
|
||||
virtual bool hasScanCode(int32_t deviceId, int32_t scanCode) const;
|
||||
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 sp<KeyCharacterMap> getKeyCharacterMap(int32_t deviceId) const;
|
||||
virtual bool setKeyboardLayoutOverlay(int32_t deviceId, const sp<KeyCharacterMap>& map);
|
||||
|
||||
virtual void vibrate(int32_t deviceId, nsecs_t duration);
|
||||
virtual void cancelVibrate(int32_t deviceId);
|
||||
|
||||
virtual void requestReopenDevices();
|
||||
|
||||
virtual void wake();
|
||||
|
||||
virtual void dump(String8& dump);
|
||||
virtual void monitor();
|
||||
|
||||
protected:
|
||||
virtual ~EventHub();
|
||||
|
||||
private:
|
||||
struct Device {
|
||||
Device* next;
|
||||
|
||||
int fd; // may be -1 if device is virtual
|
||||
const int32_t id;
|
||||
const String8 path;
|
||||
const InputDeviceIdentifier identifier;
|
||||
|
||||
uint32_t classes;
|
||||
|
||||
uint8_t keyBitmask[(KEY_MAX + 1) / 8];
|
||||
uint8_t absBitmask[(ABS_MAX + 1) / 8];
|
||||
uint8_t relBitmask[(REL_MAX + 1) / 8];
|
||||
uint8_t swBitmask[(SW_MAX + 1) / 8];
|
||||
uint8_t ledBitmask[(LED_MAX + 1) / 8];
|
||||
uint8_t ffBitmask[(FF_MAX + 1) / 8];
|
||||
uint8_t propBitmask[(INPUT_PROP_MAX + 1) / 8];
|
||||
|
||||
String8 configurationFile;
|
||||
PropertyMap* configuration;
|
||||
VirtualKeyMap* virtualKeyMap;
|
||||
KeyMap keyMap;
|
||||
|
||||
sp<KeyCharacterMap> overlayKeyMap;
|
||||
sp<KeyCharacterMap> combinedKeyMap;
|
||||
|
||||
bool ffEffectPlaying;
|
||||
int16_t ffEffectId; // initially -1
|
||||
|
||||
int32_t controllerNumber;
|
||||
|
||||
int32_t timestampOverrideSec;
|
||||
int32_t timestampOverrideUsec;
|
||||
|
||||
Device(int fd, int32_t id, const String8& path, const InputDeviceIdentifier& identifier);
|
||||
~Device();
|
||||
|
||||
void close();
|
||||
|
||||
inline bool isVirtual() const { return fd < 0; }
|
||||
|
||||
const sp<KeyCharacterMap>& getKeyCharacterMap() const {
|
||||
if (combinedKeyMap != NULL) {
|
||||
return combinedKeyMap;
|
||||
}
|
||||
return keyMap.keyCharacterMap;
|
||||
}
|
||||
};
|
||||
|
||||
status_t openDeviceLocked(const char *devicePath);
|
||||
void createVirtualKeyboardLocked();
|
||||
void addDeviceLocked(Device* device);
|
||||
void assignDescriptorLocked(InputDeviceIdentifier& identifier);
|
||||
|
||||
status_t closeDeviceByPathLocked(const char *devicePath);
|
||||
void closeDeviceLocked(Device* device);
|
||||
void closeAllDevicesLocked();
|
||||
|
||||
status_t scanDirLocked(const char *dirname);
|
||||
void scanDevicesLocked();
|
||||
status_t readNotifyLocked();
|
||||
|
||||
Device* getDeviceByDescriptorLocked(String8& descriptor) const;
|
||||
Device* getDeviceLocked(int32_t deviceId) const;
|
||||
Device* getDeviceByPathLocked(const char* devicePath) const;
|
||||
|
||||
bool hasKeycodeLocked(Device* device, int keycode) const;
|
||||
|
||||
void loadConfigurationLocked(Device* device);
|
||||
status_t loadVirtualKeyMapLocked(Device* device);
|
||||
status_t loadKeyMapLocked(Device* device);
|
||||
|
||||
bool isExternalDeviceLocked(Device* device);
|
||||
|
||||
int32_t getNextControllerNumberLocked(Device* device);
|
||||
void releaseControllerNumberLocked(Device* device);
|
||||
void setLedForController(Device* device);
|
||||
|
||||
status_t mapLed(Device* device, int32_t led, int32_t* outScanCode) const;
|
||||
void setLedStateLocked(Device* device, int32_t led, bool on);
|
||||
|
||||
// Protect all internal state.
|
||||
mutable Mutex mLock;
|
||||
|
||||
// The actual id of the built-in keyboard, or NO_BUILT_IN_KEYBOARD if none.
|
||||
// EventHub remaps the built-in keyboard to id 0 externally as required by the API.
|
||||
enum {
|
||||
// Must not conflict with any other assigned device ids, including
|
||||
// the virtual keyboard id (-1).
|
||||
NO_BUILT_IN_KEYBOARD = -2,
|
||||
};
|
||||
int32_t mBuiltInKeyboardId;
|
||||
|
||||
int32_t mNextDeviceId;
|
||||
|
||||
BitSet32 mControllerNumbers;
|
||||
|
||||
KeyedVector<int32_t, Device*> mDevices;
|
||||
|
||||
Device *mOpeningDevices;
|
||||
Device *mClosingDevices;
|
||||
|
||||
bool mNeedToSendFinishedDeviceScan;
|
||||
bool mNeedToReopenDevices;
|
||||
bool mNeedToScanDevices;
|
||||
Vector<String8> mExcludedDevices;
|
||||
|
||||
int mEpollFd;
|
||||
int mINotifyFd;
|
||||
int mWakeReadPipeFd;
|
||||
int mWakeWritePipeFd;
|
||||
|
||||
// Ids used for epoll notifications not associated with devices.
|
||||
static const uint32_t EPOLL_ID_INOTIFY = 0x80000001;
|
||||
static const uint32_t EPOLL_ID_WAKE = 0x80000002;
|
||||
|
||||
// Epoll FD list size hint.
|
||||
static const int EPOLL_SIZE_HINT = 8;
|
||||
|
||||
// Maximum number of signalled FDs to handle at a time.
|
||||
static const int EPOLL_MAX_EVENTS = 16;
|
||||
|
||||
// The array of pending epoll events and the index of the next event to be handled.
|
||||
struct epoll_event mPendingEventItems[EPOLL_MAX_EVENTS];
|
||||
size_t mPendingEventCount;
|
||||
size_t mPendingEventIndex;
|
||||
bool mPendingINotify;
|
||||
|
||||
bool mUsingEpollWakeup;
|
||||
};
|
||||
|
||||
}; // namespace android
|
||||
|
||||
#endif // _RUNTIME_EVENT_HUB_H
|
||||
|
|
@ -1,42 +0,0 @@
|
|||
/*
|
||||
* Copyright (C) 2011 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.
|
||||
*/
|
||||
|
||||
#define LOG_TAG "InputApplication"
|
||||
|
||||
#include "InputApplication.h"
|
||||
|
||||
#include <cutils/log.h>
|
||||
|
||||
namespace android {
|
||||
|
||||
// --- InputApplicationHandle ---
|
||||
|
||||
InputApplicationHandle::InputApplicationHandle() :
|
||||
mInfo(NULL) {
|
||||
}
|
||||
|
||||
InputApplicationHandle::~InputApplicationHandle() {
|
||||
delete mInfo;
|
||||
}
|
||||
|
||||
void InputApplicationHandle::releaseInfo() {
|
||||
if (mInfo) {
|
||||
delete mInfo;
|
||||
mInfo = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace android
|
||||
|
|
@ -1,83 +0,0 @@
|
|||
/*
|
||||
* Copyright (C) 2011 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_APPLICATION_H
|
||||
#define _UI_INPUT_APPLICATION_H
|
||||
|
||||
#include <input/Input.h>
|
||||
|
||||
#include <utils/RefBase.h>
|
||||
#include <utils/Timers.h>
|
||||
#include <utils/String8.h>
|
||||
|
||||
namespace android {
|
||||
|
||||
/*
|
||||
* Describes the properties of an application that can receive input.
|
||||
*/
|
||||
struct InputApplicationInfo {
|
||||
String8 name;
|
||||
nsecs_t dispatchingTimeout;
|
||||
};
|
||||
|
||||
|
||||
/*
|
||||
* Handle for an application that can receive input.
|
||||
*
|
||||
* Used by the native input dispatcher as a handle for the window manager objects
|
||||
* that describe an application.
|
||||
*/
|
||||
class InputApplicationHandle : public RefBase {
|
||||
public:
|
||||
inline const InputApplicationInfo* getInfo() const {
|
||||
return mInfo;
|
||||
}
|
||||
|
||||
inline String8 getName() const {
|
||||
return mInfo ? mInfo->name : String8("<invalid>");
|
||||
}
|
||||
|
||||
inline nsecs_t getDispatchingTimeout(nsecs_t defaultValue) const {
|
||||
return mInfo ? mInfo->dispatchingTimeout : defaultValue;
|
||||
}
|
||||
|
||||
/**
|
||||
* Requests that the state of this object be updated to reflect
|
||||
* the most current available information about the application.
|
||||
*
|
||||
* This method should only be called from within the input dispatcher's
|
||||
* critical section.
|
||||
*
|
||||
* Returns true on success, or false if the handle is no longer valid.
|
||||
*/
|
||||
virtual bool updateInfo() = 0;
|
||||
|
||||
/**
|
||||
* Releases the storage used by the associated information when it is
|
||||
* no longer needed.
|
||||
*/
|
||||
void releaseInfo();
|
||||
|
||||
protected:
|
||||
InputApplicationHandle();
|
||||
virtual ~InputApplicationHandle();
|
||||
|
||||
InputApplicationInfo* mInfo;
|
||||
};
|
||||
|
||||
} // namespace android
|
||||
|
||||
#endif // _UI_INPUT_APPLICATION_H
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
|
|
@ -1,182 +0,0 @@
|
|||
/*
|
||||
* Copyright (C) 2011 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.
|
||||
*/
|
||||
|
||||
#define LOG_TAG "InputListener"
|
||||
|
||||
//#define LOG_NDEBUG 0
|
||||
|
||||
#include "InputListener.h"
|
||||
|
||||
#include <cutils/log.h>
|
||||
|
||||
namespace android {
|
||||
|
||||
// --- NotifyConfigurationChangedArgs ---
|
||||
|
||||
NotifyConfigurationChangedArgs::NotifyConfigurationChangedArgs(nsecs_t eventTime) :
|
||||
eventTime(eventTime) {
|
||||
}
|
||||
|
||||
NotifyConfigurationChangedArgs::NotifyConfigurationChangedArgs(
|
||||
const NotifyConfigurationChangedArgs& other) :
|
||||
eventTime(other.eventTime) {
|
||||
}
|
||||
|
||||
void NotifyConfigurationChangedArgs::notify(const sp<InputListenerInterface>& listener) const {
|
||||
listener->notifyConfigurationChanged(this);
|
||||
}
|
||||
|
||||
|
||||
// --- NotifyKeyArgs ---
|
||||
|
||||
NotifyKeyArgs::NotifyKeyArgs(nsecs_t eventTime, int32_t deviceId, uint32_t source,
|
||||
uint32_t policyFlags,
|
||||
int32_t action, int32_t flags, int32_t keyCode, int32_t scanCode,
|
||||
int32_t metaState, nsecs_t downTime) :
|
||||
eventTime(eventTime), deviceId(deviceId), source(source), policyFlags(policyFlags),
|
||||
action(action), flags(flags), keyCode(keyCode), scanCode(scanCode),
|
||||
metaState(metaState), downTime(downTime) {
|
||||
}
|
||||
|
||||
NotifyKeyArgs::NotifyKeyArgs(const NotifyKeyArgs& other) :
|
||||
eventTime(other.eventTime), deviceId(other.deviceId), source(other.source),
|
||||
policyFlags(other.policyFlags),
|
||||
action(other.action), flags(other.flags),
|
||||
keyCode(other.keyCode), scanCode(other.scanCode),
|
||||
metaState(other.metaState), downTime(other.downTime) {
|
||||
}
|
||||
|
||||
void NotifyKeyArgs::notify(const sp<InputListenerInterface>& listener) const {
|
||||
listener->notifyKey(this);
|
||||
}
|
||||
|
||||
|
||||
// --- NotifyMotionArgs ---
|
||||
|
||||
NotifyMotionArgs::NotifyMotionArgs(nsecs_t eventTime, int32_t deviceId, uint32_t source,
|
||||
uint32_t policyFlags,
|
||||
int32_t action, int32_t flags, int32_t metaState, int32_t buttonState,
|
||||
int32_t edgeFlags, int32_t displayId, uint32_t pointerCount,
|
||||
const PointerProperties* pointerProperties, const PointerCoords* pointerCoords,
|
||||
float xPrecision, float yPrecision, nsecs_t downTime) :
|
||||
eventTime(eventTime), deviceId(deviceId), source(source), policyFlags(policyFlags),
|
||||
action(action), flags(flags), metaState(metaState), buttonState(buttonState),
|
||||
edgeFlags(edgeFlags), displayId(displayId), pointerCount(pointerCount),
|
||||
xPrecision(xPrecision), yPrecision(yPrecision), downTime(downTime) {
|
||||
for (uint32_t i = 0; i < pointerCount; i++) {
|
||||
this->pointerProperties[i].copyFrom(pointerProperties[i]);
|
||||
this->pointerCoords[i].copyFrom(pointerCoords[i]);
|
||||
}
|
||||
}
|
||||
|
||||
NotifyMotionArgs::NotifyMotionArgs(const NotifyMotionArgs& other) :
|
||||
eventTime(other.eventTime), deviceId(other.deviceId), source(other.source),
|
||||
policyFlags(other.policyFlags),
|
||||
action(other.action), flags(other.flags),
|
||||
metaState(other.metaState), buttonState(other.buttonState),
|
||||
edgeFlags(other.edgeFlags), displayId(other.displayId),
|
||||
pointerCount(other.pointerCount),
|
||||
xPrecision(other.xPrecision), yPrecision(other.yPrecision), downTime(other.downTime) {
|
||||
for (uint32_t i = 0; i < pointerCount; i++) {
|
||||
pointerProperties[i].copyFrom(other.pointerProperties[i]);
|
||||
pointerCoords[i].copyFrom(other.pointerCoords[i]);
|
||||
}
|
||||
}
|
||||
|
||||
void NotifyMotionArgs::notify(const sp<InputListenerInterface>& listener) const {
|
||||
listener->notifyMotion(this);
|
||||
}
|
||||
|
||||
|
||||
// --- NotifySwitchArgs ---
|
||||
|
||||
NotifySwitchArgs::NotifySwitchArgs(nsecs_t eventTime, uint32_t policyFlags,
|
||||
uint32_t switchValues, uint32_t switchMask) :
|
||||
eventTime(eventTime), policyFlags(policyFlags),
|
||||
switchValues(switchValues), switchMask(switchMask) {
|
||||
}
|
||||
|
||||
NotifySwitchArgs::NotifySwitchArgs(const NotifySwitchArgs& other) :
|
||||
eventTime(other.eventTime), policyFlags(other.policyFlags),
|
||||
switchValues(other.switchValues), switchMask(other.switchMask) {
|
||||
}
|
||||
|
||||
void NotifySwitchArgs::notify(const sp<InputListenerInterface>& listener) const {
|
||||
listener->notifySwitch(this);
|
||||
}
|
||||
|
||||
|
||||
// --- NotifyDeviceResetArgs ---
|
||||
|
||||
NotifyDeviceResetArgs::NotifyDeviceResetArgs(nsecs_t eventTime, int32_t deviceId) :
|
||||
eventTime(eventTime), deviceId(deviceId) {
|
||||
}
|
||||
|
||||
NotifyDeviceResetArgs::NotifyDeviceResetArgs(const NotifyDeviceResetArgs& other) :
|
||||
eventTime(other.eventTime), deviceId(other.deviceId) {
|
||||
}
|
||||
|
||||
void NotifyDeviceResetArgs::notify(const sp<InputListenerInterface>& listener) const {
|
||||
listener->notifyDeviceReset(this);
|
||||
}
|
||||
|
||||
|
||||
// --- QueuedInputListener ---
|
||||
|
||||
QueuedInputListener::QueuedInputListener(const sp<InputListenerInterface>& innerListener) :
|
||||
mInnerListener(innerListener) {
|
||||
}
|
||||
|
||||
QueuedInputListener::~QueuedInputListener() {
|
||||
size_t count = mArgsQueue.size();
|
||||
for (size_t i = 0; i < count; i++) {
|
||||
delete mArgsQueue[i];
|
||||
}
|
||||
}
|
||||
|
||||
void QueuedInputListener::notifyConfigurationChanged(
|
||||
const NotifyConfigurationChangedArgs* args) {
|
||||
mArgsQueue.push(new NotifyConfigurationChangedArgs(*args));
|
||||
}
|
||||
|
||||
void QueuedInputListener::notifyKey(const NotifyKeyArgs* args) {
|
||||
mArgsQueue.push(new NotifyKeyArgs(*args));
|
||||
}
|
||||
|
||||
void QueuedInputListener::notifyMotion(const NotifyMotionArgs* args) {
|
||||
mArgsQueue.push(new NotifyMotionArgs(*args));
|
||||
}
|
||||
|
||||
void QueuedInputListener::notifySwitch(const NotifySwitchArgs* args) {
|
||||
mArgsQueue.push(new NotifySwitchArgs(*args));
|
||||
}
|
||||
|
||||
void QueuedInputListener::notifyDeviceReset(const NotifyDeviceResetArgs* args) {
|
||||
mArgsQueue.push(new NotifyDeviceResetArgs(*args));
|
||||
}
|
||||
|
||||
void QueuedInputListener::flush() {
|
||||
size_t count = mArgsQueue.size();
|
||||
for (size_t i = 0; i < count; i++) {
|
||||
NotifyArgs* args = mArgsQueue[i];
|
||||
args->notify(mInnerListener);
|
||||
delete args;
|
||||
}
|
||||
mArgsQueue.clear();
|
||||
}
|
||||
|
||||
|
||||
} // namespace android
|
||||
|
|
@ -1,196 +0,0 @@
|
|||
/*
|
||||
* Copyright (C) 2011 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_LISTENER_H
|
||||
#define _UI_INPUT_LISTENER_H
|
||||
|
||||
#include <input/Input.h>
|
||||
#include <utils/RefBase.h>
|
||||
#include <utils/Vector.h>
|
||||
|
||||
namespace android {
|
||||
|
||||
class InputListenerInterface;
|
||||
|
||||
|
||||
/* Superclass of all input event argument objects */
|
||||
struct NotifyArgs {
|
||||
virtual ~NotifyArgs() { }
|
||||
|
||||
virtual void notify(const sp<InputListenerInterface>& listener) const = 0;
|
||||
};
|
||||
|
||||
|
||||
/* Describes a configuration change event. */
|
||||
struct NotifyConfigurationChangedArgs : public NotifyArgs {
|
||||
nsecs_t eventTime;
|
||||
|
||||
inline NotifyConfigurationChangedArgs() { }
|
||||
|
||||
NotifyConfigurationChangedArgs(nsecs_t eventTime);
|
||||
|
||||
NotifyConfigurationChangedArgs(const NotifyConfigurationChangedArgs& other);
|
||||
|
||||
virtual ~NotifyConfigurationChangedArgs() { }
|
||||
|
||||
virtual void notify(const sp<InputListenerInterface>& listener) const;
|
||||
};
|
||||
|
||||
|
||||
/* Describes a key event. */
|
||||
struct NotifyKeyArgs : public NotifyArgs {
|
||||
nsecs_t eventTime;
|
||||
int32_t deviceId;
|
||||
uint32_t source;
|
||||
uint32_t policyFlags;
|
||||
int32_t action;
|
||||
int32_t flags;
|
||||
int32_t keyCode;
|
||||
int32_t scanCode;
|
||||
int32_t metaState;
|
||||
nsecs_t downTime;
|
||||
|
||||
inline NotifyKeyArgs() { }
|
||||
|
||||
NotifyKeyArgs(nsecs_t eventTime, int32_t deviceId, uint32_t source, uint32_t policyFlags,
|
||||
int32_t action, int32_t flags, int32_t keyCode, int32_t scanCode,
|
||||
int32_t metaState, nsecs_t downTime);
|
||||
|
||||
NotifyKeyArgs(const NotifyKeyArgs& other);
|
||||
|
||||
virtual ~NotifyKeyArgs() { }
|
||||
|
||||
virtual void notify(const sp<InputListenerInterface>& listener) const;
|
||||
};
|
||||
|
||||
|
||||
/* Describes a motion event. */
|
||||
struct NotifyMotionArgs : public NotifyArgs {
|
||||
nsecs_t eventTime;
|
||||
int32_t deviceId;
|
||||
uint32_t source;
|
||||
uint32_t policyFlags;
|
||||
int32_t action;
|
||||
int32_t flags;
|
||||
int32_t metaState;
|
||||
int32_t buttonState;
|
||||
int32_t edgeFlags;
|
||||
int32_t displayId;
|
||||
uint32_t pointerCount;
|
||||
PointerProperties pointerProperties[MAX_POINTERS];
|
||||
PointerCoords pointerCoords[MAX_POINTERS];
|
||||
float xPrecision;
|
||||
float yPrecision;
|
||||
nsecs_t downTime;
|
||||
|
||||
inline NotifyMotionArgs() { }
|
||||
|
||||
NotifyMotionArgs(nsecs_t eventTime, int32_t deviceId, uint32_t source, uint32_t policyFlags,
|
||||
int32_t action, int32_t flags, int32_t metaState, int32_t buttonState,
|
||||
int32_t edgeFlags, int32_t displayId, uint32_t pointerCount,
|
||||
const PointerProperties* pointerProperties, const PointerCoords* pointerCoords,
|
||||
float xPrecision, float yPrecision, nsecs_t downTime);
|
||||
|
||||
NotifyMotionArgs(const NotifyMotionArgs& other);
|
||||
|
||||
virtual ~NotifyMotionArgs() { }
|
||||
|
||||
virtual void notify(const sp<InputListenerInterface>& listener) const;
|
||||
};
|
||||
|
||||
|
||||
/* Describes a switch event. */
|
||||
struct NotifySwitchArgs : public NotifyArgs {
|
||||
nsecs_t eventTime;
|
||||
uint32_t policyFlags;
|
||||
uint32_t switchValues;
|
||||
uint32_t switchMask;
|
||||
|
||||
inline NotifySwitchArgs() { }
|
||||
|
||||
NotifySwitchArgs(nsecs_t eventTime, uint32_t policyFlags,
|
||||
uint32_t switchValues, uint32_t switchMask);
|
||||
|
||||
NotifySwitchArgs(const NotifySwitchArgs& other);
|
||||
|
||||
virtual ~NotifySwitchArgs() { }
|
||||
|
||||
virtual void notify(const sp<InputListenerInterface>& listener) const;
|
||||
};
|
||||
|
||||
|
||||
/* Describes a device reset event, such as when a device is added,
|
||||
* reconfigured, or removed. */
|
||||
struct NotifyDeviceResetArgs : public NotifyArgs {
|
||||
nsecs_t eventTime;
|
||||
int32_t deviceId;
|
||||
|
||||
inline NotifyDeviceResetArgs() { }
|
||||
|
||||
NotifyDeviceResetArgs(nsecs_t eventTime, int32_t deviceId);
|
||||
|
||||
NotifyDeviceResetArgs(const NotifyDeviceResetArgs& other);
|
||||
|
||||
virtual ~NotifyDeviceResetArgs() { }
|
||||
|
||||
virtual void notify(const sp<InputListenerInterface>& listener) const;
|
||||
};
|
||||
|
||||
|
||||
/*
|
||||
* The interface used by the InputReader to notify the InputListener about input events.
|
||||
*/
|
||||
class InputListenerInterface : public virtual RefBase {
|
||||
protected:
|
||||
InputListenerInterface() { }
|
||||
virtual ~InputListenerInterface() { }
|
||||
|
||||
public:
|
||||
virtual void notifyConfigurationChanged(const NotifyConfigurationChangedArgs* args) = 0;
|
||||
virtual void notifyKey(const NotifyKeyArgs* args) = 0;
|
||||
virtual void notifyMotion(const NotifyMotionArgs* args) = 0;
|
||||
virtual void notifySwitch(const NotifySwitchArgs* args) = 0;
|
||||
virtual void notifyDeviceReset(const NotifyDeviceResetArgs* args) = 0;
|
||||
};
|
||||
|
||||
|
||||
/*
|
||||
* An implementation of the listener interface that queues up and defers dispatch
|
||||
* of decoded events until flushed.
|
||||
*/
|
||||
class QueuedInputListener : public InputListenerInterface {
|
||||
protected:
|
||||
virtual ~QueuedInputListener();
|
||||
|
||||
public:
|
||||
QueuedInputListener(const sp<InputListenerInterface>& innerListener);
|
||||
|
||||
virtual void notifyConfigurationChanged(const NotifyConfigurationChangedArgs* args);
|
||||
virtual void notifyKey(const NotifyKeyArgs* args);
|
||||
virtual void notifyMotion(const NotifyMotionArgs* args);
|
||||
virtual void notifySwitch(const NotifySwitchArgs* args);
|
||||
virtual void notifyDeviceReset(const NotifyDeviceResetArgs* args);
|
||||
|
||||
void flush();
|
||||
|
||||
private:
|
||||
sp<InputListenerInterface> mInnerListener;
|
||||
Vector<NotifyArgs*> mArgsQueue;
|
||||
};
|
||||
|
||||
} // namespace android
|
||||
|
||||
#endif // _UI_INPUT_LISTENER_H
|
||||
|
|
@ -1,93 +0,0 @@
|
|||
/*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
#define LOG_TAG "InputManager"
|
||||
|
||||
//#define LOG_NDEBUG 0
|
||||
|
||||
#include "InputManager.h"
|
||||
|
||||
#include <cutils/log.h>
|
||||
|
||||
namespace android {
|
||||
|
||||
InputManager::InputManager(
|
||||
const sp<EventHubInterface>& eventHub,
|
||||
const sp<InputReaderPolicyInterface>& readerPolicy,
|
||||
const sp<InputDispatcherPolicyInterface>& dispatcherPolicy) {
|
||||
mDispatcher = new InputDispatcher(dispatcherPolicy);
|
||||
mReader = new InputReader(eventHub, readerPolicy, mDispatcher);
|
||||
initialize();
|
||||
}
|
||||
|
||||
InputManager::InputManager(
|
||||
const sp<InputReaderInterface>& reader,
|
||||
const sp<InputDispatcherInterface>& dispatcher) :
|
||||
mReader(reader),
|
||||
mDispatcher(dispatcher) {
|
||||
initialize();
|
||||
}
|
||||
|
||||
InputManager::~InputManager() {
|
||||
stop();
|
||||
}
|
||||
|
||||
void InputManager::initialize() {
|
||||
mReaderThread = new InputReaderThread(mReader);
|
||||
mDispatcherThread = new InputDispatcherThread(mDispatcher);
|
||||
}
|
||||
|
||||
status_t InputManager::start() {
|
||||
status_t result = mDispatcherThread->run("InputDispatcher", PRIORITY_URGENT_DISPLAY);
|
||||
if (result) {
|
||||
ALOGE("Could not start InputDispatcher thread due to error %d.", result);
|
||||
return result;
|
||||
}
|
||||
|
||||
result = mReaderThread->run("InputReader", PRIORITY_URGENT_DISPLAY);
|
||||
if (result) {
|
||||
ALOGE("Could not start InputReader thread due to error %d.", result);
|
||||
|
||||
mDispatcherThread->requestExit();
|
||||
return result;
|
||||
}
|
||||
|
||||
return OK;
|
||||
}
|
||||
|
||||
status_t InputManager::stop() {
|
||||
status_t result = mReaderThread->requestExitAndWait();
|
||||
if (result) {
|
||||
ALOGW("Could not stop InputReader thread due to error %d.", result);
|
||||
}
|
||||
|
||||
result = mDispatcherThread->requestExitAndWait();
|
||||
if (result) {
|
||||
ALOGW("Could not stop InputDispatcher thread due to error %d.", result);
|
||||
}
|
||||
|
||||
return OK;
|
||||
}
|
||||
|
||||
sp<InputReaderInterface> InputManager::getReader() {
|
||||
return mReader;
|
||||
}
|
||||
|
||||
sp<InputDispatcherInterface> InputManager::getDispatcher() {
|
||||
return mDispatcher;
|
||||
}
|
||||
|
||||
} // namespace android
|
||||
|
|
@ -1,109 +0,0 @@
|
|||
/*
|
||||
* 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_MANAGER_H
|
||||
#define _UI_INPUT_MANAGER_H
|
||||
|
||||
/**
|
||||
* Native input manager.
|
||||
*/
|
||||
|
||||
#include "EventHub.h"
|
||||
#include "InputReader.h"
|
||||
#include "InputDispatcher.h"
|
||||
|
||||
#include <input/Input.h>
|
||||
#include <input/InputTransport.h>
|
||||
#include <utils/Errors.h>
|
||||
#include <utils/Vector.h>
|
||||
#include <utils/Timers.h>
|
||||
#include <utils/RefBase.h>
|
||||
#include <utils/String8.h>
|
||||
|
||||
namespace android {
|
||||
|
||||
/*
|
||||
* The input manager is the core of the system event processing.
|
||||
*
|
||||
* The input manager uses two threads.
|
||||
*
|
||||
* 1. The InputReaderThread (called "InputReader") reads and preprocesses raw input events,
|
||||
* applies policy, and posts messages to a queue managed by the DispatcherThread.
|
||||
* 2. The InputDispatcherThread (called "InputDispatcher") thread waits for new events on the
|
||||
* queue and asynchronously dispatches them to applications.
|
||||
*
|
||||
* By design, the InputReaderThread class and InputDispatcherThread class do not share any
|
||||
* internal state. Moreover, all communication is done one way from the InputReaderThread
|
||||
* into the InputDispatcherThread and never the reverse. Both classes may interact with the
|
||||
* InputDispatchPolicy, however.
|
||||
*
|
||||
* The InputManager class never makes any calls into Java itself. Instead, the
|
||||
* InputDispatchPolicy is responsible for performing all external interactions with the
|
||||
* system, including calling DVM services.
|
||||
*/
|
||||
class InputManagerInterface : public virtual RefBase {
|
||||
protected:
|
||||
InputManagerInterface() { }
|
||||
virtual ~InputManagerInterface() { }
|
||||
|
||||
public:
|
||||
/* Starts the input manager threads. */
|
||||
virtual status_t start() = 0;
|
||||
|
||||
/* Stops the input manager threads and waits for them to exit. */
|
||||
virtual status_t stop() = 0;
|
||||
|
||||
/* Gets the input reader. */
|
||||
virtual sp<InputReaderInterface> getReader() = 0;
|
||||
|
||||
/* Gets the input dispatcher. */
|
||||
virtual sp<InputDispatcherInterface> getDispatcher() = 0;
|
||||
};
|
||||
|
||||
class InputManager : public InputManagerInterface {
|
||||
protected:
|
||||
virtual ~InputManager();
|
||||
|
||||
public:
|
||||
InputManager(
|
||||
const sp<EventHubInterface>& eventHub,
|
||||
const sp<InputReaderPolicyInterface>& readerPolicy,
|
||||
const sp<InputDispatcherPolicyInterface>& dispatcherPolicy);
|
||||
|
||||
// (used for testing purposes)
|
||||
InputManager(
|
||||
const sp<InputReaderInterface>& reader,
|
||||
const sp<InputDispatcherInterface>& dispatcher);
|
||||
|
||||
virtual status_t start();
|
||||
virtual status_t stop();
|
||||
|
||||
virtual sp<InputReaderInterface> getReader();
|
||||
virtual sp<InputDispatcherInterface> getDispatcher();
|
||||
|
||||
private:
|
||||
sp<InputReaderInterface> mReader;
|
||||
sp<InputReaderThread> mReaderThread;
|
||||
|
||||
sp<InputDispatcherInterface> mDispatcher;
|
||||
sp<InputDispatcherThread> mDispatcherThread;
|
||||
|
||||
void initialize();
|
||||
};
|
||||
|
||||
} // namespace android
|
||||
|
||||
#endif // _UI_INPUT_MANAGER_H
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
|
|
@ -1,71 +0,0 @@
|
|||
/*
|
||||
* Copyright (C) 2011 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.
|
||||
*/
|
||||
|
||||
#define LOG_TAG "InputWindow"
|
||||
#define LOG_NDEBUG 0
|
||||
|
||||
#include "InputWindow.h"
|
||||
|
||||
#include <cutils/log.h>
|
||||
|
||||
#include <ui/Rect.h>
|
||||
#include <ui/Region.h>
|
||||
|
||||
namespace android {
|
||||
|
||||
// --- InputWindowInfo ---
|
||||
void InputWindowInfo::addTouchableRegion(const Rect& region) {
|
||||
touchableRegion.orSelf(region);
|
||||
}
|
||||
|
||||
bool InputWindowInfo::touchableRegionContainsPoint(int32_t x, int32_t y) const {
|
||||
return touchableRegion.contains(x,y);
|
||||
}
|
||||
|
||||
bool InputWindowInfo::frameContainsPoint(int32_t x, int32_t y) const {
|
||||
return x >= frameLeft && x <= frameRight
|
||||
&& y >= frameTop && y <= frameBottom;
|
||||
}
|
||||
|
||||
bool InputWindowInfo::isTrustedOverlay() const {
|
||||
return layoutParamsType == TYPE_INPUT_METHOD
|
||||
|| layoutParamsType == TYPE_INPUT_METHOD_DIALOG
|
||||
|| layoutParamsType == TYPE_SECURE_SYSTEM_OVERLAY;
|
||||
}
|
||||
|
||||
bool InputWindowInfo::supportsSplitTouch() const {
|
||||
return layoutParamsFlags & FLAG_SPLIT_TOUCH;
|
||||
}
|
||||
|
||||
|
||||
// --- InputWindowHandle ---
|
||||
|
||||
InputWindowHandle::InputWindowHandle(const sp<InputApplicationHandle>& inputApplicationHandle) :
|
||||
inputApplicationHandle(inputApplicationHandle), mInfo(NULL) {
|
||||
}
|
||||
|
||||
InputWindowHandle::~InputWindowHandle() {
|
||||
delete mInfo;
|
||||
}
|
||||
|
||||
void InputWindowHandle::releaseInfo() {
|
||||
if (mInfo) {
|
||||
delete mInfo;
|
||||
mInfo = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace android
|
||||
|
|
@ -1,209 +0,0 @@
|
|||
/*
|
||||
* Copyright (C) 2011 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_WINDOW_H
|
||||
#define _UI_INPUT_WINDOW_H
|
||||
|
||||
#include <input/Input.h>
|
||||
#include <input/InputTransport.h>
|
||||
#include <ui/Rect.h>
|
||||
#include <ui/Region.h>
|
||||
#include <utils/RefBase.h>
|
||||
#include <utils/Timers.h>
|
||||
#include <utils/String8.h>
|
||||
|
||||
#include "InputApplication.h"
|
||||
|
||||
namespace android {
|
||||
|
||||
|
||||
/*
|
||||
* Describes the properties of a window that can receive input.
|
||||
*/
|
||||
struct InputWindowInfo {
|
||||
// Window flags from WindowManager.LayoutParams
|
||||
enum {
|
||||
FLAG_ALLOW_LOCK_WHILE_SCREEN_ON = 0x00000001,
|
||||
FLAG_DIM_BEHIND = 0x00000002,
|
||||
FLAG_BLUR_BEHIND = 0x00000004,
|
||||
FLAG_NOT_FOCUSABLE = 0x00000008,
|
||||
FLAG_NOT_TOUCHABLE = 0x00000010,
|
||||
FLAG_NOT_TOUCH_MODAL = 0x00000020,
|
||||
FLAG_TOUCHABLE_WHEN_WAKING = 0x00000040,
|
||||
FLAG_KEEP_SCREEN_ON = 0x00000080,
|
||||
FLAG_LAYOUT_IN_SCREEN = 0x00000100,
|
||||
FLAG_LAYOUT_NO_LIMITS = 0x00000200,
|
||||
FLAG_FULLSCREEN = 0x00000400,
|
||||
FLAG_FORCE_NOT_FULLSCREEN = 0x00000800,
|
||||
FLAG_DITHER = 0x00001000,
|
||||
FLAG_SECURE = 0x00002000,
|
||||
FLAG_SCALED = 0x00004000,
|
||||
FLAG_IGNORE_CHEEK_PRESSES = 0x00008000,
|
||||
FLAG_LAYOUT_INSET_DECOR = 0x00010000,
|
||||
FLAG_ALT_FOCUSABLE_IM = 0x00020000,
|
||||
FLAG_WATCH_OUTSIDE_TOUCH = 0x00040000,
|
||||
FLAG_SHOW_WHEN_LOCKED = 0x00080000,
|
||||
FLAG_SHOW_WALLPAPER = 0x00100000,
|
||||
FLAG_TURN_SCREEN_ON = 0x00200000,
|
||||
FLAG_DISMISS_KEYGUARD = 0x00400000,
|
||||
FLAG_SPLIT_TOUCH = 0x00800000,
|
||||
FLAG_SLIPPERY = 0x20000000,
|
||||
FLAG_NEEDS_MENU_KEY = 0x40000000,
|
||||
};
|
||||
|
||||
// Private Window flags from WindowManager.LayoutParams
|
||||
enum {
|
||||
PRIVATE_FLAG_SYSTEM_ERROR = 0x00000100,
|
||||
};
|
||||
|
||||
// Window types from WindowManager.LayoutParams
|
||||
enum {
|
||||
FIRST_APPLICATION_WINDOW = 1,
|
||||
TYPE_BASE_APPLICATION = 1,
|
||||
TYPE_APPLICATION = 2,
|
||||
TYPE_APPLICATION_STARTING = 3,
|
||||
LAST_APPLICATION_WINDOW = 99,
|
||||
FIRST_SUB_WINDOW = 1000,
|
||||
TYPE_APPLICATION_PANEL = FIRST_SUB_WINDOW,
|
||||
TYPE_APPLICATION_MEDIA = FIRST_SUB_WINDOW+1,
|
||||
TYPE_APPLICATION_SUB_PANEL = FIRST_SUB_WINDOW+2,
|
||||
TYPE_APPLICATION_ATTACHED_DIALOG = FIRST_SUB_WINDOW+3,
|
||||
TYPE_APPLICATION_MEDIA_OVERLAY = FIRST_SUB_WINDOW+4,
|
||||
LAST_SUB_WINDOW = 1999,
|
||||
FIRST_SYSTEM_WINDOW = 2000,
|
||||
TYPE_STATUS_BAR = FIRST_SYSTEM_WINDOW,
|
||||
TYPE_SEARCH_BAR = FIRST_SYSTEM_WINDOW+1,
|
||||
TYPE_PHONE = FIRST_SYSTEM_WINDOW+2,
|
||||
TYPE_SYSTEM_ALERT = FIRST_SYSTEM_WINDOW+3,
|
||||
TYPE_KEYGUARD = FIRST_SYSTEM_WINDOW+4,
|
||||
TYPE_TOAST = FIRST_SYSTEM_WINDOW+5,
|
||||
TYPE_SYSTEM_OVERLAY = FIRST_SYSTEM_WINDOW+6,
|
||||
TYPE_PRIORITY_PHONE = FIRST_SYSTEM_WINDOW+7,
|
||||
TYPE_SYSTEM_DIALOG = FIRST_SYSTEM_WINDOW+8,
|
||||
TYPE_KEYGUARD_DIALOG = FIRST_SYSTEM_WINDOW+9,
|
||||
TYPE_SYSTEM_ERROR = FIRST_SYSTEM_WINDOW+10,
|
||||
TYPE_INPUT_METHOD = FIRST_SYSTEM_WINDOW+11,
|
||||
TYPE_INPUT_METHOD_DIALOG= FIRST_SYSTEM_WINDOW+12,
|
||||
TYPE_WALLPAPER = FIRST_SYSTEM_WINDOW+13,
|
||||
TYPE_STATUS_BAR_PANEL = FIRST_SYSTEM_WINDOW+14,
|
||||
TYPE_SECURE_SYSTEM_OVERLAY = FIRST_SYSTEM_WINDOW+15,
|
||||
TYPE_DRAG = FIRST_SYSTEM_WINDOW+16,
|
||||
TYPE_STATUS_BAR_SUB_PANEL = FIRST_SYSTEM_WINDOW+17,
|
||||
TYPE_POINTER = FIRST_SYSTEM_WINDOW+18,
|
||||
TYPE_NAVIGATION_BAR = FIRST_SYSTEM_WINDOW+19,
|
||||
TYPE_VOLUME_OVERLAY = FIRST_SYSTEM_WINDOW+20,
|
||||
TYPE_BOOT_PROGRESS = FIRST_SYSTEM_WINDOW+21,
|
||||
LAST_SYSTEM_WINDOW = 2999,
|
||||
};
|
||||
|
||||
enum {
|
||||
INPUT_FEATURE_DISABLE_TOUCH_PAD_GESTURES = 0x00000001,
|
||||
INPUT_FEATURE_NO_INPUT_CHANNEL = 0x00000002,
|
||||
INPUT_FEATURE_DISABLE_USER_ACTIVITY = 0x00000004,
|
||||
};
|
||||
|
||||
sp<InputChannel> inputChannel;
|
||||
String8 name;
|
||||
int32_t layoutParamsFlags;
|
||||
int32_t layoutParamsPrivateFlags;
|
||||
int32_t layoutParamsType;
|
||||
nsecs_t dispatchingTimeout;
|
||||
int32_t frameLeft;
|
||||
int32_t frameTop;
|
||||
int32_t frameRight;
|
||||
int32_t frameBottom;
|
||||
float scaleFactor;
|
||||
Region touchableRegion;
|
||||
bool visible;
|
||||
bool canReceiveKeys;
|
||||
bool hasFocus;
|
||||
bool hasWallpaper;
|
||||
bool paused;
|
||||
int32_t layer;
|
||||
int32_t ownerPid;
|
||||
int32_t ownerUid;
|
||||
int32_t inputFeatures;
|
||||
int32_t displayId;
|
||||
|
||||
void addTouchableRegion(const Rect& region);
|
||||
|
||||
bool touchableRegionContainsPoint(int32_t x, int32_t y) const;
|
||||
bool frameContainsPoint(int32_t x, int32_t y) const;
|
||||
|
||||
/* Returns true if the window is of a trusted type that is allowed to silently
|
||||
* overlay other windows for the purpose of implementing the secure views feature.
|
||||
* Trusted overlays, such as IME windows, can partly obscure other windows without causing
|
||||
* motion events to be delivered to them with AMOTION_EVENT_FLAG_WINDOW_IS_OBSCURED.
|
||||
*/
|
||||
bool isTrustedOverlay() const;
|
||||
|
||||
bool supportsSplitTouch() const;
|
||||
};
|
||||
|
||||
|
||||
/*
|
||||
* Handle for a window that can receive input.
|
||||
*
|
||||
* Used by the native input dispatcher to indirectly refer to the window manager objects
|
||||
* that describe a window.
|
||||
*/
|
||||
class InputWindowHandle : public RefBase {
|
||||
public:
|
||||
const sp<InputApplicationHandle> inputApplicationHandle;
|
||||
|
||||
inline const InputWindowInfo* getInfo() const {
|
||||
return mInfo;
|
||||
}
|
||||
|
||||
inline sp<InputChannel> getInputChannel() const {
|
||||
return mInfo ? mInfo->inputChannel : NULL;
|
||||
}
|
||||
|
||||
inline String8 getName() const {
|
||||
return mInfo ? mInfo->name : String8("<invalid>");
|
||||
}
|
||||
|
||||
inline nsecs_t getDispatchingTimeout(nsecs_t defaultValue) const {
|
||||
return mInfo ? mInfo->dispatchingTimeout : defaultValue;
|
||||
}
|
||||
|
||||
/**
|
||||
* Requests that the state of this object be updated to reflect
|
||||
* the most current available information about the application.
|
||||
*
|
||||
* This method should only be called from within the input dispatcher's
|
||||
* critical section.
|
||||
*
|
||||
* Returns true on success, or false if the handle is no longer valid.
|
||||
*/
|
||||
virtual bool updateInfo() = 0;
|
||||
|
||||
/**
|
||||
* Releases the storage used by the associated information when it is
|
||||
* no longer needed.
|
||||
*/
|
||||
void releaseInfo();
|
||||
|
||||
protected:
|
||||
InputWindowHandle(const sp<InputApplicationHandle>& inputApplicationHandle);
|
||||
virtual ~InputWindowHandle();
|
||||
|
||||
InputWindowInfo* mInfo;
|
||||
};
|
||||
|
||||
} // namespace android
|
||||
|
||||
#endif // _UI_INPUT_WINDOW_H
|
||||
|
|
@ -1,105 +0,0 @@
|
|||
/*
|
||||
* Copyright (C) 2014 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 _INPUTFLINGER_POINTER_CONTROLLER_INTERFACE_H
|
||||
#define _INPUTFLINGER_POINTER_CONTROLLER_INTERFACE_H
|
||||
|
||||
#include <input/Input.h>
|
||||
#include <utils/BitSet.h>
|
||||
#include <utils/RefBase.h>
|
||||
|
||||
namespace android {
|
||||
|
||||
/**
|
||||
* Interface for tracking a mouse / touch pad pointer and touch pad spots.
|
||||
*
|
||||
* The spots are sprites on screen that visually represent the positions of
|
||||
* fingers
|
||||
*
|
||||
* The pointer controller is responsible for providing synchronization and for tracking
|
||||
* display orientation changes if needed.
|
||||
*/
|
||||
class PointerControllerInterface : public virtual RefBase {
|
||||
protected:
|
||||
PointerControllerInterface() { }
|
||||
virtual ~PointerControllerInterface() { }
|
||||
|
||||
public:
|
||||
/* Gets the bounds of the region that the pointer can traverse.
|
||||
* Returns true if the bounds are available. */
|
||||
virtual bool getBounds(float* outMinX, float* outMinY,
|
||||
float* outMaxX, float* outMaxY) const = 0;
|
||||
|
||||
/* Move the pointer. */
|
||||
virtual void move(float deltaX, float deltaY) = 0;
|
||||
|
||||
/* Sets a mask that indicates which buttons are pressed. */
|
||||
virtual void setButtonState(int32_t buttonState) = 0;
|
||||
|
||||
/* Gets a mask that indicates which buttons are pressed. */
|
||||
virtual int32_t getButtonState() const = 0;
|
||||
|
||||
/* Sets the absolute location of the pointer. */
|
||||
virtual void setPosition(float x, float y) = 0;
|
||||
|
||||
/* Gets the absolute location of the pointer. */
|
||||
virtual void getPosition(float* outX, float* outY) const = 0;
|
||||
|
||||
enum Transition {
|
||||
// Fade/unfade immediately.
|
||||
TRANSITION_IMMEDIATE,
|
||||
// Fade/unfade gradually.
|
||||
TRANSITION_GRADUAL,
|
||||
};
|
||||
|
||||
/* Fades the pointer out now. */
|
||||
virtual void fade(Transition transition) = 0;
|
||||
|
||||
/* Makes the pointer visible if it has faded out.
|
||||
* The pointer never unfades itself automatically. This method must be called
|
||||
* by the client whenever the pointer is moved or a button is pressed and it
|
||||
* wants to ensure that the pointer becomes visible again. */
|
||||
virtual void unfade(Transition transition) = 0;
|
||||
|
||||
enum Presentation {
|
||||
// Show the mouse pointer.
|
||||
PRESENTATION_POINTER,
|
||||
// Show spots and a spot anchor in place of the mouse pointer.
|
||||
PRESENTATION_SPOT,
|
||||
};
|
||||
|
||||
/* Sets the mode of the pointer controller. */
|
||||
virtual void setPresentation(Presentation presentation) = 0;
|
||||
|
||||
/* Sets the spots for the current gesture.
|
||||
* The spots are not subject to the inactivity timeout like the pointer
|
||||
* itself it since they are expected to remain visible for so long as
|
||||
* the fingers are on the touch pad.
|
||||
*
|
||||
* The values of the AMOTION_EVENT_AXIS_PRESSURE axis is significant.
|
||||
* For spotCoords, pressure != 0 indicates that the spot's location is being
|
||||
* pressed (not hovering).
|
||||
*/
|
||||
virtual void setSpots(const PointerCoords* spotCoords, const uint32_t* spotIdToIndex,
|
||||
BitSet32 spotIdBits) = 0;
|
||||
|
||||
/* Removes all spots. */
|
||||
virtual void clearSpots() = 0;
|
||||
};
|
||||
|
||||
} // namespace android
|
||||
|
||||
#endif // _INPUTFLINGER_POINTER_CONTROLLER_INTERFACE_H
|
||||
Loading…
Reference in New Issue