Snap for 11533280 from 7c20ba903c8972f4d980d9d2d6a18717ad718061 to 24Q3-release (700f5a20) · Commits · e / os / android_frameworks_native

include/input/Input.h

+9 −0

Original line number	Diff line number	Diff line
		@@ -870,6 +870,10 @@ public:

		void copyFrom(const MotionEvent* other, bool keepHistory);

		// Initialize this event by keeping only the pointers from "other" that are in splitPointerIds.
		void splitFrom(const MotionEvent& other, std::bitset<MAX_POINTER_ID + 1> splitPointerIds,
		int32_t newEventId);

		void addSample(
		nsecs_t eventTime,
		const PointerCoords* pointerCoords);
		@@ -910,6 +914,11 @@ public:

		static std::string actionToString(int32_t action);

		static std::tuple<int32_t /action/, std::vector<PointerProperties>,
		std::vector<PointerCoords>>
		split(int32_t action, int32_t flags, int32_t historySize, const std::vector<PointerProperties>&,
		const std::vector<PointerCoords>&, std::bitset<MAX_POINTER_ID + 1> splitPointerIds);

		// MotionEvent will transform various axes in different ways, based on the source. For
		// example, the x and y axes will not have any offsets/translations applied if it comes from a
		// relative mouse device (since SOURCE_RELATIVE_MOUSE is a non-pointer source). These methods

include/input/InputEventBuilders.h

+14 −3

Original line number	Diff line number	Diff line
		@@ -118,6 +118,16 @@ public:
		return *this;
		}

		MotionEventBuilder& transform(ui::Transform t) {
		mTransform = t;
		return *this;
		}

		MotionEventBuilder& rawTransform(ui::Transform t) {
		mRawTransform = t;
		return *this;
		}

		MotionEvent build() {
		std::vector<PointerProperties> pointerProperties;
		std::vector<PointerCoords> pointerCoords;
		@@ -134,12 +144,11 @@ public:
		}

		MotionEvent event;
		static const ui::Transform kIdentityTransform;
		event.initialize(InputEvent::nextId(), mDeviceId, mSource, mDisplayId, INVALID_HMAC,
		mAction, mActionButton, mFlags, /edgeFlags=/0, AMETA_NONE, mButtonState,
		MotionClassification::NONE, kIdentityTransform,
		MotionClassification::NONE, mTransform,
		/xPrecision=/0, /yPrecision=/0, mRawXCursorPosition,
		mRawYCursorPosition, kIdentityTransform, mDownTime, mEventTime,
		mRawYCursorPosition, mRawTransform, mDownTime, mEventTime,
		mPointers.size(), pointerProperties.data(), pointerCoords.data());
		return event;
		}
		@@ -156,6 +165,8 @@ private:
		int32_t mFlags{0};
		float mRawXCursorPosition{AMOTION_EVENT_INVALID_CURSOR_POSITION};
		float mRawYCursorPosition{AMOTION_EVENT_INVALID_CURSOR_POSITION};
		ui::Transform mTransform;
		ui::Transform mRawTransform;

		std::vector<PointerBuilder> mPointers;
		};

include/powermanager/HalResult.h

0 → 100644

