| /* |
| * Copyright (C) 2021 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 "../dispatcher/LatencyTracker.h" |
| #include "../InputDeviceMetricsSource.h" |
| #include "NotifyArgsBuilders.h" |
| #include "android/input.h" |
| |
| #include <android-base/logging.h> |
| #include <android-base/properties.h> |
| #include <binder/Binder.h> |
| #include <gtest/gtest.h> |
| #include <input/PrintTools.h> |
| #include <inttypes.h> |
| #include <linux/input.h> |
| #include <log/log.h> |
| |
| #define TAG "LatencyTracker_test" |
| |
| using android::base::HwTimeoutMultiplier; |
| using android::inputdispatcher::InputEventTimeline; |
| using android::inputdispatcher::LatencyTracker; |
| |
| namespace android::inputdispatcher { |
| |
| namespace { |
| |
| constexpr DeviceId DEVICE_ID = 100; |
| |
| static InputDeviceInfo generateTestDeviceInfo(uint16_t vendorId, uint16_t productId, |
| DeviceId deviceId) { |
| InputDeviceIdentifier identifier; |
| identifier.vendor = vendorId; |
| identifier.product = productId; |
| auto info = InputDeviceInfo(); |
| info.initialize(deviceId, /*generation=*/1, /*controllerNumber=*/1, identifier, "Test Device", |
| /*isExternal=*/false, /*hasMic=*/false, ui::LogicalDisplayId::INVALID); |
| return info; |
| } |
| |
| void setDefaultInputDeviceInfo(LatencyTracker& tracker) { |
| InputDeviceInfo deviceInfo = generateTestDeviceInfo(/*vendorId=*/0, /*productId=*/0, DEVICE_ID); |
| tracker.setInputDevices({deviceInfo}); |
| } |
| |
| const auto FIRST_TOUCH_POINTER = PointerBuilder(/*id=*/0, ToolType::FINGER).x(100).y(200); |
| |
| /** |
| * This is a convenience method for comparing timelines that also prints the difference between |
| * the two structures. This helps debugging when the timelines don't match. |
| * @param received the timeline that was actually received |
| * @param expected the timeline that we expected to receive |
| * @return true if the two timelines match, false otherwise. |
| */ |
| bool timelinesAreEqual(const InputEventTimeline& received, const InputEventTimeline& expected) { |
| LOG_IF(ERROR, expected.eventTime != received.eventTime) |
| << "Received timeline with eventTime=" << received.eventTime |
| << " instead of expected eventTime=" << expected.eventTime; |
| LOG_IF(ERROR, expected.readTime != received.readTime) |
| << "Received timeline with readTime=" << received.readTime |
| << " instead of expected readTime=" << expected.readTime; |
| LOG_IF(ERROR, expected.vendorId != received.vendorId) |
| << "Received timeline with vendorId=" << received.vendorId |
| << " instead of expected vendorId=" << expected.vendorId; |
| LOG_IF(ERROR, expected.productId != received.productId) |
| << "Received timeline with productId=" << received.productId |
| << " instead of expected productId=" << expected.productId; |
| LOG_IF(ERROR, expected.sources != received.sources) |
| << "Received timeline with sources=" << dumpSet(received.sources, ftl::enum_string) |
| << " instead of expected sources=" << dumpSet(expected.sources, ftl::enum_string); |
| LOG_IF(ERROR, expected.inputEventActionType != received.inputEventActionType) |
| << "Received timeline with inputEventActionType=" |
| << ftl::enum_string(received.inputEventActionType) |
| << " instead of expected inputEventActionType=" |
| << ftl::enum_string(expected.inputEventActionType); |
| |
| return received == expected; |
| } |
| |
| } // namespace |
| |
| const std::chrono::duration ANR_TIMEOUT = std::chrono::milliseconds( |
| android::os::IInputConstants::UNMULTIPLIED_DEFAULT_DISPATCHING_TIMEOUT_MILLIS * |
| HwTimeoutMultiplier()); |
| |
| InputEventTimeline getTestTimeline() { |
| InputEventTimeline t( |
| /*eventTime=*/2, |
| /*readTime=*/3, |
| /*vendorId=*/0, |
| /*productId=*/0, {InputDeviceUsageSource::TOUCHSCREEN}, |
| /*inputEventActionType=*/InputEventActionType::UNKNOWN_INPUT_EVENT); |
| ConnectionTimeline expectedCT(/*deliveryTime=*/6, /*consumeTime=*/7, /*finishTime=*/8); |
| std::array<nsecs_t, GraphicsTimeline::SIZE> graphicsTimeline{}; |
| graphicsTimeline[GraphicsTimeline::GPU_COMPLETED_TIME] = 9; |
| graphicsTimeline[GraphicsTimeline::PRESENT_TIME] = 10; |
| expectedCT.setGraphicsTimeline(graphicsTimeline); |
| t.connectionTimelines.emplace(sp<BBinder>::make(), expectedCT); |
| return t; |
| } |
| |
| // --- LatencyTrackerTest --- |
| class LatencyTrackerTest : public testing::Test, public InputEventTimelineProcessor { |
| protected: |
| std::unique_ptr<LatencyTracker> mTracker; |
| sp<IBinder> connection1; |
| sp<IBinder> connection2; |
| |
| void SetUp() override { |
| connection1 = sp<BBinder>::make(); |
| connection2 = sp<BBinder>::make(); |
| |
| mTracker = std::make_unique<LatencyTracker>(*this); |
| setDefaultInputDeviceInfo(*mTracker); |
| } |
| void TearDown() override {} |
| |
| void triggerEventReporting(nsecs_t lastEventTime); |
| |
| void assertReceivedTimeline(const InputEventTimeline& timeline); |
| /** |
| * Timelines can be received in any order (order is not guaranteed). So if we are expecting more |
| * than 1 timeline, use this function to check that the set of received timelines matches |
| * what we expected. |
| */ |
| void assertReceivedTimelines(const std::vector<InputEventTimeline>& timelines); |
| |
| private: |
| void processTimeline(const InputEventTimeline& timeline) override { |
| mReceivedTimelines.push_back(timeline); |
| } |
| void pushLatencyStatistics() override {} |
| std::string dump(const char* prefix) const { return ""; }; |
| std::deque<InputEventTimeline> mReceivedTimelines; |
| }; |
| |
| /** |
| * Send an event that would trigger the reporting of all of the events that are at least as old as |
| * the provided 'lastEventTime'. |
| */ |
| void LatencyTrackerTest::triggerEventReporting(nsecs_t lastEventTime) { |
| const nsecs_t triggerEventTime = |
| lastEventTime + std::chrono::nanoseconds(ANR_TIMEOUT).count() + 1; |
| mTracker->trackListener(MotionArgsBuilder(AMOTION_EVENT_ACTION_CANCEL, |
| AINPUT_SOURCE_TOUCHSCREEN, /*inputEventId=*/1) |
| .eventTime(triggerEventTime) |
| .readTime(3) |
| .deviceId(DEVICE_ID) |
| .pointer(FIRST_TOUCH_POINTER) |
| .build()); |
| } |
| |
| void LatencyTrackerTest::assertReceivedTimeline(const InputEventTimeline& expectedTimeline) { |
| ASSERT_FALSE(mReceivedTimelines.empty()); |
| const InputEventTimeline& received = mReceivedTimelines.front(); |
| ASSERT_TRUE(timelinesAreEqual(received, expectedTimeline)); |
| mReceivedTimelines.pop_front(); |
| } |
| |
| /** |
| * We are essentially comparing two multisets, but without constructing them. |
| * This comparison is inefficient, but it avoids having to construct a set, and also avoids the |
| * declaration of copy constructor for ConnectionTimeline. |
| * We ensure that collections A and B have the same size, that for every element in A, there is an |
| * equal element in B, and for every element in B there is an equal element in A. |
| */ |
| void LatencyTrackerTest::assertReceivedTimelines(const std::vector<InputEventTimeline>& timelines) { |
| ASSERT_EQ(timelines.size(), mReceivedTimelines.size()); |
| for (const InputEventTimeline& expectedTimeline : timelines) { |
| bool found = false; |
| for (const InputEventTimeline& receivedTimeline : mReceivedTimelines) { |
| if (receivedTimeline == expectedTimeline) { |
| found = true; |
| break; |
| } |
| } |
| if (!found) { |
| for (const InputEventTimeline& receivedTimeline : mReceivedTimelines) { |
| LOG(ERROR) << "Received timeline with eventTime=" << receivedTimeline.eventTime; |
| } |
| } |
| ASSERT_TRUE(found) << "Could not find expected timeline with eventTime=" |
| << expectedTimeline.eventTime; |
| } |
| for (const InputEventTimeline& receivedTimeline : mReceivedTimelines) { |
| bool found = false; |
| for (const InputEventTimeline& expectedTimeline : timelines) { |
| if (receivedTimeline == expectedTimeline) { |
| found = true; |
| break; |
| } |
| } |
| ASSERT_TRUE(found) << "Could not find received timeline with eventTime=" |
| << receivedTimeline.eventTime; |
| } |
| mReceivedTimelines.clear(); |
| } |
| |
| /** |
| * Ensure that calling 'trackListener' in isolation only creates an inputflinger timeline, without |
| * any additional ConnectionTimeline's. |
| */ |
| TEST_F(LatencyTrackerTest, TrackListener_DoesNotTriggerReporting) { |
| mTracker->trackListener(MotionArgsBuilder(AMOTION_EVENT_ACTION_CANCEL, |
| AINPUT_SOURCE_TOUCHSCREEN, /*inputEventId=*/1) |
| .eventTime(2) |
| .readTime(3) |
| .deviceId(DEVICE_ID) |
| .pointer(FIRST_TOUCH_POINTER) |
| .build()); |
| triggerEventReporting(/*eventTime=*/2); |
| assertReceivedTimeline( |
| InputEventTimeline{/*eventTime=*/2, |
| /*readTime=*/3, |
| /*vendorId=*/0, |
| /*productID=*/0, |
| {InputDeviceUsageSource::TOUCHSCREEN}, |
| /*inputEventActionType=*/InputEventActionType::UNKNOWN_INPUT_EVENT}); |
| } |
| |
| /** |
| * A single call to trackFinishedEvent should not cause a timeline to be reported. |
| */ |
| TEST_F(LatencyTrackerTest, TrackFinishedEvent_DoesNotTriggerReporting) { |
| mTracker->trackFinishedEvent(/*inputEventId=*/1, connection1, /*deliveryTime=*/2, |
| /*consumeTime=*/3, /*finishTime=*/4); |
| triggerEventReporting(/*eventTime=*/4); |
| assertReceivedTimelines({}); |
| } |
| |
| /** |
| * A single call to trackGraphicsLatency should not cause a timeline to be reported. |
| */ |
| TEST_F(LatencyTrackerTest, TrackGraphicsLatency_DoesNotTriggerReporting) { |
| std::array<nsecs_t, GraphicsTimeline::SIZE> graphicsTimeline; |
| graphicsTimeline[GraphicsTimeline::GPU_COMPLETED_TIME] = 2; |
| graphicsTimeline[GraphicsTimeline::PRESENT_TIME] = 3; |
| mTracker->trackGraphicsLatency(/*inputEventId=*/1, connection2, graphicsTimeline); |
| triggerEventReporting(/*eventTime=*/3); |
| assertReceivedTimelines({}); |
| } |
| |
| TEST_F(LatencyTrackerTest, TrackAllParameters_ReportsFullTimeline) { |
| constexpr int32_t inputEventId = 1; |
| InputEventTimeline expected = getTestTimeline(); |
| |
| const auto& [connectionToken, expectedCT] = *expected.connectionTimelines.begin(); |
| |
| mTracker->trackListener( |
| MotionArgsBuilder(AMOTION_EVENT_ACTION_CANCEL, AINPUT_SOURCE_TOUCHSCREEN, inputEventId) |
| .eventTime(expected.eventTime) |
| .readTime(expected.readTime) |
| .deviceId(DEVICE_ID) |
| .pointer(FIRST_TOUCH_POINTER) |
| .build()); |
| mTracker->trackFinishedEvent(inputEventId, connectionToken, expectedCT.deliveryTime, |
| expectedCT.consumeTime, expectedCT.finishTime); |
| mTracker->trackGraphicsLatency(inputEventId, connectionToken, expectedCT.graphicsTimeline); |
| |
| triggerEventReporting(expected.eventTime); |
| assertReceivedTimeline(expected); |
| } |
| |
| /** |
| * Send 2 events with the same inputEventId, but different eventTime's. Ensure that no crash occurs, |
| * and that the tracker drops such events completely. |
| */ |
| TEST_F(LatencyTrackerTest, WhenDuplicateEventsAreReported_DoesNotCrash) { |
| constexpr nsecs_t inputEventId = 1; |
| constexpr nsecs_t readTime = 3; // does not matter for this test |
| |
| // In the following 2 calls to trackListener, the inputEventId's are the same, but event times |
| // are different. |
| mTracker->trackListener( |
| MotionArgsBuilder(AMOTION_EVENT_ACTION_CANCEL, AINPUT_SOURCE_TOUCHSCREEN, inputEventId) |
| .eventTime(1) |
| .readTime(readTime) |
| .deviceId(DEVICE_ID) |
| .pointer(FIRST_TOUCH_POINTER) |
| .build()); |
| mTracker->trackListener( |
| MotionArgsBuilder(AMOTION_EVENT_ACTION_CANCEL, AINPUT_SOURCE_TOUCHSCREEN, inputEventId) |
| .eventTime(2) |
| .readTime(readTime) |
| .deviceId(DEVICE_ID) |
| .pointer(FIRST_TOUCH_POINTER) |
| .build()); |
| |
| triggerEventReporting(/*eventTime=*/2); |
| // Since we sent duplicate input events, the tracker should just delete all of them, because it |
| // does not have enough information to properly track them. |
| assertReceivedTimelines({}); |
| } |
| |
| TEST_F(LatencyTrackerTest, MultipleEvents_AreReportedConsistently) { |
| constexpr int32_t inputEventId1 = 1; |
| InputEventTimeline timeline1( |
| /*eventTime*/ 2, |
| /*readTime*/ 3, |
| /*vendorId=*/0, |
| /*productId=*/0, {InputDeviceUsageSource::TOUCHSCREEN}, |
| /*inputEventType=*/InputEventActionType::UNKNOWN_INPUT_EVENT); |
| timeline1.connectionTimelines.emplace(connection1, |
| ConnectionTimeline(/*deliveryTime*/ 6, /*consumeTime*/ 7, |
| /*finishTime*/ 8)); |
| ConnectionTimeline& connectionTimeline1 = timeline1.connectionTimelines.begin()->second; |
| std::array<nsecs_t, GraphicsTimeline::SIZE> graphicsTimeline1; |
| graphicsTimeline1[GraphicsTimeline::GPU_COMPLETED_TIME] = 9; |
| graphicsTimeline1[GraphicsTimeline::PRESENT_TIME] = 10; |
| connectionTimeline1.setGraphicsTimeline(std::move(graphicsTimeline1)); |
| |
| constexpr int32_t inputEventId2 = 10; |
| InputEventTimeline timeline2( |
| /*eventTime=*/20, |
| /*readTime=*/30, |
| /*vendorId=*/0, |
| /*productId=*/0, {InputDeviceUsageSource::TOUCHSCREEN}, |
| /*inputEventActionType=*/InputEventActionType::UNKNOWN_INPUT_EVENT); |
| timeline2.connectionTimelines.emplace(connection2, |
| ConnectionTimeline(/*deliveryTime=*/60, |
| /*consumeTime=*/70, |
| /*finishTime=*/80)); |
| ConnectionTimeline& connectionTimeline2 = timeline2.connectionTimelines.begin()->second; |
| std::array<nsecs_t, GraphicsTimeline::SIZE> graphicsTimeline2; |
| graphicsTimeline2[GraphicsTimeline::GPU_COMPLETED_TIME] = 90; |
| graphicsTimeline2[GraphicsTimeline::PRESENT_TIME] = 100; |
| connectionTimeline2.setGraphicsTimeline(std::move(graphicsTimeline2)); |
| |
| // Start processing first event |
| mTracker->trackListener( |
| MotionArgsBuilder(AMOTION_EVENT_ACTION_CANCEL, AINPUT_SOURCE_TOUCHSCREEN, inputEventId1) |
| .eventTime(timeline1.eventTime) |
| .readTime(timeline1.readTime) |
| .deviceId(DEVICE_ID) |
| .pointer(FIRST_TOUCH_POINTER) |
| .build()); |
| // Start processing second event |
| mTracker->trackListener( |
| MotionArgsBuilder(AMOTION_EVENT_ACTION_CANCEL, AINPUT_SOURCE_TOUCHSCREEN, inputEventId2) |
| .eventTime(timeline2.eventTime) |
| .readTime(timeline2.readTime) |
| .deviceId(DEVICE_ID) |
| .pointer(FIRST_TOUCH_POINTER) |
| .build()); |
| mTracker->trackFinishedEvent(inputEventId1, connection1, connectionTimeline1.deliveryTime, |
| connectionTimeline1.consumeTime, connectionTimeline1.finishTime); |
| |
| mTracker->trackFinishedEvent(inputEventId2, connection2, connectionTimeline2.deliveryTime, |
| connectionTimeline2.consumeTime, connectionTimeline2.finishTime); |
| mTracker->trackGraphicsLatency(inputEventId1, connection1, |
| connectionTimeline1.graphicsTimeline); |
| mTracker->trackGraphicsLatency(inputEventId2, connection2, |
| connectionTimeline2.graphicsTimeline); |
| // Now both events should be completed |
| triggerEventReporting(timeline2.eventTime); |
| assertReceivedTimelines({timeline1, timeline2}); |
| } |
| |
| /** |
| * Check that LatencyTracker consistently tracks events even if there are many incomplete events. |
| */ |
| TEST_F(LatencyTrackerTest, IncompleteEvents_AreHandledConsistently) { |
| InputEventTimeline timeline = getTestTimeline(); |
| std::vector<InputEventTimeline> expectedTimelines; |
| const ConnectionTimeline& expectedCT = timeline.connectionTimelines.begin()->second; |
| const sp<IBinder>& token = timeline.connectionTimelines.begin()->first; |
| |
| for (size_t i = 1; i <= 100; i++) { |
| mTracker->trackListener(MotionArgsBuilder(AMOTION_EVENT_ACTION_CANCEL, |
| AINPUT_SOURCE_TOUCHSCREEN, /*inputEventId=*/i) |
| .eventTime(timeline.eventTime) |
| .readTime(timeline.readTime) |
| .deviceId(DEVICE_ID) |
| .pointer(FIRST_TOUCH_POINTER) |
| .build()); |
| expectedTimelines.push_back(InputEventTimeline{timeline.eventTime, timeline.readTime, |
| timeline.vendorId, timeline.productId, |
| timeline.sources, |
| timeline.inputEventActionType}); |
| } |
| // Now, complete the first event that was sent. |
| mTracker->trackFinishedEvent(/*inputEventId=*/1, token, expectedCT.deliveryTime, |
| expectedCT.consumeTime, expectedCT.finishTime); |
| mTracker->trackGraphicsLatency(/*inputEventId=*/1, token, expectedCT.graphicsTimeline); |
| |
| expectedTimelines[0].connectionTimelines.emplace(token, std::move(expectedCT)); |
| triggerEventReporting(timeline.eventTime); |
| assertReceivedTimelines(expectedTimelines); |
| } |
| |
| /** |
| * For simplicity of the implementation, LatencyTracker only starts tracking an event when |
| * 'trackListener' is invoked. |
| * Both 'trackFinishedEvent' and 'trackGraphicsLatency' should not start a new event. |
| * If they are received before 'trackListener' (which should not be possible), they are ignored. |
| */ |
| TEST_F(LatencyTrackerTest, EventsAreTracked_WhenTrackListenerIsCalledFirst) { |
| constexpr int32_t inputEventId = 1; |
| InputEventTimeline expected = getTestTimeline(); |
| const ConnectionTimeline& expectedCT = expected.connectionTimelines.begin()->second; |
| mTracker->trackFinishedEvent(inputEventId, connection1, expectedCT.deliveryTime, |
| expectedCT.consumeTime, expectedCT.finishTime); |
| mTracker->trackGraphicsLatency(inputEventId, connection1, expectedCT.graphicsTimeline); |
| |
| mTracker->trackListener( |
| MotionArgsBuilder(AMOTION_EVENT_ACTION_CANCEL, AINPUT_SOURCE_TOUCHSCREEN, inputEventId) |
| .eventTime(expected.eventTime) |
| .readTime(expected.readTime) |
| .deviceId(DEVICE_ID) |
| .pointer(FIRST_TOUCH_POINTER) |
| .build()); |
| triggerEventReporting(expected.eventTime); |
| assertReceivedTimeline(InputEventTimeline{expected.eventTime, expected.readTime, |
| expected.vendorId, expected.productId, |
| expected.sources, expected.inputEventActionType}); |
| } |
| |
| /** |
| * Check that LatencyTracker has the received timeline that contains the correctly |
| * resolved product ID, vendor ID and source for a particular device ID from |
| * among a list of devices. |
| */ |
| TEST_F(LatencyTrackerTest, TrackListenerCheck_DeviceInfoFieldsInputEventTimeline) { |
| constexpr int32_t inputEventId = 1; |
| InputEventTimeline timeline( |
| /*eventTime*/ 2, /*readTime*/ 3, |
| /*vendorId=*/50, /*productId=*/60, {InputDeviceUsageSource::STYLUS_DIRECT}, |
| /*inputEventActionType=*/InputEventActionType::UNKNOWN_INPUT_EVENT); |
| InputDeviceInfo deviceInfo1 = generateTestDeviceInfo( |
| /*vendorId=*/5, /*productId=*/6, /*deviceId=*/DEVICE_ID + 1); |
| InputDeviceInfo deviceInfo2 = generateTestDeviceInfo( |
| /*vendorId=*/50, /*productId=*/60, /*deviceId=*/DEVICE_ID); |
| deviceInfo2.addSource(AINPUT_SOURCE_TOUCHSCREEN); |
| deviceInfo2.addSource(AINPUT_SOURCE_STYLUS); |
| |
| mTracker->setInputDevices({deviceInfo1, deviceInfo2}); |
| mTracker->trackListener( |
| MotionArgsBuilder(AMOTION_EVENT_ACTION_CANCEL, |
| AINPUT_SOURCE_TOUCHSCREEN | AINPUT_SOURCE_STYLUS, inputEventId) |
| |
| .eventTime(timeline.eventTime) |
| .readTime(timeline.readTime) |
| .deviceId(DEVICE_ID) |
| .pointer(PointerBuilder(/*id=*/0, ToolType::STYLUS).x(100).y(200)) |
| .build()); |
| triggerEventReporting(timeline.eventTime); |
| assertReceivedTimeline(timeline); |
| } |
| |
| /** |
| * Check that InputEventActionType is correctly assigned to InputEventTimeline in trackListener. |
| */ |
| TEST_F(LatencyTrackerTest, TrackListenerCheck_InputEventActionTypeFieldInputEventTimeline) { |
| constexpr int32_t inputEventId = 1; |
| // Create timelines for different event types (Motion, Key) |
| InputEventTimeline motionDownTimeline( |
| /*eventTime*/ 2, /*readTime*/ 3, |
| /*vendorId*/ 0, /*productId*/ 0, {InputDeviceUsageSource::TOUCHSCREEN}, |
| InputEventActionType::MOTION_ACTION_DOWN); |
| |
| InputEventTimeline motionMoveTimeline( |
| /*eventTime*/ 4, /*readTime*/ 5, |
| /*vendorId*/ 0, /*productId*/ 0, {InputDeviceUsageSource::TOUCHSCREEN}, |
| InputEventActionType::MOTION_ACTION_MOVE); |
| |
| InputEventTimeline motionUpTimeline( |
| /*eventTime*/ 6, /*readTime*/ 7, |
| /*vendorId*/ 0, /*productId*/ 0, {InputDeviceUsageSource::TOUCHSCREEN}, |
| InputEventActionType::MOTION_ACTION_UP); |
| |
| InputEventTimeline keyDownTimeline( |
| /*eventTime*/ 8, /*readTime*/ 9, |
| /*vendorId*/ 0, /*productId*/ 0, {InputDeviceUsageSource::BUTTONS}, |
| InputEventActionType::KEY); |
| |
| InputEventTimeline keyUpTimeline( |
| /*eventTime*/ 10, /*readTime*/ 11, |
| /*vendorId*/ 0, /*productId*/ 0, {InputDeviceUsageSource::BUTTONS}, |
| InputEventActionType::KEY); |
| |
| InputEventTimeline unknownTimeline( |
| /*eventTime*/ 12, /*readTime*/ 13, |
| /*vendorId*/ 0, /*productId*/ 0, {InputDeviceUsageSource::TOUCHSCREEN}, |
| InputEventActionType::UNKNOWN_INPUT_EVENT); |
| |
| mTracker->trackListener( |
| MotionArgsBuilder(AMOTION_EVENT_ACTION_DOWN, AINPUT_SOURCE_TOUCHSCREEN, inputEventId) |
| .eventTime(motionDownTimeline.eventTime) |
| .readTime(motionDownTimeline.readTime) |
| .deviceId(DEVICE_ID) |
| .pointer(FIRST_TOUCH_POINTER) |
| .build()); |
| mTracker->trackListener(MotionArgsBuilder(AMOTION_EVENT_ACTION_MOVE, AINPUT_SOURCE_TOUCHSCREEN, |
| inputEventId + 1) |
| .eventTime(motionMoveTimeline.eventTime) |
| .readTime(motionMoveTimeline.readTime) |
| .deviceId(DEVICE_ID) |
| .pointer(FIRST_TOUCH_POINTER) |
| .build()); |
| mTracker->trackListener( |
| MotionArgsBuilder(AMOTION_EVENT_ACTION_UP, AINPUT_SOURCE_TOUCHSCREEN, inputEventId + 2) |
| .eventTime(motionUpTimeline.eventTime) |
| .readTime(motionUpTimeline.readTime) |
| .deviceId(DEVICE_ID) |
| .pointer(FIRST_TOUCH_POINTER) |
| .build()); |
| mTracker->trackListener( |
| KeyArgsBuilder(AKEY_EVENT_ACTION_DOWN, AINPUT_SOURCE_KEYBOARD, inputEventId + 3) |
| .eventTime(keyDownTimeline.eventTime) |
| .readTime(keyDownTimeline.readTime) |
| .deviceId(DEVICE_ID) |
| .build()); |
| mTracker->trackListener( |
| KeyArgsBuilder(AKEY_EVENT_ACTION_UP, AINPUT_SOURCE_KEYBOARD, inputEventId + 4) |
| .eventTime(keyUpTimeline.eventTime) |
| .readTime(keyUpTimeline.readTime) |
| .deviceId(DEVICE_ID) |
| .build()); |
| mTracker->trackListener(MotionArgsBuilder(AMOTION_EVENT_ACTION_POINTER_DOWN, |
| AINPUT_SOURCE_TOUCHSCREEN, inputEventId + 5) |
| .eventTime(unknownTimeline.eventTime) |
| .readTime(unknownTimeline.readTime) |
| .deviceId(DEVICE_ID) |
| .pointer(FIRST_TOUCH_POINTER) |
| .build()); |
| |
| triggerEventReporting(unknownTimeline.eventTime); |
| |
| std::vector<InputEventTimeline> expectedTimelines = {motionDownTimeline, motionMoveTimeline, |
| motionUpTimeline, keyDownTimeline, |
| keyUpTimeline, unknownTimeline}; |
| assertReceivedTimelines(expectedTimelines); |
| } |
| |
| } // namespace android::inputdispatcher |