Merge changes I73c090e8,I03e0960f into main (7fd4c33d) · Commits · e / os / android_frameworks_native

services/inputflinger/dispatcher/trace/AndroidInputEventProtoConverter.cpp

deleted100644 → 0

+0 −212

Original line number	Diff line number	Diff line
		/*
		* Copyright 2024 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 "AndroidInputEventProtoConverter.h"

		#include <android-base/logging.h>
		#include <perfetto/trace/android/android_input_event.pbzero.h>

		namespace android::inputdispatcher::trace {

		namespace {

		using namespace ftl::flag_operators;

		// The trace config to use for maximal tracing.
		const impl::TraceConfig CONFIG_TRACE_ALL{
		.flags = impl::TraceFlag::TRACE_DISPATCHER_INPUT_EVENTS \|
		impl::TraceFlag::TRACE_DISPATCHER_WINDOW_DISPATCH,
		.rules = {impl::TraceRule{.level = impl::TraceLevel::TRACE_LEVEL_COMPLETE,
		.matchAllPackages = {},
		.matchAnyPackages = {},
		.matchSecure{},
		.matchImeConnectionActive = {}}},
		};

		} // namespace

		void AndroidInputEventProtoConverter::toProtoMotionEvent(const TracedMotionEvent& event,
		proto::AndroidMotionEvent& outProto,
		bool isRedacted) {
		outProto.set_event_id(event.id);
		outProto.set_event_time_nanos(event.eventTime);
		outProto.set_down_time_nanos(event.downTime);
		outProto.set_source(event.source);
		outProto.set_action(event.action);
		outProto.set_device_id(event.deviceId);
		outProto.set_display_id(event.displayId.val());
		outProto.set_classification(static_cast<int32_t>(event.classification));
		outProto.set_flags(event.flags);
		outProto.set_policy_flags(event.policyFlags);
		outProto.set_button_state(event.buttonState);
		outProto.set_action_button(event.actionButton);

		if (!isRedacted) {
		outProto.set_cursor_position_x(event.xCursorPosition);
		outProto.set_cursor_position_y(event.yCursorPosition);
		outProto.set_meta_state(event.metaState);
		outProto.set_precision_x(event.xPrecision);
		outProto.set_precision_y(event.yPrecision);
		}

		for (uint32_t i = 0; i < event.pointerProperties.size(); i++) {
		auto* pointer = outProto.add_pointer();

		const auto& props = event.pointerProperties[i];
		pointer->set_pointer_id(props.id);
		pointer->set_tool_type(static_cast<int32_t>(props.toolType));

		const auto& coords = event.pointerCoords[i];
		auto bits = BitSet64(coords.bits);
		for (int32_t axisIndex = 0; !bits.isEmpty(); axisIndex++) {
		const auto axis = bits.clearFirstMarkedBit();
		auto axisEntry = pointer->add_axis_value();
		axisEntry->set_axis(axis);

		if (!isRedacted) {
		axisEntry->set_value(coords.values[axisIndex]);
		}
		}
		}
		}

		void AndroidInputEventProtoConverter::toProtoKeyEvent(const TracedKeyEvent& event,
		proto::AndroidKeyEvent& outProto,
		bool isRedacted) {
		outProto.set_event_id(event.id);
		outProto.set_event_time_nanos(event.eventTime);
		outProto.set_down_time_nanos(event.downTime);
		outProto.set_source(event.source);
		outProto.set_action(event.action);
		outProto.set_device_id(event.deviceId);
		outProto.set_display_id(event.displayId.val());
		outProto.set_repeat_count(event.repeatCount);
		outProto.set_flags(event.flags);
		outProto.set_policy_flags(event.policyFlags);

		if (!isRedacted) {
		outProto.set_key_code(event.keyCode);
		outProto.set_scan_code(event.scanCode);
		outProto.set_meta_state(event.metaState);
		}
		}

		void AndroidInputEventProtoConverter::toProtoWindowDispatchEvent(
		const WindowDispatchArgs& args, proto::AndroidWindowInputDispatchEvent& outProto,
		bool isRedacted) {
		std::visit([&](auto entry) { outProto.set_event_id(entry.id); }, args.eventEntry);
		outProto.set_vsync_id(args.vsyncId);
		outProto.set_window_id(args.windowId);
		outProto.set_resolved_flags(args.resolvedFlags);

		if (isRedacted) {
		return;
		}
		if (auto* motion = std::get_if<TracedMotionEvent>(&args.eventEntry); motion != nullptr) {
		for (size_t i = 0; i < motion->pointerProperties.size(); i++) {
		auto* pointerProto = outProto.add_dispatched_pointer();
		pointerProto->set_pointer_id(motion->pointerProperties[i].id);
		const auto& coords = motion->pointerCoords[i];
		const auto rawXY =
		MotionEvent::calculateTransformedXY(motion->source, args.rawTransform,
		coords.getXYValue());
		if (coords.getXYValue() != rawXY) {
		// These values are only traced if they were modified by the raw transform
		// to save space. Trace consumers should be aware of this optimization.
		pointerProto->set_x_in_display(rawXY.x);
		pointerProto->set_y_in_display(rawXY.y);
		}

		const auto coordsInWindow =
		MotionEvent::calculateTransformedCoords(motion->source, motion->flags,
		args.transform, coords);
		auto bits = BitSet64(coords.bits);
		for (int32_t axisIndex = 0; !bits.isEmpty(); axisIndex++) {
		const uint32_t axis = bits.clearFirstMarkedBit();
		const float axisValueInWindow = coordsInWindow.values[axisIndex];
		// Only values that are modified by the window transform are traced.
		if (coords.values[axisIndex] != axisValueInWindow) {
		auto* axisEntry = pointerProto->add_axis_value_in_window();
		axisEntry->set_axis(axis);
		axisEntry->set_value(axisValueInWindow);
		}
		}
		}
		}
		}

		impl::TraceConfig AndroidInputEventProtoConverter::parseConfig(
		proto::AndroidInputEventConfig::Decoder& protoConfig) {
		if (protoConfig.has_mode() &&
		protoConfig.mode() == proto::AndroidInputEventConfig::TRACE_MODE_TRACE_ALL) {
		// User has requested the preset for maximal tracing
		return CONFIG_TRACE_ALL;
		}

		impl::TraceConfig config;

		// Parse trace flags
		if (protoConfig.has_trace_dispatcher_input_events() &&
		protoConfig.trace_dispatcher_input_events()) {
		config.flags \|= impl::TraceFlag::TRACE_DISPATCHER_INPUT_EVENTS;
		}
		if (protoConfig.has_trace_dispatcher_window_dispatch() &&
		protoConfig.trace_dispatcher_window_dispatch()) {
		config.flags \|= impl::TraceFlag::TRACE_DISPATCHER_WINDOW_DISPATCH;
		}

		// Parse trace rules
		auto rulesIt = protoConfig.rules();
		while (rulesIt) {
		proto::AndroidInputEventConfig::TraceRule::Decoder protoRule{rulesIt->as_bytes()};
		config.rules.emplace_back();
		auto& rule = config.rules.back();

		rule.level = protoRule.has_trace_level()
		? static_cast<impl::TraceLevel>(protoRule.trace_level())
		: impl::TraceLevel::TRACE_LEVEL_NONE;

		if (protoRule.has_match_all_packages()) {
		auto pkgIt = protoRule.match_all_packages();
		while (pkgIt) {
		rule.matchAllPackages.emplace_back(pkgIt->as_std_string());
		pkgIt++;
		}
		}

		if (protoRule.has_match_any_packages()) {
		auto pkgIt = protoRule.match_any_packages();
		while (pkgIt) {
		rule.matchAnyPackages.emplace_back(pkgIt->as_std_string());
		pkgIt++;
		}
		}

		if (protoRule.has_match_secure()) {
		rule.matchSecure = protoRule.match_secure();
		}

		if (protoRule.has_match_ime_connection_active()) {
		rule.matchImeConnectionActive = protoRule.match_ime_connection_active();
		}

		rulesIt++;
		}

		return config;
		}

		} // namespace android::inputdispatcher::trace

services/inputflinger/dispatcher/trace/AndroidInputEventProtoConverter.h

+187 −9

Original line number	Diff line number	Diff line
		@@ -26,20 +26,198 @@ namespace proto = perfetto::protos::pbzero;

		namespace android::inputdispatcher::trace {

		namespace internal {

		using namespace ftl::flag_operators;

		// The trace config to use for maximal tracing.
		const impl::TraceConfig CONFIG_TRACE_ALL{
		.flags = impl::TraceFlag::TRACE_DISPATCHER_INPUT_EVENTS \|
		impl::TraceFlag::TRACE_DISPATCHER_WINDOW_DISPATCH,
		.rules = {impl::TraceRule{.level = impl::TraceLevel::TRACE_LEVEL_COMPLETE,
		.matchAllPackages = {},
		.matchAnyPackages = {},
		.matchSecure{},
		.matchImeConnectionActive = {}}},
		};

		} // namespace internal

		/**
		* Write traced events into Perfetto protos.
		*
		* This class is templated so that the logic can be tested while substituting the proto classes
		* auto-generated by Perfetto's pbzero library with mock implementations.
		*/
		template <typename ProtoMotion, typename ProtoKey, typename ProtoDispatch,
		typename ProtoConfigDecoder>
		class AndroidInputEventProtoConverter {
		public:
		static void toProtoMotionEvent(const TracedMotionEvent& event,
		proto::AndroidMotionEvent& outProto, bool isRedacted);
		static void toProtoKeyEvent(const TracedKeyEvent& event, proto::AndroidKeyEvent& outProto,
		bool isRedacted);
		static void toProtoWindowDispatchEvent(const WindowDispatchArgs&,
		proto::AndroidWindowInputDispatchEvent& outProto,
		bool isRedacted);

		static impl::TraceConfig parseConfig(proto::AndroidInputEventConfig::Decoder& protoConfig);
		static void toProtoMotionEvent(const TracedMotionEvent& event, ProtoMotion& outProto,
		bool isRedacted) {
		outProto.set_event_id(event.id);
		outProto.set_event_time_nanos(event.eventTime);
		outProto.set_down_time_nanos(event.downTime);
		outProto.set_source(event.source);
		outProto.set_action(event.action);
		outProto.set_device_id(event.deviceId);
		outProto.set_display_id(event.displayId.val());
		outProto.set_classification(static_cast<int32_t>(event.classification));
		outProto.set_flags(event.flags);
		outProto.set_policy_flags(event.policyFlags);
		outProto.set_button_state(event.buttonState);
		outProto.set_action_button(event.actionButton);

		if (!isRedacted) {
		outProto.set_cursor_position_x(event.xCursorPosition);
		outProto.set_cursor_position_y(event.yCursorPosition);
		outProto.set_meta_state(event.metaState);
		outProto.set_precision_x(event.xPrecision);
		outProto.set_precision_y(event.yPrecision);
		}

		for (uint32_t i = 0; i < event.pointerProperties.size(); i++) {
		auto* pointer = outProto.add_pointer();

		const auto& props = event.pointerProperties[i];
		pointer->set_pointer_id(props.id);
		pointer->set_tool_type(static_cast<int32_t>(props.toolType));

		const auto& coords = event.pointerCoords[i];
		auto bits = BitSet64(coords.bits);
		for (int32_t axisIndex = 0; !bits.isEmpty(); axisIndex++) {
		const auto axis = bits.clearFirstMarkedBit();
		auto axisEntry = pointer->add_axis_value();
		axisEntry->set_axis(axis);

		if (!isRedacted) {
		axisEntry->set_value(coords.values[axisIndex]);
		}
		}
		}
		}

		static void toProtoKeyEvent(const TracedKeyEvent& event, ProtoKey& outProto, bool isRedacted) {
		outProto.set_event_id(event.id);
		outProto.set_event_time_nanos(event.eventTime);
		outProto.set_down_time_nanos(event.downTime);
		outProto.set_source(event.source);
		outProto.set_action(event.action);
		outProto.set_device_id(event.deviceId);
		outProto.set_display_id(event.displayId.val());
		outProto.set_repeat_count(event.repeatCount);
		outProto.set_flags(event.flags);
		outProto.set_policy_flags(event.policyFlags);

		if (!isRedacted) {
		outProto.set_key_code(event.keyCode);
		outProto.set_scan_code(event.scanCode);
		outProto.set_meta_state(event.metaState);
		}
		}

		static void toProtoWindowDispatchEvent(const WindowDispatchArgs& args, ProtoDispatch& outProto,
		bool isRedacted) {
		std::visit([&](auto entry) { outProto.set_event_id(entry.id); }, args.eventEntry);
		outProto.set_vsync_id(args.vsyncId);
		outProto.set_window_id(args.windowId);
		outProto.set_resolved_flags(args.resolvedFlags);

		if (isRedacted) {
		return;
		}
		if (auto* motion = std::get_if<TracedMotionEvent>(&args.eventEntry); motion != nullptr) {
		for (size_t i = 0; i < motion->pointerProperties.size(); i++) {
		auto* pointerProto = outProto.add_dispatched_pointer();
		pointerProto->set_pointer_id(motion->pointerProperties[i].id);
		const auto& coords = motion->pointerCoords[i];
		const auto rawXY =
		MotionEvent::calculateTransformedXY(motion->source, args.rawTransform,
		coords.getXYValue());
		if (coords.getXYValue() != rawXY) {
		// These values are only traced if they were modified by the raw transform
		// to save space. Trace consumers should be aware of this optimization.
		pointerProto->set_x_in_display(rawXY.x);
		pointerProto->set_y_in_display(rawXY.y);
		}

		const auto coordsInWindow =
		MotionEvent::calculateTransformedCoords(motion->source, motion->flags,
		args.transform, coords);
		auto bits = BitSet64(coords.bits);
		for (int32_t axisIndex = 0; !bits.isEmpty(); axisIndex++) {
		const uint32_t axis = bits.clearFirstMarkedBit();
		const float axisValueInWindow = coordsInWindow.values[axisIndex];
		// Only values that are modified by the window transform are traced.
		if (coords.values[axisIndex] != axisValueInWindow) {
		auto* axisEntry = pointerProto->add_axis_value_in_window();
		axisEntry->set_axis(axis);
		axisEntry->set_value(axisValueInWindow);
		}
		}
		}
		}
		}

		static impl::TraceConfig parseConfig(ProtoConfigDecoder& protoConfig) {
		if (protoConfig.has_mode() &&
		protoConfig.mode() == proto::AndroidInputEventConfig::TRACE_MODE_TRACE_ALL) {
		// User has requested the preset for maximal tracing
		return internal::CONFIG_TRACE_ALL;
		}

		impl::TraceConfig config;

		// Parse trace flags
		if (protoConfig.has_trace_dispatcher_input_events() &&
		protoConfig.trace_dispatcher_input_events()) {
		config.flags \|= impl::TraceFlag::TRACE_DISPATCHER_INPUT_EVENTS;
		}
		if (protoConfig.has_trace_dispatcher_window_dispatch() &&
		protoConfig.trace_dispatcher_window_dispatch()) {
		config.flags \|= impl::TraceFlag::TRACE_DISPATCHER_WINDOW_DISPATCH;
		}

		// Parse trace rules
		auto rulesIt = protoConfig.rules();
		while (rulesIt) {
		proto::AndroidInputEventConfig::TraceRule::Decoder protoRule{rulesIt->as_bytes()};
		config.rules.emplace_back();
		auto& rule = config.rules.back();

		rule.level = protoRule.has_trace_level()
		? static_cast<impl::TraceLevel>(protoRule.trace_level())
		: impl::TraceLevel::TRACE_LEVEL_NONE;

		if (protoRule.has_match_all_packages()) {
		auto pkgIt = protoRule.match_all_packages();
		while (pkgIt) {
		rule.matchAllPackages.emplace_back(pkgIt->as_std_string());
		pkgIt++;
		}
		}

		if (protoRule.has_match_any_packages()) {
		auto pkgIt = protoRule.match_any_packages();
		while (pkgIt) {
		rule.matchAnyPackages.emplace_back(pkgIt->as_std_string());
		pkgIt++;
		}
		}

		if (protoRule.has_match_secure()) {
		rule.matchSecure = protoRule.match_secure();
		}

		if (protoRule.has_match_ime_connection_active()) {
		rule.matchImeConnectionActive = protoRule.match_ime_connection_active();
		}

		rulesIt++;
		}

		return config;
		}
		};

		} // namespace android::inputdispatcher::trace