+165 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 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.
		*/

		#pragma once

		#include <android/binder_auto_utils.h>
		#include <android/binder_status.h>
		#include <android/hardware/power/1.0/IPower.h>
		#include <binder/Status.h>
		#include <hidl/HidlSupport.h>
		#include <string>

		namespace android::power {

		static bool checkUnsupported(const ndk::ScopedAStatus& ndkStatus) {
		return ndkStatus.getExceptionCode() == EX_UNSUPPORTED_OPERATION \|\|
		ndkStatus.getStatus() == STATUS_UNKNOWN_TRANSACTION;
		}

		static bool checkUnsupported(const binder::Status& status) {
		return status.exceptionCode() == binder::Status::EX_UNSUPPORTED_OPERATION \|\|
		status.transactionError() == UNKNOWN_TRANSACTION;
		}

		// Result of a call to the Power HAL wrapper, holding data if successful.
		template <typename T>
		class HalResult {
		public:
		static HalResult<T> ok(T&& value) { return HalResult(std::forward<T>(value)); }
		static HalResult<T> ok(T& value) { return HalResult<T>::ok(T{value}); }
		static HalResult<T> failed(std::string msg) { return HalResult(msg, /* unsupported= */ false); }
		static HalResult<T> unsupported() { return HalResult("", /* unsupported= */ true); }

		static HalResult<T> fromStatus(const binder::Status& status, T&& data) {
		if (checkUnsupported(status)) {
		return HalResult<T>::unsupported();
		}
		if (status.isOk()) {
		return HalResult<T>::ok(std::forward<T>(data));
		}
		return HalResult<T>::failed(std::string(status.toString8().c_str()));
		}

		static HalResult<T> fromStatus(const binder::Status& status, T& data) {
		return HalResult<T>::fromStatus(status, T{data});
		}

		static HalResult<T> fromStatus(const ndk::ScopedAStatus& ndkStatus, T&& data) {
		if (checkUnsupported(ndkStatus)) {
		return HalResult<T>::unsupported();
		}
		if (ndkStatus.isOk()) {
		return HalResult<T>::ok(std::forward<T>(data));
		}
		return HalResult<T>::failed(std::string(ndkStatus.getDescription()));
		}

		static HalResult<T> fromStatus(const ndk::ScopedAStatus& ndkStatus, T& data) {
		return HalResult<T>::fromStatus(ndkStatus, T{data});
		}

		template <typename R>
		static HalResult<T> fromReturn(hardware::Return<R>& ret, T&& data) {
		return ret.isOk() ? HalResult<T>::ok(std::forward<T>(data))
		: HalResult<T>::failed(ret.description());
		}

		template <typename R>
		static HalResult<T> fromReturn(hardware::Return<R>& ret, T& data) {
		return HalResult<T>::fromReturn(ret, T{data});
		}

		template <typename R>
		static HalResult<T> fromReturn(hardware::Return<R>& ret, hardware::power::V1_0::Status status,
		T&& data) {
		return ret.isOk() ? HalResult<T>::fromStatus(status, std::forward<T>(data))
		: HalResult<T>::failed(ret.description());
		}

		template <typename R>
		static HalResult<T> fromReturn(hardware::Return<R>& ret, hardware::power::V1_0::Status status,
		T& data) {
		return HalResult<T>::fromReturn(ret, status, T{data});
		}

		// This will throw std::bad_optional_access if this result is not ok.
		const T& value() const { return mValue.value(); }
		bool isOk() const { return !mUnsupported && mValue.has_value(); }
		bool isFailed() const { return !mUnsupported && !mValue.has_value(); }
		bool isUnsupported() const { return mUnsupported; }
		const char* errorMessage() const { return mErrorMessage.c_str(); }

		private:
		std::optional<T> mValue;
		std::string mErrorMessage;
		bool mUnsupported;

		explicit HalResult(T&& value)
		: mValue{std::move(value)}, mErrorMessage(), mUnsupported(false) {}
		explicit HalResult(std::string errorMessage, bool unsupported)
		: mValue(), mErrorMessage(std::move(errorMessage)), mUnsupported(unsupported) {}
		};

		// Empty result
		template <>
		class HalResult<void> {
		public:
		static HalResult<void> ok() { return HalResult(); }
		static HalResult<void> failed(std::string msg) { return HalResult(std::move(msg)); }
		static HalResult<void> unsupported() { return HalResult(/* unsupported= */ true); }

		static HalResult<void> fromStatus(const binder::Status& status) {
		if (checkUnsupported(status)) {
		return HalResult<void>::unsupported();
		}
		if (status.isOk()) {
		return HalResult<void>::ok();
		}
		return HalResult<void>::failed(std::string(status.toString8().c_str()));
		}

		static HalResult<void> fromStatus(const ndk::ScopedAStatus& ndkStatus) {
		if (ndkStatus.isOk()) {
		return HalResult<void>::ok();
		}
		if (checkUnsupported(ndkStatus)) {
		return HalResult<void>::unsupported();
		}
		return HalResult<void>::failed(ndkStatus.getDescription());
		}

		template <typename R>
		static HalResult<void> fromReturn(hardware::Return<R>& ret) {
		return ret.isOk() ? HalResult<void>::ok() : HalResult<void>::failed(ret.description());
		}

		bool isOk() const { return !mUnsupported && !mFailed; }
		bool isFailed() const { return !mUnsupported && mFailed; }
		bool isUnsupported() const { return mUnsupported; }
		const char* errorMessage() const { return mErrorMessage.c_str(); }

		private:
		std::string mErrorMessage;
		bool mFailed;
		bool mUnsupported;

		explicit HalResult(bool unsupported = false)
		: mErrorMessage(), mFailed(false), mUnsupported(unsupported) {}
		explicit HalResult(std::string errorMessage)
		: mErrorMessage(std::move(errorMessage)), mFailed(true), mUnsupported(false) {}
		};
		} // namespace android::power

