| /* | |
| * 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. | |
| */ | |
| #define LOG_TAG "NotifyArgs" | |
| #define ATRACE_TAG ATRACE_TAG_INPUT | |
| #include "NotifyArgs.h" | |
| #include <android-base/stringprintf.h> | |
| #include <android/log.h> | |
| #include <math.h> | |
| #include <utils/Trace.h> | |
| using android::base::StringPrintf; | |
| namespace android { | |
| // --- NotifyConfigurationChangedArgs --- | |
| NotifyConfigurationChangedArgs::NotifyConfigurationChangedArgs(int32_t id, nsecs_t eventTime) | |
| : id(id), eventTime(eventTime) {} | |
| // --- NotifyKeyArgs --- | |
| NotifyKeyArgs::NotifyKeyArgs(int32_t id, nsecs_t eventTime, nsecs_t readTime, int32_t deviceId, | |
| uint32_t source, int32_t displayId, uint32_t policyFlags, | |
| int32_t action, int32_t flags, int32_t keyCode, int32_t scanCode, | |
| int32_t metaState, nsecs_t downTime) | |
| : id(id), | |
| eventTime(eventTime), | |
| deviceId(deviceId), | |
| source(source), | |
| displayId(displayId), | |
| policyFlags(policyFlags), | |
| action(action), | |
| flags(flags), | |
| keyCode(keyCode), | |
| scanCode(scanCode), | |
| metaState(metaState), | |
| downTime(downTime), | |
| readTime(readTime) {} | |
| // --- NotifyMotionArgs --- | |
| NotifyMotionArgs::NotifyMotionArgs( | |
| int32_t id, nsecs_t eventTime, nsecs_t readTime, int32_t deviceId, uint32_t source, | |
| int32_t displayId, uint32_t policyFlags, int32_t action, int32_t actionButton, | |
| int32_t flags, int32_t metaState, int32_t buttonState, MotionClassification classification, | |
| int32_t edgeFlags, uint32_t pointerCount, const PointerProperties* pointerProperties, | |
| const PointerCoords* pointerCoords, float xPrecision, float yPrecision, | |
| float xCursorPosition, float yCursorPosition, nsecs_t downTime, | |
| const std::vector<TouchVideoFrame>& videoFrames) | |
| : id(id), | |
| eventTime(eventTime), | |
| deviceId(deviceId), | |
| source(source), | |
| displayId(displayId), | |
| policyFlags(policyFlags), | |
| action(action), | |
| actionButton(actionButton), | |
| flags(flags), | |
| metaState(metaState), | |
| buttonState(buttonState), | |
| classification(classification), | |
| edgeFlags(edgeFlags), | |
| pointerCount(pointerCount), | |
| xPrecision(xPrecision), | |
| yPrecision(yPrecision), | |
| xCursorPosition(xCursorPosition), | |
| yCursorPosition(yCursorPosition), | |
| downTime(downTime), | |
| readTime(readTime), | |
| videoFrames(videoFrames) { | |
| 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) | |
| : id(other.id), | |
| eventTime(other.eventTime), | |
| deviceId(other.deviceId), | |
| source(other.source), | |
| displayId(other.displayId), | |
| policyFlags(other.policyFlags), | |
| action(other.action), | |
| actionButton(other.actionButton), | |
| flags(other.flags), | |
| metaState(other.metaState), | |
| buttonState(other.buttonState), | |
| classification(other.classification), | |
| edgeFlags(other.edgeFlags), | |
| pointerCount(other.pointerCount), | |
| xPrecision(other.xPrecision), | |
| yPrecision(other.yPrecision), | |
| xCursorPosition(other.xCursorPosition), | |
| yCursorPosition(other.yCursorPosition), | |
| downTime(other.downTime), | |
| readTime(other.readTime), | |
| videoFrames(other.videoFrames) { | |
| for (uint32_t i = 0; i < pointerCount; i++) { | |
| pointerProperties[i].copyFrom(other.pointerProperties[i]); | |
| pointerCoords[i].copyFrom(other.pointerCoords[i]); | |
| } | |
| } | |
| static inline bool isCursorPositionEqual(float lhs, float rhs) { | |
| return (isnan(lhs) && isnan(rhs)) || lhs == rhs; | |
| } | |
| bool NotifyMotionArgs::operator==(const NotifyMotionArgs& rhs) const { | |
| bool equal = id == rhs.id && eventTime == rhs.eventTime && readTime == rhs.readTime && | |
| deviceId == rhs.deviceId && source == rhs.source && displayId == rhs.displayId && | |
| policyFlags == rhs.policyFlags && action == rhs.action && | |
| actionButton == rhs.actionButton && flags == rhs.flags && metaState == rhs.metaState && | |
| buttonState == rhs.buttonState && classification == rhs.classification && | |
| edgeFlags == rhs.edgeFlags && | |
| pointerCount == rhs.pointerCount | |
| // PointerProperties and PointerCoords are compared separately below | |
| && xPrecision == rhs.xPrecision && yPrecision == rhs.yPrecision && | |
| isCursorPositionEqual(xCursorPosition, rhs.xCursorPosition) && | |
| isCursorPositionEqual(yCursorPosition, rhs.yCursorPosition) && | |
| downTime == rhs.downTime && videoFrames == rhs.videoFrames; | |
| if (!equal) { | |
| return false; | |
| } | |
| for (size_t i = 0; i < pointerCount; i++) { | |
| equal = pointerProperties[i] == rhs.pointerProperties[i] && | |
| pointerCoords[i] == rhs.pointerCoords[i]; | |
| if (!equal) { | |
| return false; | |
| } | |
| } | |
| return true; | |
| } | |
| std::string NotifyMotionArgs::dump() const { | |
| std::string coords; | |
| for (uint32_t i = 0; i < pointerCount; i++) { | |
| if (!coords.empty()) { | |
| coords += ", "; | |
| } | |
| coords += StringPrintf("{%" PRIu32 ": ", i); | |
| coords += | |
| StringPrintf("id=%" PRIu32 " x=%.1f y=%.1f pressure=%.1f", pointerProperties[i].id, | |
| pointerCoords[i].getX(), pointerCoords[i].getY(), | |
| pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_PRESSURE)); | |
| const int32_t toolType = pointerProperties[i].toolType; | |
| if (toolType != AMOTION_EVENT_TOOL_TYPE_FINGER) { | |
| coords += StringPrintf(" toolType=%s", motionToolTypeToString(toolType)); | |
| } | |
| const float major = pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR); | |
| const float minor = pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR); | |
| const float orientation = pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_ORIENTATION); | |
| if (major != 0 || minor != 0) { | |
| coords += StringPrintf(" major=%.1f minor=%.1f orientation=%.1f", major, minor, | |
| orientation); | |
| } | |
| coords += "}"; | |
| } | |
| return StringPrintf("NotifyMotionArgs(id=%" PRId32 ", eventTime=%" PRId64 ", deviceId=%" PRId32 | |
| ", source=%s, action=%s, pointerCount=%" PRIu32 | |
| " pointers=%s, flags=0x%08x)", | |
| id, eventTime, deviceId, inputEventSourceToString(source).c_str(), | |
| MotionEvent::actionToString(action).c_str(), pointerCount, coords.c_str(), | |
| flags); | |
| } | |
| // --- NotifySwitchArgs --- | |
| NotifySwitchArgs::NotifySwitchArgs(int32_t id, nsecs_t eventTime, uint32_t policyFlags, | |
| uint32_t switchValues, uint32_t switchMask) | |
| : id(id), | |
| eventTime(eventTime), | |
| policyFlags(policyFlags), | |
| switchValues(switchValues), | |
| switchMask(switchMask) {} | |
| // --- NotifySensorArgs --- | |
| NotifySensorArgs::NotifySensorArgs(int32_t id, nsecs_t eventTime, int32_t deviceId, uint32_t source, | |
| InputDeviceSensorType sensorType, | |
| InputDeviceSensorAccuracy accuracy, bool accuracyChanged, | |
| nsecs_t hwTimestamp, std::vector<float> values) | |
| : id(id), | |
| eventTime(eventTime), | |
| deviceId(deviceId), | |
| source(source), | |
| sensorType(sensorType), | |
| accuracy(accuracy), | |
| accuracyChanged(accuracyChanged), | |
| hwTimestamp(hwTimestamp), | |
| values(std::move(values)) {} | |
| // --- NotifyVibratorStateArgs --- | |
| NotifyVibratorStateArgs::NotifyVibratorStateArgs(int32_t id, nsecs_t eventTime, int32_t deviceId, | |
| bool isOn) | |
| : id(id), eventTime(eventTime), deviceId(deviceId), isOn(isOn) {} | |
| // --- NotifyDeviceResetArgs --- | |
| NotifyDeviceResetArgs::NotifyDeviceResetArgs(int32_t id, nsecs_t eventTime, int32_t deviceId) | |
| : id(id), eventTime(eventTime), deviceId(deviceId) {} | |
| // --- NotifyPointerCaptureChangedArgs --- | |
| NotifyPointerCaptureChangedArgs::NotifyPointerCaptureChangedArgs( | |
| int32_t id, nsecs_t eventTime, const PointerCaptureRequest& request) | |
| : id(id), eventTime(eventTime), request(request) {} | |
| // Helper to std::visit with lambdas. | |
| template <typename... V> | |
| struct Visitor : V... {}; | |
| // explicit deduction guide (not needed as of C++20) | |
| template <typename... V> | |
| Visitor(V...) -> Visitor<V...>; | |
| const char* toString(const NotifyArgs& args) { | |
| Visitor toStringVisitor{ | |
| [&](const NotifyConfigurationChangedArgs&) { return "NotifyConfigurationChangedArgs"; }, | |
| [&](const NotifyKeyArgs&) { return "NotifyKeyArgs"; }, | |
| [&](const NotifyMotionArgs&) { return "NotifyMotionArgs"; }, | |
| [&](const NotifySensorArgs&) { return "NotifySensorArgs"; }, | |
| [&](const NotifySwitchArgs&) { return "NotifySwitchArgs"; }, | |
| [&](const NotifyDeviceResetArgs&) { return "NotifyDeviceResetArgs"; }, | |
| [&](const NotifyPointerCaptureChangedArgs&) { | |
| return "NotifyPointerCaptureChangedArgs"; | |
| }, | |
| [&](const NotifyVibratorStateArgs&) { return "NotifyVibratorStateArgs"; }, | |
| }; | |
| return std::visit(toStringVisitor, args); | |
| } | |
| } // namespace android |