Merge changes from topic "InputDeviceUsageReported" into udc-qpr-dev am: d07aba4fab am: 8c2ac76200 (fedc2297) · Commits · e / os / android_frameworks_native

include/input/InputDevice.h

+3 −0

Original line number	Diff line number	Diff line
		@@ -68,6 +68,9 @@ struct InputDeviceIdentifier {
		* while conforming to the filename limitations.
		*/
		std::string getCanonicalName() const;

		bool operator==(const InputDeviceIdentifier&) const = default;
		bool operator!=(const InputDeviceIdentifier&) const = default;
		};

		/* Types of input device sensors. Keep sync with core/java/android/hardware/Sensor.java */

include/input/PrintTools.h

+14 −0

Original line number	Diff line number	Diff line
		@@ -87,6 +87,20 @@ std::string dumpMap(const std::map<K, V>& map, std::string (*keyToString)(const
		return out;
		}

		/**
		* Convert map keys to string. The keys of the map should be integral type.
		*/
		template <typename K, typename V>
		std::string dumpMapKeys(const std::map<K, V>& map,
		std::string (*keyToString)(const K&) = constToString) {
		std::string out;
		for (const auto& [k, _] : map) {
		out += out.empty() ? "{" : ", ";
		out += keyToString(k);
		}
		return out.empty() ? "{}" : (out + "}");
		}

		/**
		* Convert a vector to a string. The values of the vector should be of a type supported by
		* constToString.

services/inputflinger/BlockingQueue.h

+52 −14

Original line number	Diff line number	Diff line
		@@ -16,15 +16,17 @@

		#pragma once

		#include "android-base/thread_annotations.h"
		#include <condition_variable>
		#include <list>
		#include <mutex>
		#include <vector>
		#include <optional>
		#include "android-base/thread_annotations.h"

		namespace android {

		/**
		* A FIFO queue that stores up to <i>capacity</i> objects.
		* A thread-safe FIFO queue. This list-backed queue stores up to <i>capacity</i> objects if
		* a capacity is provided at construction, and is otherwise unbounded.
		* Objects can always be added. Objects are added immediately.
		* If the queue is full, new objects cannot be added.
		*
		@@ -33,13 +35,13 @@ namespace android {
		template <class T>
		class BlockingQueue {
		public:
		BlockingQueue(size_t capacity) : mCapacity(capacity) {
		mQueue.reserve(mCapacity);
		};
		explicit BlockingQueue() = default;

		explicit BlockingQueue(size_t capacity) : mCapacity(capacity){};

		/**
		* Retrieve and remove the oldest object.
		* Blocks execution while queue is empty.
		* Blocks execution indefinitely while queue is empty.
		*/
		T pop() {
		std::unique_lock lock(mLock);
		@@ -50,6 +52,23 @@ public:
		return t;
		};

		/**
		* Retrieve and remove the oldest object.
		* Blocks execution for the given duration while queue is empty, and returns std::nullopt
		* if the queue was empty for the entire duration.
		*/
		std::optional<T> popWithTimeout(std::chrono::nanoseconds duration) {
		std::unique_lock lock(mLock);
		android::base::ScopedLockAssertion assumeLock(mLock);
		if (!mHasElements.wait_for(lock, duration,
		[this]() REQUIRES(mLock) { return !this->mQueue.empty(); })) {
		return {};
		}
		T t = std::move(mQueue.front());
		mQueue.erase(mQueue.begin());
		return t;
		};

		/**
		* Add a new object to the queue.
		* Does not block.
		@@ -57,20 +76,39 @@ public:
		* Return false if the queue is full.
		*/
		bool push(T&& t) {
		{
		{ // acquire lock
		std::scoped_lock lock(mLock);
		if (mQueue.size() == mCapacity) {
		if (mCapacity && mQueue.size() == mCapacity) {
		return false;
		}
		mQueue.push_back(std::move(t));
		} // release lock
		mHasElements.notify_one();
		return true;
		};

		/**
		* Construct a new object into the queue.
		* Does not block.
		* Return true if an element was successfully added.
		* Return false if the queue is full.
		*/
		template <class... Args>
		bool emplace(Args&&... args) {
		{ // acquire lock
		std::scoped_lock lock(mLock);
		if (mCapacity && mQueue.size() == mCapacity) {
		return false;
		}
		mQueue.emplace_back(args...);
		} // release lock
		mHasElements.notify_one();
		return true;
		};

		void erase(const std::function<bool(const T&)>& lambda) {
		void erase_if(const std::function<bool(const T&)>& pred) {
		std::scoped_lock lock(mLock);
		std::erase_if(mQueue, [&lambda](const auto& t) { return lambda(t); });
		std::erase_if(mQueue, pred);
		}

		/**
		@@ -93,7 +131,7 @@ public:
		}

		private:
		const size_t mCapacity;
		const std::optional<size_t> mCapacity;
		/**
		* Used to signal that mQueue is non-empty.
		*/
		@@ -102,7 +140,7 @@ private:
		* Lock for accessing and waiting on elements.
		*/
		std::mutex mLock;
		std::vector<T> mQueue GUARDED_BY(mLock);
		std::list<T> mQueue GUARDED_BY(mLock);
		};

		} // namespace android

services/inputflinger/InputDeviceMetricsCollector.cpp

+311 −1

Original line number	Diff line number	Diff line
		@@ -17,52 +17,362 @@
		#define LOG_TAG "InputDeviceMetricsCollector"
		#include "InputDeviceMetricsCollector.h"

		#include "KeyCodeClassifications.h"

		#include <android-base/stringprintf.h>
		#include <input/PrintTools.h>
		#include <linux/input.h>

		namespace android {

		using android::base::StringPrintf;
		using std::chrono::nanoseconds;

		namespace {

		constexpr nanoseconds DEFAULT_USAGE_SESSION_TIMEOUT = std::chrono::seconds(5);

		/**
		* Log debug messages about metrics events logged to statsd.
		* Enable this via "adb shell setprop log.tag.InputDeviceMetricsCollector DEBUG" (requires restart)
		*/
		const bool DEBUG = __android_log_is_loggable(ANDROID_LOG_DEBUG, LOG_TAG, ANDROID_LOG_INFO);

		int32_t linuxBusToInputDeviceBusEnum(int32_t linuxBus) {
		switch (linuxBus) {
		case BUS_USB:
		return util::INPUT_DEVICE_USAGE_REPORTED__DEVICE_BUS__USB;
		case BUS_BLUETOOTH:
		return util::INPUT_DEVICE_USAGE_REPORTED__DEVICE_BUS__BLUETOOTH;
		default:
		return util::INPUT_DEVICE_USAGE_REPORTED__DEVICE_BUS__OTHER;
		}
		}

		class : public InputDeviceMetricsLogger {
		nanoseconds getCurrentTime() override { return nanoseconds(systemTime(SYSTEM_TIME_MONOTONIC)); }

		void logInputDeviceUsageReported(const InputDeviceIdentifier& identifier,
		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;

		ALOGD_IF(DEBUG, "Usage session reported for device: %s", identifier.name.c_str());
		ALOGD_IF(DEBUG, " Total duration: %dms", durationMillis);
		ALOGD_IF(DEBUG, " Source breakdown:");

		std::vector<int32_t> sources;
		std::vector<int32_t> durationsPerSource;
		for (auto& [src, dur] : report.sourceBreakdown) {
		sources.push_back(ftl::to_underlying(src));
		int32_t durMillis = std::chrono::duration_cast<std::chrono::milliseconds>(dur).count();
		durationsPerSource.emplace_back(durMillis);
		ALOGD_IF(DEBUG, " - usageSource: %s\t duration: %dms",
		ftl::enum_string(src).c_str(), durMillis);
		}

		util::stats_write(util::INPUTDEVICE_USAGE_REPORTED, identifier.vendor, identifier.product,
		identifier.version, linuxBusToInputDeviceBusEnum(identifier.bus),
		durationMillis, sources, durationsPerSource, /uids=/empty,
		/usage_durations_per_uid=/empty);
		}
		} sStatsdLogger;

		bool isIgnoredInputDeviceId(int32_t deviceId) {
		switch (deviceId) {
		case INVALID_INPUT_DEVICE_ID:
		case VIRTUAL_KEYBOARD_ID:
		return true;
		default:
		return false;
		}
		}

		} // namespace

		InputDeviceUsageSource getUsageSourceForKeyArgs(const InputDeviceInfo& info,
		const NotifyKeyArgs& keyArgs) {
		if (!isFromSource(keyArgs.source, AINPUT_SOURCE_KEYBOARD)) {
		return InputDeviceUsageSource::UNKNOWN;
		}

		if (isFromSource(keyArgs.source, AINPUT_SOURCE_DPAD) &&
		DPAD_ALL_KEYCODES.count(keyArgs.keyCode) != 0) {
		return InputDeviceUsageSource::DPAD;
		}

		if (isFromSource(keyArgs.source, AINPUT_SOURCE_GAMEPAD) &&
		GAMEPAD_KEYCODES.count(keyArgs.keyCode) != 0) {
		return InputDeviceUsageSource::GAMEPAD;
		}

		if (info.getKeyboardType() == AINPUT_KEYBOARD_TYPE_ALPHABETIC) {
		return InputDeviceUsageSource::KEYBOARD;
		}

		return InputDeviceUsageSource::BUTTONS;
		}

		std::set<InputDeviceUsageSource> getUsageSourcesForMotionArgs(const NotifyMotionArgs& motionArgs) {
		LOG_ALWAYS_FATAL_IF(motionArgs.pointerCount < 1, "Received motion args without pointers");
		std::set<InputDeviceUsageSource> sources;

		for (uint32_t i = 0; i < motionArgs.pointerCount; i++) {
		const auto toolType = motionArgs.pointerProperties[i].toolType;
		if (isFromSource(motionArgs.source, AINPUT_SOURCE_MOUSE)) {
		if (toolType == ToolType::MOUSE) {
		sources.emplace(InputDeviceUsageSource::MOUSE);
		continue;
		}
		if (toolType == ToolType::FINGER) {
		sources.emplace(InputDeviceUsageSource::TOUCHPAD);
		continue;
		}
		if (isStylusToolType(toolType)) {
		sources.emplace(InputDeviceUsageSource::STYLUS_INDIRECT);
		continue;
		}
		}
		if (isFromSource(motionArgs.source, AINPUT_SOURCE_MOUSE_RELATIVE) &&
		toolType == ToolType::MOUSE) {
		sources.emplace(InputDeviceUsageSource::MOUSE_CAPTURED);
		continue;
		}
		if (isFromSource(motionArgs.source, AINPUT_SOURCE_TOUCHPAD) &&
		toolType == ToolType::FINGER) {
		sources.emplace(InputDeviceUsageSource::TOUCHPAD_CAPTURED);
		continue;
		}
		if (isFromSource(motionArgs.source, AINPUT_SOURCE_BLUETOOTH_STYLUS) &&
		isStylusToolType(toolType)) {
		sources.emplace(InputDeviceUsageSource::STYLUS_FUSED);
		continue;
		}
		if (isFromSource(motionArgs.source, AINPUT_SOURCE_STYLUS) && isStylusToolType(toolType)) {
		sources.emplace(InputDeviceUsageSource::STYLUS_DIRECT);
		continue;
		}
		if (isFromSource(motionArgs.source, AINPUT_SOURCE_TOUCH_NAVIGATION)) {
		sources.emplace(InputDeviceUsageSource::TOUCH_NAVIGATION);
		continue;
		}
		if (isFromSource(motionArgs.source, AINPUT_SOURCE_JOYSTICK)) {
		sources.emplace(InputDeviceUsageSource::JOYSTICK);
		continue;
		}
		if (isFromSource(motionArgs.source, AINPUT_SOURCE_ROTARY_ENCODER)) {
		sources.emplace(InputDeviceUsageSource::ROTARY_ENCODER);
		continue;
		}
		if (isFromSource(motionArgs.source, AINPUT_SOURCE_TRACKBALL)) {
		sources.emplace(InputDeviceUsageSource::TRACKBALL);
		continue;
		}
		if (isFromSource(motionArgs.source, AINPUT_SOURCE_TOUCHSCREEN)) {
		sources.emplace(InputDeviceUsageSource::TOUCHSCREEN);
		continue;
		}
		sources.emplace(InputDeviceUsageSource::UNKNOWN);
		}

		return sources;
		}

		// --- InputDeviceMetricsCollector ---

		InputDeviceMetricsCollector::InputDeviceMetricsCollector(InputListenerInterface& listener)
		: mNextListener(listener){};
		: InputDeviceMetricsCollector(listener, sStatsdLogger, DEFAULT_USAGE_SESSION_TIMEOUT) {}

		InputDeviceMetricsCollector::InputDeviceMetricsCollector(InputListenerInterface& listener,
		InputDeviceMetricsLogger& logger,
		nanoseconds usageSessionTimeout)
		: mNextListener(listener), mLogger(logger), mUsageSessionTimeout(usageSessionTimeout) {}

		void InputDeviceMetricsCollector::notifyInputDevicesChanged(
		const NotifyInputDevicesChangedArgs& args) {
		reportCompletedSessions();
		onInputDevicesChanged(args.inputDeviceInfos);
		mNextListener.notify(args);
		}

		void InputDeviceMetricsCollector::notifyConfigurationChanged(
		const NotifyConfigurationChangedArgs& args) {
		reportCompletedSessions();
		mNextListener.notify(args);
		}

		void InputDeviceMetricsCollector::notifyKey(const NotifyKeyArgs& args) {
		reportCompletedSessions();
		const SourceProvider getSources = [&args](const InputDeviceInfo& info) {
		return std::set{getUsageSourceForKeyArgs(info, args)};
		};
		onInputDeviceUsage(DeviceId{args.deviceId}, nanoseconds(args.eventTime), getSources);

		mNextListener.notify(args);
		}

		void InputDeviceMetricsCollector::notifyMotion(const NotifyMotionArgs& args) {
		reportCompletedSessions();
		onInputDeviceUsage(DeviceId{args.deviceId}, nanoseconds(args.eventTime),
		[&args](const auto&) { return getUsageSourcesForMotionArgs(args); });

		mNextListener.notify(args);
		}

		void InputDeviceMetricsCollector::notifySwitch(const NotifySwitchArgs& args) {
		reportCompletedSessions();
		mNextListener.notify(args);
		}

		void InputDeviceMetricsCollector::notifySensor(const NotifySensorArgs& args) {
		reportCompletedSessions();
		mNextListener.notify(args);
		}

		void InputDeviceMetricsCollector::notifyVibratorState(const NotifyVibratorStateArgs& args) {
		reportCompletedSessions();
		mNextListener.notify(args);
		}

		void InputDeviceMetricsCollector::notifyDeviceReset(const NotifyDeviceResetArgs& args) {
		reportCompletedSessions();
		mNextListener.notify(args);
		}

		void InputDeviceMetricsCollector::notifyPointerCaptureChanged(
		const NotifyPointerCaptureChangedArgs& args) {
		reportCompletedSessions();
		mNextListener.notify(args);
		}

		void InputDeviceMetricsCollector::dump(std::string& dump) {
		dump += "InputDeviceMetricsCollector:\n";

		dump += " Logged device IDs: " + dumpMapKeys(mLoggedDeviceInfos, &toString) + "\n";
		dump += " Devices with active usage sessions: " +
		dumpMapKeys(mActiveUsageSessions, &toString) + "\n";
		}

		void InputDeviceMetricsCollector::onInputDevicesChanged(const std::vector<InputDeviceInfo>& infos) {
		std::map<DeviceId, InputDeviceInfo> newDeviceInfos;

		for (const InputDeviceInfo& info : infos) {
		if (isIgnoredInputDeviceId(info.getId())) {
		continue;
		}
		newDeviceInfos.emplace(info.getId(), info);
		}

		for (auto [deviceId, info] : mLoggedDeviceInfos) {
		if (newDeviceInfos.count(deviceId) != 0) {
		continue;
		}
		onInputDeviceRemoved(deviceId, info.getIdentifier());
		}

		std::swap(newDeviceInfos, mLoggedDeviceInfos);
		}

		void InputDeviceMetricsCollector::onInputDeviceRemoved(DeviceId deviceId,
		const InputDeviceIdentifier& identifier) {
		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());
		mActiveUsageSessions.erase(it);

		// We don't remove this from mLoggedDeviceInfos because it will be updated in
		// onInputDevicesChanged().
		}

		void InputDeviceMetricsCollector::onInputDeviceUsage(DeviceId deviceId, nanoseconds eventTime,
		const SourceProvider& getSources) {
		auto infoIt = mLoggedDeviceInfos.find(deviceId);
		if (infoIt == mLoggedDeviceInfos.end()) {
		// Do not track usage for devices that are not logged.
		return;
		}

		auto [sessionIt, _] =
		mActiveUsageSessions.try_emplace(deviceId, mUsageSessionTimeout, eventTime);
		for (InputDeviceUsageSource source : getSources(infoIt->second)) {
		sessionIt->second.recordUsage(eventTime, source);
		}
		}

		void InputDeviceMetricsCollector::reportCompletedSessions() {
		const auto currentTime = mLogger.getCurrentTime();

		std::vector<DeviceId> completedUsageSessions;

		for (auto& [deviceId, activeSession] : mActiveUsageSessions) {
		if (activeSession.checkIfCompletedAt(currentTime)) {
		completedUsageSessions.emplace_back(deviceId);
		}
		}

		for (DeviceId deviceId : completedUsageSessions) {
		const auto infoIt = mLoggedDeviceInfos.find(deviceId);
		LOG_ALWAYS_FATAL_IF(infoIt == mLoggedDeviceInfos.end());

		auto activeSessionIt = mActiveUsageSessions.find(deviceId);
		LOG_ALWAYS_FATAL_IF(activeSessionIt == mActiveUsageSessions.end());
		auto& [_, activeSession] = *activeSessionIt;
		mLogger.logInputDeviceUsageReported(infoIt->second.getIdentifier(),
		activeSession.finishSession());
		mActiveUsageSessions.erase(activeSessionIt);
		}
		}

		// --- InputDeviceMetricsCollector::ActiveSession ---

		InputDeviceMetricsCollector::ActiveSession::ActiveSession(nanoseconds usageSessionTimeout,
		nanoseconds startTime)
		: mUsageSessionTimeout(usageSessionTimeout), mDeviceSession({startTime, startTime}) {}

		void InputDeviceMetricsCollector::ActiveSession::recordUsage(nanoseconds eventTime,
		InputDeviceUsageSource source) {
		// We assume that event times for subsequent events are always monotonically increasing for each
		// input device.
		auto [activeSourceIt, inserted] =
		mActiveSessionsBySource.try_emplace(source, eventTime, eventTime);
		if (!inserted) {
		activeSourceIt->second.end = eventTime;
		}
		mDeviceSession.end = eventTime;
		}

		bool InputDeviceMetricsCollector::ActiveSession::checkIfCompletedAt(nanoseconds timestamp) {
		const auto sessionExpiryTime = timestamp - mUsageSessionTimeout;
		std::vector<InputDeviceUsageSource> completedSourceSessionsForDevice;
		for (auto& [source, session] : mActiveSessionsBySource) {
		if (session.end <= sessionExpiryTime) {
		completedSourceSessionsForDevice.emplace_back(source);
		}
		}
		for (InputDeviceUsageSource source : completedSourceSessionsForDevice) {
		auto it = mActiveSessionsBySource.find(source);
		const auto& [_, session] = *it;
		mSourceUsageBreakdown.emplace_back(source, session.end - session.start);
		mActiveSessionsBySource.erase(it);
		}
		return mActiveSessionsBySource.empty();
		}

		InputDeviceMetricsLogger::DeviceUsageReport
		InputDeviceMetricsCollector::ActiveSession::finishSession() {
		const auto deviceUsageDuration = mDeviceSession.end - mDeviceSession.start;

		for (const auto& [source, sourceSession] : mActiveSessionsBySource) {
		mSourceUsageBreakdown.emplace_back(source, sourceSession.end - sourceSession.start);
		}
		mActiveSessionsBySource.clear();

		return {deviceUsageDuration, mSourceUsageBreakdown};
		}

		} // namespace android

services/inputflinger/InputDeviceMetricsCollector.h

+117 −0

Original line number	Diff line number	Diff line
		@@ -17,6 +17,16 @@
		#pragma once

		#include "InputListener.h"
		#include "NotifyArgs.h"

		#include <ftl/mixins.h>
		#include <input/InputDevice.h>
		#include <statslog.h>
		#include <chrono>
		#include <functional>
		#include <map>
		#include <set>
		#include <vector>

		namespace android {

		@@ -34,11 +44,73 @@ public:
		virtual void dump(std::string& dump) = 0;
		};

		/**
		* Enum representation of the InputDeviceUsageSource.
		*/
		enum class InputDeviceUsageSource : int32_t {
		UNKNOWN = util::INPUT_DEVICE_USAGE_REPORTED__USAGE_SOURCES__UNKNOWN,
		BUTTONS = util::INPUT_DEVICE_USAGE_REPORTED__USAGE_SOURCES__BUTTONS,
		KEYBOARD = util::INPUT_DEVICE_USAGE_REPORTED__USAGE_SOURCES__KEYBOARD,
		DPAD = util::INPUT_DEVICE_USAGE_REPORTED__USAGE_SOURCES__DPAD,
		GAMEPAD = util::INPUT_DEVICE_USAGE_REPORTED__USAGE_SOURCES__GAMEPAD,
		JOYSTICK = util::INPUT_DEVICE_USAGE_REPORTED__USAGE_SOURCES__JOYSTICK,
		MOUSE = util::INPUT_DEVICE_USAGE_REPORTED__USAGE_SOURCES__MOUSE,
		MOUSE_CAPTURED = util::INPUT_DEVICE_USAGE_REPORTED__USAGE_SOURCES__MOUSE_CAPTURED,
		TOUCHPAD = util::INPUT_DEVICE_USAGE_REPORTED__USAGE_SOURCES__TOUCHPAD,
		TOUCHPAD_CAPTURED = util::INPUT_DEVICE_USAGE_REPORTED__USAGE_SOURCES__TOUCHPAD_CAPTURED,
		ROTARY_ENCODER = util::INPUT_DEVICE_USAGE_REPORTED__USAGE_SOURCES__ROTARY_ENCODER,
		STYLUS_DIRECT = util::INPUT_DEVICE_USAGE_REPORTED__USAGE_SOURCES__STYLUS_DIRECT,
		STYLUS_INDIRECT = util::INPUT_DEVICE_USAGE_REPORTED__USAGE_SOURCES__STYLUS_INDIRECT,
		STYLUS_FUSED = util::INPUT_DEVICE_USAGE_REPORTED__USAGE_SOURCES__STYLUS_FUSED,
		TOUCH_NAVIGATION = util::INPUT_DEVICE_USAGE_REPORTED__USAGE_SOURCES__TOUCH_NAVIGATION,
		TOUCHSCREEN = util::INPUT_DEVICE_USAGE_REPORTED__USAGE_SOURCES__TOUCHSCREEN,
		TRACKBALL = util::INPUT_DEVICE_USAGE_REPORTED__USAGE_SOURCES__TRACKBALL,

		ftl_first = UNKNOWN,
		ftl_last = TRACKBALL,
		};

		/** Returns the InputDeviceUsageSource that corresponds to the key event. */
		InputDeviceUsageSource getUsageSourceForKeyArgs(const InputDeviceInfo&, const NotifyKeyArgs&);

		/** Returns the InputDeviceUsageSources that correspond to the motion event. */
		std::set<InputDeviceUsageSource> getUsageSourcesForMotionArgs(const NotifyMotionArgs&);

		/** The logging interface for the metrics collector, injected for testing. */
		class InputDeviceMetricsLogger {
		public:
		virtual std::chrono::nanoseconds getCurrentTime() = 0;

		// Describes the breakdown of an input device usage session by its usage sources.
		// An input device can have more than one usage source. For example, some game controllers have
		// buttons, joysticks, and touchpads. We track usage by these sources to get a better picture of
		// the device usage. The source breakdown of a 10 minute usage session could look like this:
		// { {GAMEPAD, <9 mins>}, {TOUCHPAD, <2 mins>}, {TOUCHPAD, <3 mins>} }
		// This would indicate that the GAMEPAD source was used first, and that source usage session
		// lasted for 9 mins. During that time, the TOUCHPAD was used for 2 mins, until its source
		// usage session expired. The TOUCHPAD was then used again later for another 3 mins.
		using SourceUsageBreakdown =
		std::vector<std::pair<InputDeviceUsageSource, std::chrono::nanoseconds /duration/>>;

		struct DeviceUsageReport {
		std::chrono::nanoseconds usageDuration;
		SourceUsageBreakdown sourceBreakdown;
		};

		virtual void logInputDeviceUsageReported(const InputDeviceIdentifier&,
		const DeviceUsageReport&) = 0;
		virtual ~InputDeviceMetricsLogger() = default;
		};

		class InputDeviceMetricsCollector : public InputDeviceMetricsCollectorInterface {
		public:
		explicit InputDeviceMetricsCollector(InputListenerInterface& listener);
		~InputDeviceMetricsCollector() override = default;

		// Test constructor
		InputDeviceMetricsCollector(InputListenerInterface& listener, InputDeviceMetricsLogger& logger,
		std::chrono::nanoseconds usageSessionTimeout);

		void notifyInputDevicesChanged(const NotifyInputDevicesChangedArgs& args) override;
		void notifyConfigurationChanged(const NotifyConfigurationChangedArgs& args) override;
		void notifyKey(const NotifyKeyArgs& args) override;
		@@ -53,6 +125,51 @@ public:

		private:
		InputListenerInterface& mNextListener;
		InputDeviceMetricsLogger& mLogger;
		const std::chrono::nanoseconds mUsageSessionTimeout;

		// Type-safe wrapper for input device id.
		struct DeviceId : ftl::Constructible<DeviceId, std::int32_t>,
		ftl::Equatable<DeviceId>,
		ftl::Orderable<DeviceId> {
		using Constructible::Constructible;
		};
		static inline std::string toString(const DeviceId& id) {
		return std::to_string(ftl::to_underlying(id));
		}

		std::map<DeviceId, InputDeviceInfo> mLoggedDeviceInfos;

		class ActiveSession {
		public:
		explicit ActiveSession(std::chrono::nanoseconds usageSessionTimeout,
		std::chrono::nanoseconds startTime);
		void recordUsage(std::chrono::nanoseconds eventTime, InputDeviceUsageSource source);
		bool checkIfCompletedAt(std::chrono::nanoseconds timestamp);
		InputDeviceMetricsLogger::DeviceUsageReport finishSession();

		private:
		struct UsageSession {
		std::chrono::nanoseconds start{};
		std::chrono::nanoseconds end{};
		};

		const std::chrono::nanoseconds mUsageSessionTimeout;
		UsageSession mDeviceSession{};

		std::map<InputDeviceUsageSource, UsageSession> mActiveSessionsBySource{};
		InputDeviceMetricsLogger::SourceUsageBreakdown mSourceUsageBreakdown{};
		};

		// The input devices that currently have active usage sessions.
		std::map<DeviceId, ActiveSession> mActiveUsageSessions;

		void onInputDevicesChanged(const std::vector<InputDeviceInfo>& infos);
		void onInputDeviceRemoved(DeviceId deviceId, const InputDeviceIdentifier& identifier);
		using SourceProvider = std::function<std::set<InputDeviceUsageSource>(const InputDeviceInfo&)>;
		void onInputDeviceUsage(DeviceId deviceId, std::chrono::nanoseconds eventTime,
		const SourceProvider& getSources);
		void reportCompletedSessions();
		};

		} // namespace android