| /* | |
| * Copyright (C) 2022 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. | |
| */ | |
| #include "InputCommonConverter.h" | |
| using namespace ::aidl::android::hardware::input; | |
| namespace android { | |
| static common::Source getSource(uint32_t source) { | |
| static_assert(static_cast<common::Source>(AINPUT_SOURCE_UNKNOWN) == common::Source::UNKNOWN, | |
| "SOURCE_UNKNOWN mismatch"); | |
| static_assert(static_cast<common::Source>(AINPUT_SOURCE_KEYBOARD) == common::Source::KEYBOARD, | |
| "SOURCE_KEYBOARD mismatch"); | |
| static_assert(static_cast<common::Source>(AINPUT_SOURCE_DPAD) == common::Source::DPAD, | |
| "SOURCE_DPAD mismatch"); | |
| static_assert(static_cast<common::Source>(AINPUT_SOURCE_GAMEPAD) == common::Source::GAMEPAD, | |
| "SOURCE_GAMEPAD mismatch"); | |
| static_assert(static_cast<common::Source>(AINPUT_SOURCE_TOUCHSCREEN) == | |
| common::Source::TOUCHSCREEN, | |
| "SOURCE_TOUCHSCREEN mismatch"); | |
| static_assert(static_cast<common::Source>(AINPUT_SOURCE_MOUSE) == common::Source::MOUSE, | |
| "SOURCE_MOUSE mismatch"); | |
| static_assert(static_cast<common::Source>(AINPUT_SOURCE_STYLUS) == common::Source::STYLUS, | |
| "SOURCE_STYLUS mismatch"); | |
| static_assert(static_cast<common::Source>(AINPUT_SOURCE_BLUETOOTH_STYLUS) == | |
| common::Source::BLUETOOTH_STYLUS, | |
| "SOURCE_BLUETOOTH_STYLUS mismatch"); | |
| static_assert(static_cast<common::Source>(AINPUT_SOURCE_TRACKBALL) == common::Source::TRACKBALL, | |
| "SOURCE_TRACKBALL mismatch"); | |
| static_assert(static_cast<common::Source>(AINPUT_SOURCE_MOUSE_RELATIVE) == | |
| common::Source::MOUSE_RELATIVE, | |
| "SOURCE_MOUSE_RELATIVE mismatch"); | |
| static_assert(static_cast<common::Source>(AINPUT_SOURCE_TOUCHPAD) == common::Source::TOUCHPAD, | |
| "SOURCE_TOUCHPAD mismatch"); | |
| static_assert(static_cast<common::Source>(AINPUT_SOURCE_TOUCH_NAVIGATION) == | |
| common::Source::TOUCH_NAVIGATION, | |
| "SOURCE_TOUCH_NAVIGATION mismatch"); | |
| static_assert(static_cast<common::Source>(AINPUT_SOURCE_JOYSTICK) == common::Source::JOYSTICK, | |
| "SOURCE_JOYSTICK mismatch"); | |
| static_assert(static_cast<common::Source>(AINPUT_SOURCE_ROTARY_ENCODER) == | |
| common::Source::ROTARY_ENCODER, | |
| "SOURCE_ROTARY_ENCODER mismatch"); | |
| static_assert(static_cast<common::Source>(AINPUT_SOURCE_HDMI) == common::Source::HDMI); | |
| static_assert(static_cast<common::Source>(AINPUT_SOURCE_SENSOR) == common::Source::SENSOR); | |
| static_assert(static_cast<common::Source>(AINPUT_SOURCE_ANY) == common::Source::ANY, | |
| "SOURCE_ANY mismatch"); | |
| return static_cast<common::Source>(source); | |
| } | |
| static common::Action getAction(int32_t actionMasked) { | |
| static_assert(static_cast<common::Action>(AMOTION_EVENT_ACTION_DOWN) == common::Action::DOWN, | |
| "ACTION_DOWN mismatch"); | |
| static_assert(static_cast<common::Action>(AMOTION_EVENT_ACTION_UP) == common::Action::UP, | |
| "ACTION_UP mismatch"); | |
| static_assert(static_cast<common::Action>(AMOTION_EVENT_ACTION_MOVE) == common::Action::MOVE, | |
| "ACTION_MOVE mismatch"); | |
| static_assert(static_cast<common::Action>(AMOTION_EVENT_ACTION_CANCEL) == | |
| common::Action::CANCEL, | |
| "ACTION_CANCEL mismatch"); | |
| static_assert(static_cast<common::Action>(AMOTION_EVENT_ACTION_OUTSIDE) == | |
| common::Action::OUTSIDE, | |
| "ACTION_OUTSIDE mismatch"); | |
| static_assert(static_cast<common::Action>(AMOTION_EVENT_ACTION_POINTER_DOWN) == | |
| common::Action::POINTER_DOWN, | |
| "ACTION_POINTER_DOWN mismatch"); | |
| static_assert(static_cast<common::Action>(AMOTION_EVENT_ACTION_POINTER_UP) == | |
| common::Action::POINTER_UP, | |
| "ACTION_POINTER_UP mismatch"); | |
| static_assert(static_cast<common::Action>(AMOTION_EVENT_ACTION_HOVER_MOVE) == | |
| common::Action::HOVER_MOVE, | |
| "ACTION_HOVER_MOVE mismatch"); | |
| static_assert(static_cast<common::Action>(AMOTION_EVENT_ACTION_SCROLL) == | |
| common::Action::SCROLL, | |
| "ACTION_SCROLL mismatch"); | |
| static_assert(static_cast<common::Action>(AMOTION_EVENT_ACTION_HOVER_ENTER) == | |
| common::Action::HOVER_ENTER, | |
| "ACTION_HOVER_ENTER mismatch"); | |
| static_assert(static_cast<common::Action>(AMOTION_EVENT_ACTION_HOVER_EXIT) == | |
| common::Action::HOVER_EXIT, | |
| "ACTION_HOVER_EXIT mismatch"); | |
| static_assert(static_cast<common::Action>(AMOTION_EVENT_ACTION_BUTTON_PRESS) == | |
| common::Action::BUTTON_PRESS, | |
| "ACTION_BUTTON_PRESS mismatch"); | |
| static_assert(static_cast<common::Action>(AMOTION_EVENT_ACTION_BUTTON_RELEASE) == | |
| common::Action::BUTTON_RELEASE, | |
| "ACTION_BUTTON_RELEASE mismatch"); | |
| return static_cast<common::Action>(actionMasked); | |
| } | |
| static common::Button getActionButton(int32_t actionButton) { | |
| static_assert(static_cast<common::Button>(0) == common::Button::NONE, "BUTTON_NONE mismatch"); | |
| static_assert(static_cast<common::Button>(AMOTION_EVENT_BUTTON_PRIMARY) == | |
| common::Button::PRIMARY, | |
| "BUTTON_PRIMARY mismatch"); | |
| static_assert(static_cast<common::Button>(AMOTION_EVENT_BUTTON_SECONDARY) == | |
| common::Button::SECONDARY, | |
| "BUTTON_SECONDARY mismatch"); | |
| static_assert(static_cast<common::Button>(AMOTION_EVENT_BUTTON_TERTIARY) == | |
| common::Button::TERTIARY, | |
| "BUTTON_TERTIARY mismatch"); | |
| static_assert(static_cast<common::Button>(AMOTION_EVENT_BUTTON_BACK) == common::Button::BACK, | |
| "BUTTON_BACK mismatch"); | |
| static_assert(static_cast<common::Button>(AMOTION_EVENT_BUTTON_FORWARD) == | |
| common::Button::FORWARD, | |
| "BUTTON_FORWARD mismatch"); | |
| static_assert(static_cast<common::Button>(AMOTION_EVENT_BUTTON_STYLUS_PRIMARY) == | |
| common::Button::STYLUS_PRIMARY, | |
| "BUTTON_STYLUS_PRIMARY mismatch"); | |
| static_assert(static_cast<common::Button>(AMOTION_EVENT_BUTTON_STYLUS_SECONDARY) == | |
| common::Button::STYLUS_SECONDARY, | |
| "BUTTON_STYLUS_SECONDARY mismatch"); | |
| return static_cast<common::Button>(actionButton); | |
| } | |
| static common::Flag getFlags(int32_t flags) { | |
| static_assert(static_cast<common::Flag>(AMOTION_EVENT_FLAG_WINDOW_IS_OBSCURED) == | |
| common::Flag::WINDOW_IS_OBSCURED); | |
| static_assert(static_cast<common::Flag>(AMOTION_EVENT_FLAG_IS_GENERATED_GESTURE) == | |
| common::Flag::IS_GENERATED_GESTURE); | |
| static_assert(static_cast<common::Flag>(AMOTION_EVENT_FLAG_TAINTED) == common::Flag::TAINTED); | |
| return static_cast<common::Flag>(flags); | |
| } | |
| static common::PolicyFlag getPolicyFlags(int32_t flags) { | |
| static_assert(static_cast<common::PolicyFlag>(POLICY_FLAG_WAKE) == common::PolicyFlag::WAKE); | |
| static_assert(static_cast<common::PolicyFlag>(POLICY_FLAG_VIRTUAL) == | |
| common::PolicyFlag::VIRTUAL); | |
| static_assert(static_cast<common::PolicyFlag>(POLICY_FLAG_FUNCTION) == | |
| common::PolicyFlag::FUNCTION); | |
| static_assert(static_cast<common::PolicyFlag>(POLICY_FLAG_GESTURE) == | |
| common::PolicyFlag::GESTURE); | |
| static_assert(static_cast<common::PolicyFlag>(POLICY_FLAG_INJECTED) == | |
| common::PolicyFlag::INJECTED); | |
| static_assert(static_cast<common::PolicyFlag>(POLICY_FLAG_TRUSTED) == | |
| common::PolicyFlag::TRUSTED); | |
| static_assert(static_cast<common::PolicyFlag>(POLICY_FLAG_FILTERED) == | |
| common::PolicyFlag::FILTERED); | |
| static_assert(static_cast<common::PolicyFlag>(POLICY_FLAG_DISABLE_KEY_REPEAT) == | |
| common::PolicyFlag::DISABLE_KEY_REPEAT); | |
| static_assert(static_cast<common::PolicyFlag>(POLICY_FLAG_INTERACTIVE) == | |
| common::PolicyFlag::INTERACTIVE); | |
| static_assert(static_cast<common::PolicyFlag>(POLICY_FLAG_PASS_TO_USER) == | |
| common::PolicyFlag::PASS_TO_USER); | |
| return static_cast<common::PolicyFlag>(flags); | |
| } | |
| static common::EdgeFlag getEdgeFlags(int32_t flags) { | |
| static_assert(static_cast<common::EdgeFlag>(AMOTION_EVENT_EDGE_FLAG_NONE) == | |
| common::EdgeFlag::NONE); | |
| static_assert(static_cast<common::EdgeFlag>(AMOTION_EVENT_EDGE_FLAG_TOP) == | |
| common::EdgeFlag::TOP); | |
| static_assert(static_cast<common::EdgeFlag>(AMOTION_EVENT_EDGE_FLAG_BOTTOM) == | |
| common::EdgeFlag::BOTTOM); | |
| static_assert(static_cast<common::EdgeFlag>(AMOTION_EVENT_EDGE_FLAG_LEFT) == | |
| common::EdgeFlag::LEFT); | |
| static_assert(static_cast<common::EdgeFlag>(AMOTION_EVENT_EDGE_FLAG_RIGHT) == | |
| common::EdgeFlag::RIGHT); | |
| return static_cast<common::EdgeFlag>(flags); | |
| } | |
| static common::Meta getMetastate(int32_t state) { | |
| static_assert(static_cast<common::Meta>(AMETA_NONE) == common::Meta::NONE); | |
| static_assert(static_cast<common::Meta>(AMETA_ALT_ON) == common::Meta::ALT_ON); | |
| static_assert(static_cast<common::Meta>(AMETA_ALT_LEFT_ON) == common::Meta::ALT_LEFT_ON); | |
| static_assert(static_cast<common::Meta>(AMETA_ALT_RIGHT_ON) == common::Meta::ALT_RIGHT_ON); | |
| static_assert(static_cast<common::Meta>(AMETA_SHIFT_ON) == common::Meta::SHIFT_ON); | |
| static_assert(static_cast<common::Meta>(AMETA_SHIFT_LEFT_ON) == common::Meta::SHIFT_LEFT_ON); | |
| static_assert(static_cast<common::Meta>(AMETA_SHIFT_RIGHT_ON) == common::Meta::SHIFT_RIGHT_ON); | |
| static_assert(static_cast<common::Meta>(AMETA_SYM_ON) == common::Meta::SYM_ON); | |
| static_assert(static_cast<common::Meta>(AMETA_FUNCTION_ON) == common::Meta::FUNCTION_ON); | |
| static_assert(static_cast<common::Meta>(AMETA_CTRL_ON) == common::Meta::CTRL_ON); | |
| static_assert(static_cast<common::Meta>(AMETA_CTRL_LEFT_ON) == common::Meta::CTRL_LEFT_ON); | |
| static_assert(static_cast<common::Meta>(AMETA_CTRL_RIGHT_ON) == common::Meta::CTRL_RIGHT_ON); | |
| static_assert(static_cast<common::Meta>(AMETA_META_ON) == common::Meta::META_ON); | |
| static_assert(static_cast<common::Meta>(AMETA_META_LEFT_ON) == common::Meta::META_LEFT_ON); | |
| static_assert(static_cast<common::Meta>(AMETA_META_RIGHT_ON) == common::Meta::META_RIGHT_ON); | |
| static_assert(static_cast<common::Meta>(AMETA_CAPS_LOCK_ON) == common::Meta::CAPS_LOCK_ON); | |
| static_assert(static_cast<common::Meta>(AMETA_NUM_LOCK_ON) == common::Meta::NUM_LOCK_ON); | |
| static_assert(static_cast<common::Meta>(AMETA_SCROLL_LOCK_ON) == common::Meta::SCROLL_LOCK_ON); | |
| return static_cast<common::Meta>(state); | |
| } | |
| static common::Button getButtonState(int32_t buttonState) { | |
| // No need for static_assert here. | |
| // The button values have already been asserted in getActionButton(..) above | |
| return static_cast<common::Button>(buttonState); | |
| } | |
| static common::ToolType getToolType(int32_t toolType) { | |
| static_assert(static_cast<common::ToolType>(AMOTION_EVENT_TOOL_TYPE_UNKNOWN) == | |
| common::ToolType::UNKNOWN); | |
| static_assert(static_cast<common::ToolType>(AMOTION_EVENT_TOOL_TYPE_FINGER) == | |
| common::ToolType::FINGER); | |
| static_assert(static_cast<common::ToolType>(AMOTION_EVENT_TOOL_TYPE_STYLUS) == | |
| common::ToolType::STYLUS); | |
| static_assert(static_cast<common::ToolType>(AMOTION_EVENT_TOOL_TYPE_MOUSE) == | |
| common::ToolType::MOUSE); | |
| static_assert(static_cast<common::ToolType>(AMOTION_EVENT_TOOL_TYPE_ERASER) == | |
| common::ToolType::ERASER); | |
| return static_cast<common::ToolType>(toolType); | |
| } | |
| // MotionEvent axes asserts | |
| static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_X) == common::Axis::X); | |
| static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_Y) == common::Axis::Y); | |
| static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_PRESSURE) == common::Axis::PRESSURE); | |
| static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_SIZE) == common::Axis::SIZE); | |
| static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_TOUCH_MAJOR) == | |
| common::Axis::TOUCH_MAJOR); | |
| static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_TOUCH_MINOR) == | |
| common::Axis::TOUCH_MINOR); | |
| static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_TOOL_MAJOR) == common::Axis::TOOL_MAJOR); | |
| static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_TOOL_MINOR) == common::Axis::TOOL_MINOR); | |
| static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_ORIENTATION) == | |
| common::Axis::ORIENTATION); | |
| static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_VSCROLL) == common::Axis::VSCROLL); | |
| static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_HSCROLL) == common::Axis::HSCROLL); | |
| static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_Z) == common::Axis::Z); | |
| static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_RX) == common::Axis::RX); | |
| static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_RY) == common::Axis::RY); | |
| static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_RZ) == common::Axis::RZ); | |
| static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_HAT_X) == common::Axis::HAT_X); | |
| static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_HAT_Y) == common::Axis::HAT_Y); | |
| static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_LTRIGGER) == common::Axis::LTRIGGER); | |
| static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_RTRIGGER) == common::Axis::RTRIGGER); | |
| static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_THROTTLE) == common::Axis::THROTTLE); | |
| static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_RUDDER) == common::Axis::RUDDER); | |
| static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_WHEEL) == common::Axis::WHEEL); | |
| static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_GAS) == common::Axis::GAS); | |
| static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_BRAKE) == common::Axis::BRAKE); | |
| static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_DISTANCE) == common::Axis::DISTANCE); | |
| static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_TILT) == common::Axis::TILT); | |
| static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_SCROLL) == common::Axis::SCROLL); | |
| static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_RELATIVE_X) == common::Axis::RELATIVE_X); | |
| static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_RELATIVE_Y) == common::Axis::RELATIVE_Y); | |
| static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_GENERIC_1) == common::Axis::GENERIC_1); | |
| static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_GENERIC_2) == common::Axis::GENERIC_2); | |
| static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_GENERIC_3) == common::Axis::GENERIC_3); | |
| static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_GENERIC_4) == common::Axis::GENERIC_4); | |
| static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_GENERIC_5) == common::Axis::GENERIC_5); | |
| static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_GENERIC_6) == common::Axis::GENERIC_6); | |
| static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_GENERIC_7) == common::Axis::GENERIC_7); | |
| static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_GENERIC_8) == common::Axis::GENERIC_8); | |
| static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_GENERIC_9) == common::Axis::GENERIC_9); | |
| static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_GENERIC_10) == common::Axis::GENERIC_10); | |
| static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_GENERIC_11) == common::Axis::GENERIC_11); | |
| static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_GENERIC_12) == common::Axis::GENERIC_12); | |
| static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_GENERIC_13) == common::Axis::GENERIC_13); | |
| static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_GENERIC_14) == common::Axis::GENERIC_14); | |
| static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_GENERIC_15) == common::Axis::GENERIC_15); | |
| static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_GENERIC_16) == common::Axis::GENERIC_16); | |
| // TODO(b/251196347): add GESTURE_{X,Y}_OFFSET, GESTURE_SCROLL_{X,Y}_DISTANCE, and | |
| // GESTURE_PINCH_SCALE_FACTOR. | |
| // If you added a new axis, consider whether this should also be exposed as a HAL axis. Update the | |
| // static_assert below and add the new axis here, or leave a comment summarizing your decision. | |
| static_assert(static_cast<common::Axis>(AMOTION_EVENT_MAXIMUM_VALID_AXIS_VALUE) == | |
| static_cast<common::Axis>(AMOTION_EVENT_AXIS_GESTURE_PINCH_SCALE_FACTOR)); | |
| static common::VideoFrame getHalVideoFrame(const TouchVideoFrame& frame) { | |
| common::VideoFrame out; | |
| out.width = frame.getWidth(); | |
| out.height = frame.getHeight(); | |
| std::vector<char16_t> unsignedData(frame.getData().begin(), frame.getData().end()); | |
| out.data = unsignedData; | |
| struct timeval timestamp = frame.getTimestamp(); | |
| out.timestamp = seconds_to_nanoseconds(timestamp.tv_sec) + | |
| microseconds_to_nanoseconds(timestamp.tv_usec); | |
| return out; | |
| } | |
| static std::vector<common::VideoFrame> convertVideoFrames( | |
| const std::vector<TouchVideoFrame>& frames) { | |
| std::vector<common::VideoFrame> out; | |
| for (const TouchVideoFrame& frame : frames) { | |
| out.push_back(getHalVideoFrame(frame)); | |
| } | |
| return out; | |
| } | |
| static void getHalPropertiesAndCoords(const NotifyMotionArgs& args, | |
| std::vector<common::PointerProperties>& outPointerProperties, | |
| std::vector<common::PointerCoords>& outPointerCoords) { | |
| outPointerProperties.reserve(args.pointerCount); | |
| outPointerCoords.reserve(args.pointerCount); | |
| for (size_t i = 0; i < args.pointerCount; i++) { | |
| common::PointerProperties properties; | |
| properties.id = args.pointerProperties[i].id; | |
| properties.toolType = getToolType(args.pointerProperties[i].toolType); | |
| outPointerProperties.push_back(properties); | |
| common::PointerCoords coords; | |
| // OK to copy bits because we have static_assert for pointerCoords axes | |
| coords.bits = args.pointerCoords[i].bits; | |
| coords.values = std::vector<float>(args.pointerCoords[i].values.cbegin(), | |
| args.pointerCoords[i].values.cbegin() + | |
| BitSet64::count(args.pointerCoords[i].bits)); | |
| outPointerCoords.push_back(coords); | |
| } | |
| } | |
| common::MotionEvent notifyMotionArgsToHalMotionEvent(const NotifyMotionArgs& args) { | |
| common::MotionEvent event; | |
| event.deviceId = args.deviceId; | |
| event.source = getSource(args.source); | |
| event.displayId = args.displayId; | |
| event.downTime = args.downTime; | |
| event.eventTime = args.eventTime; | |
| event.deviceTimestamp = 0; | |
| event.action = getAction(args.action & AMOTION_EVENT_ACTION_MASK); | |
| event.actionIndex = MotionEvent::getActionIndex(args.action); | |
| event.actionButton = getActionButton(args.actionButton); | |
| event.flags = getFlags(args.flags); | |
| event.policyFlags = getPolicyFlags(args.policyFlags); | |
| event.edgeFlags = getEdgeFlags(args.edgeFlags); | |
| event.metaState = getMetastate(args.metaState); | |
| event.buttonState = getButtonState(args.buttonState); | |
| event.xPrecision = args.xPrecision; | |
| event.yPrecision = args.yPrecision; | |
| std::vector<common::PointerProperties> pointerProperties; | |
| std::vector<common::PointerCoords> pointerCoords; | |
| getHalPropertiesAndCoords(args, /*out*/ pointerProperties, /*out*/ pointerCoords); | |
| event.pointerProperties = pointerProperties; | |
| event.pointerCoords = pointerCoords; | |
| event.frames = convertVideoFrames(args.videoFrames); | |
| return event; | |
| } | |
| } // namespace android |