Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 67d09ca8 authored by Prabir Pradhan's avatar Prabir Pradhan
Browse files

Metrics collector: Log a separate bus for USI styluses 

For USI styluses, Vendor IDs are assigned by USI, and are different from
the Vendor IDs for USB devices. Therefore, to identify a device from its
VID/PID, we need to know whether it is reporting USB product/vendor IDs
or USI ones.

Here, we introduce USI as a new bus enum value for metrics purposes.
This way, we can differentiate product identifiers based on the bus
through which it is using.

Bug: 299645968
Test: atest inputflinger_tests
Change-Id: I954e5a7c3db7d1ae3d0c6906923848fe5ced84f1
parent 3821b0df

services/inputflinger/InputDeviceMetricsCollector.cpp

+16 −8
Original line number Diff line number Diff line
@@ -41,7 +41,13 @@ const bool DEBUG = __android_log_is_loggable(ANDROID_LOG_DEBUG, LOG_TAG, ANDROID 


constexpr size_t INTERACTIONS_QUEUE_CAPACITY = 500;



int32_t linuxBusToInputDeviceBusEnum(int32_t linuxBus) {

int32_t linuxBusToInputDeviceBusEnum(int32_t linuxBus, bool isUsiStylus) {

    if (isUsiStylus) {

        // This is a stylus connected over the Universal Stylus Initiative (USI) protocol.

        // For metrics purposes, we treat this protocol as a separate bus.

        return util::INPUT_DEVICE_USAGE_REPORTED__DEVICE_BUS__USI;

    }



    // When adding cases to this switch, also add them to the copy of this method in

    // TouchpadInputMapper.cpp.

    // TODO(b/286394420): deduplicate this method with the one in TouchpadInputMapper.cpp.
@@ -58,11 +64,12 @@ int32_t linuxBusToInputDeviceBusEnum(int32_t linuxBus) { 
class : public InputDeviceMetricsLogger {

    nanoseconds getCurrentTime() override { return nanoseconds(systemTime(SYSTEM_TIME_MONOTONIC)); }



    void logInputDeviceUsageReported(const InputDeviceIdentifier& identifier,

    void logInputDeviceUsageReported(const InputDeviceInfo& info,

                                     const DeviceUsageReport& report) override {

        const int32_t durationMillis =

                std::chrono::duration_cast<std::chrono::milliseconds>(report.usageDuration).count();

        const static std::vector<int32_t> empty;

        const auto& identifier = info.getIdentifier();



        ALOGD_IF(DEBUG, "Usage session reported for device: %s", identifier.name.c_str());

        ALOGD_IF(DEBUG, "    Total duration: %dms", durationMillis);
@@ -90,7 +97,9 @@ class : public InputDeviceMetricsLogger { 
                     durMillis);

        }

        util::stats_write(util::INPUTDEVICE_USAGE_REPORTED, identifier.vendor, identifier.product,

                          identifier.version, linuxBusToInputDeviceBusEnum(identifier.bus),

                          identifier.version,

                          linuxBusToInputDeviceBusEnum(identifier.bus,

                                                       info.getUsiVersion().has_value()),

                          durationMillis, sources, durationsPerSource, uids, durationsPerUid);

    }

} sStatsdLogger;
@@ -295,21 +304,21 @@ void InputDeviceMetricsCollector::onInputDevicesChanged(const std::vector<InputD 
        if (newDeviceInfos.count(deviceId) != 0) {

            continue;

        }

        onInputDeviceRemoved(deviceId, info.getIdentifier());

        onInputDeviceRemoved(deviceId, info);

    }



    std::swap(newDeviceInfos, mLoggedDeviceInfos);

}



void InputDeviceMetricsCollector::onInputDeviceRemoved(DeviceId deviceId,

                                                       const InputDeviceIdentifier& identifier) {

                                                       const InputDeviceInfo& info) {

    auto it = mActiveUsageSessions.find(deviceId);

    if (it == mActiveUsageSessions.end()) {

        return;

    }

    // Report usage for that device if there is an active session.

    auto& [_, activeSession] = *it;

    mLogger.logInputDeviceUsageReported(identifier, activeSession.finishSession());

    mLogger.logInputDeviceUsageReported(info, activeSession.finishSession());

    mActiveUsageSessions.erase(it);



    // We don't remove this from mLoggedDeviceInfos because it will be updated in
@@ -365,8 +374,7 @@ void InputDeviceMetricsCollector::reportCompletedSessions() { 
        auto activeSessionIt = mActiveUsageSessions.find(deviceId);

        LOG_ALWAYS_FATAL_IF(activeSessionIt == mActiveUsageSessions.end());

        auto& [_, activeSession] = *activeSessionIt;

        mLogger.logInputDeviceUsageReported(infoIt->second.getIdentifier(),

                                            activeSession.finishSession());

        mLogger.logInputDeviceUsageReported(infoIt->second, activeSession.finishSession());

        mActiveUsageSessions.erase(activeSessionIt);

    }

}

services/inputflinger/InputDeviceMetricsCollector.h

+2 −3
Original line number Diff line number Diff line
@@ -110,8 +110,7 @@ public: 
        UidUsageBreakdown uidBreakdown;

    };



    virtual void logInputDeviceUsageReported(const InputDeviceIdentifier&,

                                             const DeviceUsageReport&) = 0;

    virtual void logInputDeviceUsageReported(const InputDeviceInfo&, const DeviceUsageReport&) = 0;

    virtual ~InputDeviceMetricsLogger() = default;

};
@@ -189,7 +188,7 @@ private: 
    std::map<DeviceId, ActiveSession> mActiveUsageSessions;



    void onInputDevicesChanged(const std::vector<InputDeviceInfo>& infos);

    void onInputDeviceRemoved(DeviceId deviceId, const InputDeviceIdentifier& identifier);

    void onInputDeviceRemoved(DeviceId deviceId, const InputDeviceInfo& info);

    using SourceProvider = std::function<std::set<InputDeviceUsageSource>(const InputDeviceInfo&)>;

    void onInputDeviceUsage(DeviceId deviceId, std::chrono::nanoseconds eventTime,

                            const SourceProvider& getSources);

services/inputflinger/reader/mapper/TouchpadInputMapper.cpp

+9 −3
Original line number Diff line number Diff line
@@ -125,7 +125,13 @@ void gestureInterpreterCallback(void* clientData, const Gesture* gesture) { 
    mapper->consumeGesture(gesture);

}



int32_t linuxBusToInputDeviceBusEnum(int32_t linuxBus) {

int32_t linuxBusToInputDeviceBusEnum(int32_t linuxBus, bool isUsiStylus) {

    if (isUsiStylus) {

        // This is a stylus connected over the Universal Stylus Initiative (USI) protocol.

        // For metrics purposes, we treat this protocol as a separate bus.

        return util::INPUT_DEVICE_USAGE_REPORTED__DEVICE_BUS__USI;

    }



    // When adding cases to this switch, also add them to the copy of this method in

    // InputDeviceMetricsCollector.cpp.

    // TODO(b/286394420): deduplicate this method with the one in InputDeviceMetricsCollector.cpp.
@@ -199,8 +205,8 @@ private: 
        for (auto& [id, counters] : mCounters) {

            auto [busId, vendorId, productId, versionId] = id;

            addAStatsEvent(outEventList, android::util::TOUCHPAD_USAGE, vendorId, productId,

                           versionId, linuxBusToInputDeviceBusEnum(busId), counters.fingers,

                           counters.palms, counters.twoFingerSwipeGestures,

                           versionId, linuxBusToInputDeviceBusEnum(busId, /*isUsi=*/false),

                           counters.fingers, counters.palms, counters.twoFingerSwipeGestures,

                           counters.threeFingerSwipeGestures, counters.fourFingerSwipeGestures,

                           counters.pinchGestures);

        }

services/inputflinger/tests/InputDeviceMetricsCollector_test.cpp

+39 −35
Original line number Diff line number Diff line
@@ -53,7 +53,7 @@ constexpr uint32_t KEY_SOURCES = 
constexpr int32_t POINTER_1_DOWN =

        AMOTION_EVENT_ACTION_POINTER_DOWN | (1 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT);



InputDeviceIdentifier getIdentifier(int32_t id = DEVICE_ID) {

InputDeviceIdentifier generateTestIdentifier(int32_t id = DEVICE_ID) {

    InputDeviceIdentifier identifier;

    identifier.name = DEVICE_NAME + "_" + std::to_string(id);

    identifier.location = LOCATION;
@@ -69,8 +69,8 @@ InputDeviceInfo generateTestDeviceInfo(int32_t id = DEVICE_ID, 
                                       uint32_t sources = TOUCHSCREEN | STYLUS,

                                       bool isAlphabetic = false) {

    auto info = InputDeviceInfo();

    info.initialize(id, /*generation=*/1, /*controllerNumber=*/1, getIdentifier(id), "alias",

                    /*isExternal=*/false, /*hasMic=*/false, ADISPLAY_ID_NONE);

    info.initialize(id, /*generation=*/1, /*controllerNumber=*/1, generateTestIdentifier(id),

                    "alias", /*isExternal=*/false, /*hasMic=*/false, ADISPLAY_ID_NONE);

    info.addSource(sources);

    info.setKeyboardType(isAlphabetic ? AINPUT_KEYBOARD_TYPE_ALPHABETIC

                                      : AINPUT_KEYBOARD_TYPE_NON_ALPHABETIC);
@@ -81,6 +81,8 @@ const InputDeviceInfo ALPHABETIC_KEYBOARD_INFO = 
        generateTestDeviceInfo(DEVICE_ID, KEY_SOURCES, /*isAlphabetic=*/true);

const InputDeviceInfo NON_ALPHABETIC_KEYBOARD_INFO =

        generateTestDeviceInfo(DEVICE_ID, KEY_SOURCES, /*isAlphabetic=*/false);

const InputDeviceInfo TOUCHSCREEN_STYLUS_INFO = generateTestDeviceInfo(DEVICE_ID);

const InputDeviceInfo SECOND_TOUCHSCREEN_STYLUS_INFO = generateTestDeviceInfo(DEVICE_ID_2);



std::set<gui::Uid> uids(std::initializer_list<int32_t> vals) {

    std::set<gui::Uid> set;
@@ -351,12 +353,12 @@ protected: 
    TestInputListener mTestListener;

    InputDeviceMetricsCollector mMetricsCollector{mTestListener, *this, USAGE_TIMEOUT};



    void assertUsageLogged(InputDeviceIdentifier identifier, nanoseconds duration,

    void assertUsageLogged(const InputDeviceInfo& info, nanoseconds duration,

                           std::optional<SourceUsageBreakdown> sourceBreakdown = {},

                           std::optional<UidUsageBreakdown> uidBreakdown = {}) {

        ASSERT_GE(mLoggedUsageSessions.size(), 1u);

        const auto& [loggedIdentifier, report] = *mLoggedUsageSessions.begin();

        ASSERT_EQ(identifier, loggedIdentifier);

        const auto& [loggedInfo, report] = *mLoggedUsageSessions.begin();

        ASSERT_EQ(info.getIdentifier(), loggedInfo.getIdentifier());

        ASSERT_EQ(duration, report.usageDuration);

        if (sourceBreakdown) {

            ASSERT_EQ(sourceBreakdown, report.sourceBreakdown);
@@ -387,14 +389,14 @@ protected: 
    }



private:

    std::vector<std::tuple<InputDeviceIdentifier, DeviceUsageReport>> mLoggedUsageSessions;

    std::vector<std::tuple<InputDeviceInfo, DeviceUsageReport>> mLoggedUsageSessions;

    nanoseconds mCurrentTime{TIME};



    nanoseconds getCurrentTime() override { return mCurrentTime; }



    void logInputDeviceUsageReported(const InputDeviceIdentifier& identifier,

    void logInputDeviceUsageReported(const InputDeviceInfo& info,

                                     const DeviceUsageReport& report) override {

        mLoggedUsageSessions.emplace_back(identifier, report);

        mLoggedUsageSessions.emplace_back(info, report);

    }

};
@@ -438,7 +440,7 @@ TEST_F(InputDeviceMetricsCollectorTest, DontLogUsageForIgnoredDevices) { 
}



TEST_F(InputDeviceMetricsCollectorTest, LogsSingleEventUsageSession) {

    mMetricsCollector.notifyInputDevicesChanged({/*id=*/0, {generateTestDeviceInfo()}});

    mMetricsCollector.notifyInputDevicesChanged({/*id=*/0, {TOUCHSCREEN_STYLUS_INFO}});



    // Device was used.

    mMetricsCollector.notifyMotion(generateMotionArgs(DEVICE_ID));
@@ -448,11 +450,11 @@ TEST_F(InputDeviceMetricsCollectorTest, LogsSingleEventUsageSession) { 
    setCurrentTime(TIME + USAGE_TIMEOUT);

    mMetricsCollector.notifyMotion(generateMotionArgs(DEVICE_ID));

    // The usage session has zero duration because it consisted of only one event.

    ASSERT_NO_FATAL_FAILURE(assertUsageLogged(getIdentifier(), 0ns));

    ASSERT_NO_FATAL_FAILURE(assertUsageLogged(TOUCHSCREEN_STYLUS_INFO, 0ns));

}



TEST_F(InputDeviceMetricsCollectorTest, LogsMultipleEventUsageSession) {

    mMetricsCollector.notifyInputDevicesChanged({/*id=*/0, {generateTestDeviceInfo()}});

    mMetricsCollector.notifyInputDevicesChanged({/*id=*/0, {TOUCHSCREEN_STYLUS_INFO}});



    // Device was used.

    mMetricsCollector.notifyMotion(generateMotionArgs(DEVICE_ID));
@@ -468,11 +470,11 @@ TEST_F(InputDeviceMetricsCollectorTest, LogsMultipleEventUsageSession) { 
    // Device was used again after the usage timeout.

    setCurrentTime(TIME + 42ns + 2 * USAGE_TIMEOUT);

    mMetricsCollector.notifyMotion(generateMotionArgs(DEVICE_ID));

    ASSERT_NO_FATAL_FAILURE(assertUsageLogged(getIdentifier(), 42ns));

    ASSERT_NO_FATAL_FAILURE(assertUsageLogged(TOUCHSCREEN_STYLUS_INFO, 42ns));

}



TEST_F(InputDeviceMetricsCollectorTest, RemovingDeviceEndsUsageSession) {

    mMetricsCollector.notifyInputDevicesChanged({/*id=*/0, {generateTestDeviceInfo()}});

    mMetricsCollector.notifyInputDevicesChanged({/*id=*/0, {TOUCHSCREEN_STYLUS_INFO}});



    // Device was used.

    mMetricsCollector.notifyMotion(generateMotionArgs(DEVICE_ID));
@@ -485,12 +487,12 @@ TEST_F(InputDeviceMetricsCollectorTest, RemovingDeviceEndsUsageSession) { 
    // The device was removed before the usage timeout expired.

    setCurrentTime(TIME + 42ns);

    mMetricsCollector.notifyInputDevicesChanged({/*id=*/0, {}});

    ASSERT_NO_FATAL_FAILURE(assertUsageLogged(getIdentifier(), 21ns));

    ASSERT_NO_FATAL_FAILURE(assertUsageLogged(TOUCHSCREEN_STYLUS_INFO, 21ns));

}



TEST_F(InputDeviceMetricsCollectorTest, TracksUsageFromDifferentDevicesIndependently) {

    mMetricsCollector.notifyInputDevicesChanged(

            {/*id=*/0, {generateTestDeviceInfo(), generateTestDeviceInfo(DEVICE_ID_2)}});

            {/*id=*/0, {TOUCHSCREEN_STYLUS_INFO, SECOND_TOUCHSCREEN_STYLUS_INFO}});



    // Device 1 was used.

    setCurrentTime(TIME);
@@ -509,7 +511,7 @@ TEST_F(InputDeviceMetricsCollectorTest, TracksUsageFromDifferentDevicesIndepende 
    // Device 1 was used after its usage timeout expired. Its usage session is reported.

    setCurrentTime(TIME + 300ns + USAGE_TIMEOUT);

    mMetricsCollector.notifyMotion(generateMotionArgs(DEVICE_ID));

    ASSERT_NO_FATAL_FAILURE(assertUsageLogged(getIdentifier(DEVICE_ID), 100ns));

    ASSERT_NO_FATAL_FAILURE(assertUsageLogged(TOUCHSCREEN_STYLUS_INFO, 100ns));



    // Device 2 was used.

    setCurrentTime(TIME + 350ns + USAGE_TIMEOUT);
@@ -525,13 +527,14 @@ TEST_F(InputDeviceMetricsCollectorTest, TracksUsageFromDifferentDevicesIndepende 
    setCurrentTime(TIME + 400ns + (2 * USAGE_TIMEOUT));

    mMetricsCollector.notifyMotion(generateMotionArgs(DEVICE_ID));

    // Since Device 2's usage session ended, its usage should be reported.

    ASSERT_NO_FATAL_FAILURE(assertUsageLogged(getIdentifier(DEVICE_ID_2), 150ns + USAGE_TIMEOUT));

    ASSERT_NO_FATAL_FAILURE(

            assertUsageLogged(SECOND_TOUCHSCREEN_STYLUS_INFO, 150ns + USAGE_TIMEOUT));



    ASSERT_NO_FATAL_FAILURE(assertUsageNotLogged());

}



TEST_F(InputDeviceMetricsCollectorTest, BreakdownUsageBySource) {

    mMetricsCollector.notifyInputDevicesChanged({/*id=*/0, {generateTestDeviceInfo()}});

    mMetricsCollector.notifyInputDevicesChanged({/*id=*/0, {TOUCHSCREEN_STYLUS_INFO}});

    InputDeviceMetricsLogger::SourceUsageBreakdown expectedSourceBreakdown;



    // Use touchscreen.
@@ -576,7 +579,7 @@ TEST_F(InputDeviceMetricsCollectorTest, BreakdownUsageBySource) { 
                                         100ns + USAGE_TIMEOUT);

    // Verify that only one usage session was logged for the device, and that session was broken

    // down by source correctly.

    ASSERT_NO_FATAL_FAILURE(assertUsageLogged(getIdentifier(),

    ASSERT_NO_FATAL_FAILURE(assertUsageLogged(TOUCHSCREEN_STYLUS_INFO,

                                              400ns + USAGE_TIMEOUT + USAGE_TIMEOUT,

                                              expectedSourceBreakdown));
@@ -585,7 +588,7 @@ TEST_F(InputDeviceMetricsCollectorTest, BreakdownUsageBySource) { 


TEST_F(InputDeviceMetricsCollectorTest, BreakdownUsageBySource_TrackSourceByDevice) {

    mMetricsCollector.notifyInputDevicesChanged(

            {/*id=*/0, {generateTestDeviceInfo(DEVICE_ID), generateTestDeviceInfo(DEVICE_ID_2)}});

            {/*id=*/0, {TOUCHSCREEN_STYLUS_INFO, SECOND_TOUCHSCREEN_STYLUS_INFO}});

    InputDeviceMetricsLogger::SourceUsageBreakdown expectedSourceBreakdown1;

    InputDeviceMetricsLogger::SourceUsageBreakdown expectedSourceBreakdown2;
@@ -602,15 +605,15 @@ TEST_F(InputDeviceMetricsCollectorTest, BreakdownUsageBySource_TrackSourceByDevi 
    expectedSourceBreakdown1.emplace_back(InputDeviceUsageSource::TOUCHSCREEN, 100ns);

    expectedSourceBreakdown2.emplace_back(InputDeviceUsageSource::STYLUS_DIRECT, 100ns);

    ASSERT_NO_FATAL_FAILURE(

            assertUsageLogged(getIdentifier(DEVICE_ID), 100ns, expectedSourceBreakdown1));

            assertUsageLogged(TOUCHSCREEN_STYLUS_INFO, 100ns, expectedSourceBreakdown1));

    ASSERT_NO_FATAL_FAILURE(

            assertUsageLogged(getIdentifier(DEVICE_ID_2), 100ns, expectedSourceBreakdown2));

            assertUsageLogged(SECOND_TOUCHSCREEN_STYLUS_INFO, 100ns, expectedSourceBreakdown2));



    ASSERT_NO_FATAL_FAILURE(assertUsageNotLogged());

}



TEST_F(InputDeviceMetricsCollectorTest, BreakdownUsageBySource_MultiSourceEvent) {

    mMetricsCollector.notifyInputDevicesChanged({/*id=*/0, {generateTestDeviceInfo(DEVICE_ID)}});

    mMetricsCollector.notifyInputDevicesChanged({/*id=*/0, {TOUCHSCREEN_STYLUS_INFO}});

    InputDeviceMetricsLogger::SourceUsageBreakdown expectedSourceBreakdown;



    mMetricsCollector.notifyMotion(generateMotionArgs(DEVICE_ID, TOUCHSCREEN | STYLUS, //
@@ -634,13 +637,13 @@ TEST_F(InputDeviceMetricsCollectorTest, BreakdownUsageBySource_MultiSourceEvent) 
    expectedSourceBreakdown.emplace_back(InputDeviceUsageSource::STYLUS_DIRECT, 200ns);

    expectedSourceBreakdown.emplace_back(InputDeviceUsageSource::TOUCHSCREEN, 300ns);

    ASSERT_NO_FATAL_FAILURE(

            assertUsageLogged(getIdentifier(DEVICE_ID), 400ns, expectedSourceBreakdown));

            assertUsageLogged(TOUCHSCREEN_STYLUS_INFO, 400ns, expectedSourceBreakdown));



    ASSERT_NO_FATAL_FAILURE(assertUsageNotLogged());

}



TEST_F(InputDeviceMetricsCollectorTest, UidsNotTrackedWhenThereIsNoActiveSession) {

    mMetricsCollector.notifyInputDevicesChanged({/*id=*/0, {generateTestDeviceInfo()}});

    mMetricsCollector.notifyInputDevicesChanged({/*id=*/0, {TOUCHSCREEN_STYLUS_INFO}});



    // Notify interaction with UIDs before the device is used.

    mMetricsCollector.notifyDeviceInteraction(DEVICE_ID, currentTime(), uids({1}));
@@ -665,14 +668,15 @@ TEST_F(InputDeviceMetricsCollectorTest, UidsNotTrackedWhenThereIsNoActiveSession 


    // The first usage session is logged.

    static const UidUsageBreakdown emptyBreakdown;

    ASSERT_NO_FATAL_FAILURE(assertUsageLogged(getIdentifier(), 100ns, /*sourceBreakdown=*/{},

    ASSERT_NO_FATAL_FAILURE(assertUsageLogged(TOUCHSCREEN_STYLUS_INFO, 100ns,

                                              /*sourceBreakdown=*/{},

                                              /*uidBreakdown=*/emptyBreakdown));



    ASSERT_NO_FATAL_FAILURE(assertUsageNotLogged());

}



TEST_F(InputDeviceMetricsCollectorTest, BreakdownUsageByUid) {

    mMetricsCollector.notifyInputDevicesChanged({/*id=*/0, {generateTestDeviceInfo()}});

    mMetricsCollector.notifyInputDevicesChanged({/*id=*/0, {TOUCHSCREEN_STYLUS_INFO}});

    UidUsageBreakdown expectedUidBreakdown;



    mMetricsCollector.notifyMotion(generateMotionArgs(DEVICE_ID));
@@ -691,14 +695,14 @@ TEST_F(InputDeviceMetricsCollectorTest, BreakdownUsageByUid) { 


    // Remove the device to force the usage session to be logged.

    mMetricsCollector.notifyInputDevicesChanged({});

    ASSERT_NO_FATAL_FAILURE(assertUsageLogged(getIdentifier(), 200ns, /*sourceBreakdown=*/{},

                                              expectedUidBreakdown));

    ASSERT_NO_FATAL_FAILURE(assertUsageLogged(TOUCHSCREEN_STYLUS_INFO, 200ns,

                                              /*sourceBreakdown=*/{}, expectedUidBreakdown));



    ASSERT_NO_FATAL_FAILURE(assertUsageNotLogged());

}



TEST_F(InputDeviceMetricsCollectorTest, BreakdownUsageByUid_TracksMultipleSessionsForUid) {

    mMetricsCollector.notifyInputDevicesChanged({/*id=*/0, {generateTestDeviceInfo()}});

    mMetricsCollector.notifyInputDevicesChanged({/*id=*/0, {TOUCHSCREEN_STYLUS_INFO}});

    UidUsageBreakdown expectedUidBreakdown;



    mMetricsCollector.notifyMotion(generateMotionArgs(DEVICE_ID));
@@ -742,7 +746,7 @@ TEST_F(InputDeviceMetricsCollectorTest, BreakdownUsageByUid_TracksMultipleSessio 
    expectedUidBreakdown.emplace_back(2, 0ns);

    expectedUidBreakdown.emplace_back(3, 100ns);

    expectedUidBreakdown.emplace_back(4, 100ns);

    ASSERT_NO_FATAL_FAILURE(assertUsageLogged(getIdentifier(), 500ns + USAGE_TIMEOUT,

    ASSERT_NO_FATAL_FAILURE(assertUsageLogged(TOUCHSCREEN_STYLUS_INFO, 500ns + USAGE_TIMEOUT,

                                              /*sourceBreakdown=*/{}, expectedUidBreakdown));



    ASSERT_NO_FATAL_FAILURE(assertUsageNotLogged());
@@ -750,7 +754,7 @@ TEST_F(InputDeviceMetricsCollectorTest, BreakdownUsageByUid_TracksMultipleSessio 


TEST_F(InputDeviceMetricsCollectorTest, BreakdownUsageByUid_TracksUidsByDevice) {

    mMetricsCollector.notifyInputDevicesChanged(

            {/*id=*/0, {generateTestDeviceInfo(DEVICE_ID), generateTestDeviceInfo(DEVICE_ID_2)}});

            {/*id=*/0, {TOUCHSCREEN_STYLUS_INFO, SECOND_TOUCHSCREEN_STYLUS_INFO}});

    UidUsageBreakdown expectedUidBreakdown1;

    UidUsageBreakdown expectedUidBreakdown2;
@@ -773,9 +777,9 @@ TEST_F(InputDeviceMetricsCollectorTest, BreakdownUsageByUid_TracksUidsByDevice) 
    expectedUidBreakdown2.emplace_back(1, 100ns);

    expectedUidBreakdown2.emplace_back(3, 100ns);

    mMetricsCollector.notifyMotion(generateMotionArgs(DEVICE_ID));

    ASSERT_NO_FATAL_FAILURE(assertUsageLogged(getIdentifier(DEVICE_ID), 200ns,

    ASSERT_NO_FATAL_FAILURE(assertUsageLogged(TOUCHSCREEN_STYLUS_INFO, 200ns,

                                              /*sourceBreakdown=*/{}, expectedUidBreakdown1));

    ASSERT_NO_FATAL_FAILURE(assertUsageLogged(getIdentifier(DEVICE_ID_2), 100ns,

    ASSERT_NO_FATAL_FAILURE(assertUsageLogged(SECOND_TOUCHSCREEN_STYLUS_INFO, 100ns,

                                              /*sourceBreakdown=*/{}, expectedUidBreakdown2));



    ASSERT_NO_FATAL_FAILURE(assertUsageNotLogged());