/* * 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_DISPATCH_POLICY_H #define _UI_INPUT_DISPATCH_POLICY_H /** * Native input dispatch policy. */ #include #include #include #include #include #include namespace android { class InputChannel; /* * An input target specifies how an input event is to be dispatched to a particular window * including the window's input channel, control flags, a timeout, and an X / Y offset to * be added to input event coordinates to compensate for the absolute position of the * window area. */ struct InputTarget { enum { /* This flag indicates that subsequent event delivery should be held until the * current event is delivered to this target or a timeout occurs. */ FLAG_SYNC = 0x01, /* This flag indicates that a MotionEvent with ACTION_DOWN falls outside of the area of * this target and so should instead be delivered as an ACTION_OUTSIDE to this target. */ FLAG_OUTSIDE = 0x02, /* This flag indicates that a KeyEvent or MotionEvent is being canceled. * In the case of a key event, it should be delivered with KeyEvent.FLAG_CANCELED set. * In the case of a motion event, it should be delivered as MotionEvent.ACTION_CANCEL. */ FLAG_CANCEL = 0x04 }; // The input channel to be targeted. sp inputChannel; // Flags for the input target. int32_t flags; // The timeout for event delivery to this target in nanoseconds. Or -1 if none. nsecs_t timeout; // The x and y offset to add to a MotionEvent as it is delivered. // (ignored for KeyEvents) float xOffset, yOffset; }; /* * Input dispatch policy interface. * * The input dispatch policy is used by the input dispatcher to interact with the * Window Manager and other system components. This separation of concerns keeps * the input dispatcher relatively free of special case logic such as is required * to determine the target of iput events, when to wake the device, how to interact * with key guard, and when to transition to the home screen. * * The actual implementation is partially supported by callbacks into the DVM * via JNI. This class is also mocked in the input dispatcher unit tests since * it is an ideal test seam. */ class InputDispatchPolicyInterface : public virtual RefBase { protected: InputDispatchPolicyInterface() { } virtual ~InputDispatchPolicyInterface() { } public: enum { ROTATION_0 = 0, ROTATION_90 = 1, ROTATION_180 = 2, ROTATION_270 = 3 }; enum { // The input dispatcher should do nothing and discard the input unless other // flags are set. ACTION_NONE = 0, // The input dispatcher should dispatch the input to the application. ACTION_DISPATCH = 0x00000001, // The input dispatcher should perform special filtering in preparation for // a pending app switch. ACTION_APP_SWITCH_COMING = 0x00000002, // The input dispatcher should add POLICY_FLAG_WOKE_HERE to the policy flags it // passes through the dispatch pipeline. ACTION_WOKE_HERE = 0x00000004, // The input dispatcher should add POLICY_FLAG_BRIGHT_HERE to the policy flags it // passes through the dispatch pipeline. ACTION_BRIGHT_HERE = 0x00000008 }; enum { TOUCHSCREEN_UNDEFINED = 0, TOUCHSCREEN_NOTOUCH = 1, TOUCHSCREEN_STYLUS = 2, TOUCHSCREEN_FINGER = 3 }; enum { KEYBOARD_UNDEFINED = 0, KEYBOARD_NOKEYS = 1, KEYBOARD_QWERTY = 2, KEYBOARD_12KEY = 3 }; enum { NAVIGATION_UNDEFINED = 0, NAVIGATION_NONAV = 1, NAVIGATION_DPAD = 2, NAVIGATION_TRACKBALL = 3, NAVIGATION_WHEEL = 4 }; struct VirtualKeyDefinition { int32_t scanCode; // configured position data, specified in display coords int32_t centerX; int32_t centerY; int32_t width; int32_t height; }; /* Gets information about the display with the specified id. * Returns true if the display info is available, false otherwise. */ virtual bool getDisplayInfo(int32_t displayId, int32_t* width, int32_t* height, int32_t* orientation) = 0; virtual void notifyConfigurationChanged(nsecs_t when, int32_t touchScreenConfig, int32_t keyboardConfig, int32_t navigationConfig) = 0; virtual void notifyLidSwitchChanged(nsecs_t when, bool lidOpen) = 0; virtual void virtualKeyFeedback(nsecs_t when, int32_t deviceId, int32_t action, int32_t flags, int32_t keyCode, int32_t scanCode, int32_t metaState, nsecs_t downTime) = 0; virtual int32_t interceptKey(nsecs_t when, int32_t deviceId, bool down, int32_t keyCode, int32_t scanCode, uint32_t policyFlags) = 0; virtual int32_t interceptTrackball(nsecs_t when, bool buttonChanged, bool buttonDown, bool rolled) = 0; virtual int32_t interceptTouch(nsecs_t when) = 0; virtual bool allowKeyRepeat() = 0; virtual nsecs_t getKeyRepeatTimeout() = 0; virtual void getKeyEventTargets(KeyEvent* keyEvent, uint32_t policyFlags, Vector& outTargets) = 0; virtual void getMotionEventTargets(MotionEvent* motionEvent, uint32_t policyFlags, Vector& outTargets) = 0; /* Determine whether to turn on some hacks we have to improve the touch interaction with a * certain device whose screen currently is not all that good. */ virtual bool filterTouchEvents() = 0; /* Determine whether to turn on some hacks to improve touch interaction with another device * where touch coordinate data can get corrupted. */ virtual bool filterJumpyTouchEvents() = 0; virtual void getVirtualKeyDefinitions(const String8& deviceName, Vector& outVirtualKeyDefinitions) = 0; virtual void getExcludedDeviceNames(Vector& outExcludedDeviceNames) = 0; }; } // namespace android #endif // _UI_INPUT_DISPATCH_POLICY_H