services/inputflinger/dispatcher/trace/InputTracingBackendInterface.h

+1 −1

Original line number	Diff line number	Diff line
		@@ -70,7 +70,7 @@ struct TracedMotionEvent {
		uint32_t policyFlags;
		int32_t deviceId;
		uint32_t source;
		ui::LogicalDisplayId displayId;
		ui::LogicalDisplayId displayId = ui::LogicalDisplayId::INVALID;
		int32_t action;
		int32_t actionButton;
		int32_t flags;

services/inputflinger/dispatcher/trace/InputTracingPerfettoBackend.cpp

+9 −5

Original line number	Diff line number	Diff line
		@@ -34,6 +34,11 @@ namespace {

		constexpr auto INPUT_EVENT_TRACE_DATA_SOURCE_NAME = "android.input.inputevent";

		using ProtoConverter =
		AndroidInputEventProtoConverter<proto::AndroidMotionEvent, proto::AndroidKeyEvent,
		proto::AndroidWindowInputDispatchEvent,
		proto::AndroidInputEventConfig::Decoder>;

		bool isPermanentlyAllowed(gui::Uid uid) {
		switch (uid.val()) {
		case AID_SYSTEM:
		@@ -85,7 +90,7 @@ void PerfettoBackend::InputEventDataSource::OnSetup(const InputEventDataSource::
		const auto rawConfig = args.config->android_input_event_config_raw();
		auto protoConfig = perfetto::protos::pbzero::AndroidInputEventConfig::Decoder{rawConfig};

		mConfig = AndroidInputEventProtoConverter::parseConfig(protoConfig);
		mConfig = ProtoConverter::parseConfig(protoConfig);
		}

		void PerfettoBackend::InputEventDataSource::OnStart(const InputEventDataSource::StartArgs&) {
		@@ -238,7 +243,7 @@ void PerfettoBackend::traceMotionEvent(const TracedMotionEvent& event,
		auto* inputEvent = winscopeExtensions->set_android_input_event();
		auto* dispatchMotion = isRedacted ? inputEvent->set_dispatcher_motion_event_redacted()
		: inputEvent->set_dispatcher_motion_event();
		AndroidInputEventProtoConverter::toProtoMotionEvent(event, *dispatchMotion, isRedacted);
		ProtoConverter::toProtoMotionEvent(event, *dispatchMotion, isRedacted);
		});
		}

		@@ -266,7 +271,7 @@ void PerfettoBackend::traceKeyEvent(const TracedKeyEvent& event,
		auto* inputEvent = winscopeExtensions->set_android_input_event();
		auto* dispatchKey = isRedacted ? inputEvent->set_dispatcher_key_event_redacted()
		: inputEvent->set_dispatcher_key_event();
		AndroidInputEventProtoConverter::toProtoKeyEvent(event, *dispatchKey, isRedacted);
		ProtoConverter::toProtoKeyEvent(event, *dispatchKey, isRedacted);
		});
		}

		@@ -295,8 +300,7 @@ void PerfettoBackend::traceWindowDispatch(const WindowDispatchArgs& dispatchArgs
		auto* dispatchEvent = isRedacted
		? inputEvent->set_dispatcher_window_dispatch_event_redacted()
		: inputEvent->set_dispatcher_window_dispatch_event();
		AndroidInputEventProtoConverter::toProtoWindowDispatchEvent(dispatchArgs, *dispatchEvent,
		isRedacted);
		ProtoConverter::toProtoWindowDispatchEvent(dispatchArgs, *dispatchEvent, isRedacted);
		});
		}

services/inputflinger/tests/Android.bp

+1 −0

Original line number	Diff line number	Diff line
		@@ -48,6 +48,7 @@ cc_test {
		],
		srcs: [
		":inputdispatcher_common_test_sources",
		"AndroidInputEventProtoConverter_test.cpp",
		"AnrTracker_test.cpp",
		"CapturedTouchpadEventConverter_test.cpp",
		"CursorInputMapper_test.cpp",