include/powermanager/PowerHalController.h

+9 −8

Original line number	Diff line number	Diff line
		@@ -23,6 +23,7 @@
		#include <aidl/android/hardware/power/Mode.h>
		#include <android-base/thread_annotations.h>
		#include <powermanager/PowerHalWrapper.h>
		#include <powermanager/PowerHintSessionWrapper.h>

		namespace android {

		@@ -38,6 +39,7 @@ public:

		virtual std::unique_ptr<HalWrapper> connect();
		virtual void reset();
		virtual int32_t getAidlVersion();
		};

		// -------------------------------------------------------------------------------------------------
		@@ -59,12 +61,11 @@ public:
		int32_t durationMs) override;
		virtual HalResult<void> setMode(aidl::android::hardware::power::Mode mode,
		bool enabled) override;
		virtual HalResult<std::shared_ptr<aidl::android::hardware::power::IPowerHintSession>>
		createHintSession(int32_t tgid, int32_t uid, const std::vector<int32_t>& threadIds,
		virtual HalResult<std::shared_ptr<PowerHintSessionWrapper>> createHintSession(
		int32_t tgid, int32_t uid, const std::vector<int32_t>& threadIds,
		int64_t durationNanos) override;
		virtual HalResult<std::shared_ptr<aidl::android::hardware::power::IPowerHintSession>>
		createHintSessionWithConfig(int32_t tgid, int32_t uid, const std::vector<int32_t>& threadIds,
		int64_t durationNanos,
		virtual HalResult<std::shared_ptr<PowerHintSessionWrapper>> createHintSessionWithConfig(
		int32_t tgid, int32_t uid, const std::vector<int32_t>& threadIds, int64_t durationNanos,
		aidl::android::hardware::power::SessionTag tag,
		aidl::android::hardware::power::SessionConfig* config) override;
		virtual HalResult<int64_t> getHintSessionPreferredRate() override;

include/powermanager/PowerHalLoader.h

+4 −0

Original line number	Diff line number	Diff line
		@@ -36,6 +36,8 @@ public:
		static sp<hardware::power::V1_1::IPower> loadHidlV1_1();
		static sp<hardware::power::V1_2::IPower> loadHidlV1_2();
		static sp<hardware::power::V1_3::IPower> loadHidlV1_3();
		// Returns aidl interface version, or 0 if AIDL is not used
		static int32_t getAidlVersion();

		private:
		static std::mutex gHalMutex;
		@@ -48,6 +50,8 @@ private:
		static sp<hardware::power::V1_0::IPower> loadHidlV1_0Locked()
		EXCLUSIVE_LOCKS_REQUIRED(gHalMutex);

		static int32_t gAidlInterfaceVersion;

		PowerHalLoader() = delete;
		~PowerHalLoader() = delete;
		};