Snap for 11084970 from d90ac11ceb4b16dfee7476f8963ff8ac7afce9bc to 24Q1-release (f937264c) · Commits · e / os / android_frameworks_native

libs/binder/rust/src/parcel/file_descriptor.rs

+10 −11

Original line number	Diff line number	Diff line
		@@ -22,29 +22,28 @@ use crate::binder::AsNative;
		use crate::error::{status_result, Result, StatusCode};
		use crate::sys;

		use std::fs::File;
		use std::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd};
		use std::os::fd::{AsRawFd, FromRawFd, IntoRawFd, OwnedFd, RawFd};

		/// Rust version of the Java class android.os.ParcelFileDescriptor
		#[derive(Debug)]
		pub struct ParcelFileDescriptor(File);
		pub struct ParcelFileDescriptor(OwnedFd);

		impl ParcelFileDescriptor {
		/// Create a new `ParcelFileDescriptor`
		pub fn new(file: File) -> Self {
		Self(file)
		pub fn new<F: Into<OwnedFd>>(fd: F) -> Self {
		Self(fd.into())
		}
		}

		impl AsRef<File> for ParcelFileDescriptor {
		fn as_ref(&self) -> &File {
		impl AsRef<OwnedFd> for ParcelFileDescriptor {
		fn as_ref(&self) -> &OwnedFd {
		&self.0
		}
		}

		impl From<ParcelFileDescriptor> for File {
		fn from(file: ParcelFileDescriptor) -> File {
		file.0
		impl From<ParcelFileDescriptor> for OwnedFd {
		fn from(fd: ParcelFileDescriptor) -> OwnedFd {
		fd.0
		}
		}

		@@ -120,7 +119,7 @@ impl DeserializeOption for ParcelFileDescriptor {
		// Safety: At this point, we know that the file descriptor was
		// not -1, so must be a valid, owned file descriptor which we
		// can safely turn into a `File`.
		let file = unsafe { File::from_raw_fd(fd) };
		let file = unsafe { OwnedFd::from_raw_fd(fd) };
		Ok(Some(ParcelFileDescriptor::new(file)))
		}
		}

libs/gui/tests/Surface_test.cpp

+0 −65

Original line number	Diff line number	Diff line
		@@ -208,21 +208,6 @@ protected:
		ASSERT_EQ(NO_ERROR, surface->disconnect(NATIVE_WINDOW_API_CPU));
		}

		static status_t captureDisplay(DisplayCaptureArgs& captureArgs,
		ScreenCaptureResults& captureResults) {
		const auto sf = ComposerServiceAIDL::getComposerService();
		SurfaceComposerClient::Transaction().apply(true);

		const sp<SyncScreenCaptureListener> captureListener = new SyncScreenCaptureListener();
		binder::Status status = sf->captureDisplay(captureArgs, captureListener);
		status_t err = gui::aidl_utils::statusTFromBinderStatus(status);
		if (err != NO_ERROR) {
		return err;
		}
		captureResults = captureListener->waitForResults();
		return fenceStatus(captureResults.fenceResult);
		}

		sp<Surface> mSurface;
		sp<SurfaceComposerClient> mComposerClient;
		sp<SurfaceControl> mSurfaceControl;
		@@ -260,56 +245,6 @@ TEST_F(SurfaceTest, QueuesToWindowComposerIsTrueWhenPurgatorized) {
		EXPECT_EQ(1, result);
		}

		// This test probably doesn't belong here.
		TEST_F(SurfaceTest, ScreenshotsOfProtectedBuffersDontSucceed) {
		sp<ANativeWindow> anw(mSurface);

		// Verify the screenshot works with no protected buffers.
		const auto ids = SurfaceComposerClient::getPhysicalDisplayIds();
		ASSERT_FALSE(ids.empty());
		// display 0 is picked for now, can extend to support all displays if needed
		const sp<IBinder> display = SurfaceComposerClient::getPhysicalDisplayToken(ids.front());
		ASSERT_FALSE(display == nullptr);

		DisplayCaptureArgs captureArgs;
		captureArgs.displayToken = display;
		captureArgs.width = 64;
		captureArgs.height = 64;

		ScreenCaptureResults captureResults;
		ASSERT_EQ(NO_ERROR, captureDisplay(captureArgs, captureResults));

		ASSERT_EQ(NO_ERROR, native_window_api_connect(anw.get(),
		NATIVE_WINDOW_API_CPU));
		// Set the PROTECTED usage bit and verify that the screenshot fails. Note
		// that we need to dequeue a buffer in order for it to actually get
		// allocated in SurfaceFlinger.
		ASSERT_EQ(NO_ERROR, native_window_set_usage(anw.get(),
		GRALLOC_USAGE_PROTECTED));
		ASSERT_EQ(NO_ERROR, native_window_set_buffer_count(anw.get(), 3));
		ANativeWindowBuffer* buf = nullptr;

		status_t err = native_window_dequeue_buffer_and_wait(anw.get(), &buf);
		if (err) {
		// we could fail if GRALLOC_USAGE_PROTECTED is not supported.
		// that's okay as long as this is the reason for the failure.
		// try again without the GRALLOC_USAGE_PROTECTED bit.
		ASSERT_EQ(NO_ERROR, native_window_set_usage(anw.get(), 0));
		ASSERT_EQ(NO_ERROR, native_window_dequeue_buffer_and_wait(anw.get(),
		&buf));
		return;
		}
		ASSERT_EQ(NO_ERROR, anw->cancelBuffer(anw.get(), buf, -1));

		for (int i = 0; i < 4; i++) {
		// Loop to make sure SurfaceFlinger has retired a protected buffer.
		ASSERT_EQ(NO_ERROR, native_window_dequeue_buffer_and_wait(anw.get(),
		&buf));
		ASSERT_EQ(NO_ERROR, anw->queueBuffer(anw.get(), buf, -1));
		}
		ASSERT_EQ(NO_ERROR, captureDisplay(captureArgs, captureResults));
		}

		TEST_F(SurfaceTest, ConcreteTypeIsSurface) {
		sp<ANativeWindow> anw(mSurface);
		int result = -123;

services/inputflinger/PointerChoreographer.cpp

+163 −13

Original line number	Diff line number	Diff line
		@@ -31,16 +31,30 @@ bool isFromMouse(const NotifyMotionArgs& args) {
		args.pointerProperties[0].toolType == ToolType::MOUSE;
		}

		bool isHoverAction(int32_t action) {
		return action == AMOTION_EVENT_ACTION_HOVER_ENTER \|\|
		action == AMOTION_EVENT_ACTION_HOVER_MOVE \|\| action == AMOTION_EVENT_ACTION_HOVER_EXIT;
		}

		bool isStylusHoverEvent(const NotifyMotionArgs& args) {
		return isStylusEvent(args.source, args.pointerProperties) && isHoverAction(args.action);
		}
		} // namespace

		// --- PointerChoreographer ---

		PointerChoreographer::PointerChoreographer(InputListenerInterface& listener,
		PointerChoreographerPolicyInterface& policy)
		: mNextListener(listener),
		: mTouchControllerConstructor([this]() REQUIRES(mLock) {
		return mPolicy.createPointerController(
		PointerControllerInterface::ControllerType::TOUCH);
		}),
		mNextListener(listener),
		mPolicy(policy),
		mDefaultMouseDisplayId(ADISPLAY_ID_DEFAULT),
		mNotifiedPointerDisplayId(ADISPLAY_ID_NONE) {}
		mNotifiedPointerDisplayId(ADISPLAY_ID_NONE),
		mShowTouchesEnabled(false),
		mStylusPointerIconEnabled(false) {}

		void PointerChoreographer::notifyInputDevicesChanged(const NotifyInputDevicesChangedArgs& args) {
		std::scoped_lock _l(mLock);
		@@ -69,8 +83,10 @@ NotifyMotionArgs PointerChoreographer::processMotion(const NotifyMotionArgs& arg

		if (isFromMouse(args)) {
		return processMouseEventLocked(args);
		} else if (mStylusPointerIconEnabled && isStylusHoverEvent(args)) {
		processStylusHoverEventLocked(args);
		} else if (isFromSource(args.source, AINPUT_SOURCE_TOUCHSCREEN)) {
		return processTouchscreenEventLocked(args);
		processTouchscreenAndStylusEventLocked(args);
		}
		return args;
		}
		@@ -114,12 +130,70 @@ NotifyMotionArgs PointerChoreographer::processMouseEventLocked(const NotifyMotio
		* mouse device keeps moving and unfades the cursor.
		* For touch events, we do not need to populate the cursor position.
		*/
		NotifyMotionArgs PointerChoreographer::processTouchscreenEventLocked(const NotifyMotionArgs& args) {
		void PointerChoreographer::processTouchscreenAndStylusEventLocked(const NotifyMotionArgs& args) {
		if (args.displayId == ADISPLAY_ID_NONE) {
		return;
		}

		if (const auto it = mMousePointersByDisplay.find(args.displayId);
		it != mMousePointersByDisplay.end() && args.action == AMOTION_EVENT_ACTION_DOWN) {
		it->second->fade(PointerControllerInterface::Transition::GRADUAL);
		}
		return args;

		if (!mShowTouchesEnabled) {
		return;
		}

		// Get the touch pointer controller for the device, or create one if it doesn't exist.
		auto [it, _] = mTouchPointersByDevice.try_emplace(args.deviceId, mTouchControllerConstructor);

		PointerControllerInterface& pc = *it->second;

		const PointerCoords* coords = args.pointerCoords.data();
		const int32_t maskedAction = MotionEvent::getActionMasked(args.action);
		const uint8_t actionIndex = MotionEvent::getActionIndex(args.action);
		std::array<uint32_t, MAX_POINTER_ID + 1> idToIndex;
		BitSet32 idBits;
		if (maskedAction != AMOTION_EVENT_ACTION_UP && maskedAction != AMOTION_EVENT_ACTION_CANCEL) {
		for (size_t i = 0; i < args.getPointerCount(); i++) {
		if (maskedAction == AMOTION_EVENT_ACTION_POINTER_UP && actionIndex == i) {
		continue;
		}
		uint32_t id = args.pointerProperties[i].id;
		idToIndex[id] = i;
		idBits.markBit(id);
		}
		}
		// The PointerController already handles setting spots per-display, so
		// we do not need to manually manage display changes for touch spots for now.
		pc.setSpots(coords, idToIndex.cbegin(), idBits, args.displayId);
		}

		void PointerChoreographer::processStylusHoverEventLocked(const NotifyMotionArgs& args) {
		if (args.displayId == ADISPLAY_ID_NONE) {
		return;
		}

		if (args.getPointerCount() != 1) {
		LOG(WARNING) << "Only stylus hover events with a single pointer are currently supported: "
		<< args.dump();
		}

		// Get the stylus pointer controller for the device, or create one if it doesn't exist.
		auto [it, _] =
		mStylusPointersByDevice.try_emplace(args.deviceId,
		getStylusControllerConstructor(args.displayId));

		PointerControllerInterface& pc = *it->second;

		const float x = args.pointerCoords[0].getAxisValue(AMOTION_EVENT_AXIS_X);
		const float y = args.pointerCoords[0].getAxisValue(AMOTION_EVENT_AXIS_Y);
		pc.setPosition(x, y);
		if (args.action == AMOTION_EVENT_ACTION_HOVER_EXIT) {
		pc.fade(PointerControllerInterface::Transition::IMMEDIATE);
		} else {
		pc.unfade(PointerControllerInterface::Transition::IMMEDIATE);
		}
		}

		void PointerChoreographer::notifySwitch(const NotifySwitchArgs& args) {
		@@ -135,9 +209,17 @@ void PointerChoreographer::notifyVibratorState(const NotifyVibratorStateArgs& ar
		}

		void PointerChoreographer::notifyDeviceReset(const NotifyDeviceResetArgs& args) {
		processDeviceReset(args);

		mNextListener.notify(args);
		}

		void PointerChoreographer::processDeviceReset(const NotifyDeviceResetArgs& args) {
		std::scoped_lock _l(mLock);
		mTouchPointersByDevice.erase(args.deviceId);
		mStylusPointersByDevice.erase(args.deviceId);
		}

		void PointerChoreographer::notifyPointerCaptureChanged(
		const NotifyPointerCaptureChangedArgs& args) {
		if (args.request.enable) {
		@@ -153,12 +235,25 @@ void PointerChoreographer::dump(std::string& dump) {
		std::scoped_lock _l(mLock);

		dump += "PointerChoreographer:\n";
		dump += StringPrintf("show touches: %s\n", mShowTouchesEnabled ? "true" : "false");
		dump += StringPrintf("stylus pointer icon enabled: %s\n",
		mStylusPointerIconEnabled ? "true" : "false");

		dump += INDENT "MousePointerControllers:\n";
		for (const auto& [displayId, mousePointerController] : mMousePointersByDisplay) {
		std::string pointerControllerDump = addLinePrefix(mousePointerController->dump(), INDENT);
		dump += INDENT + std::to_string(displayId) + " : " + pointerControllerDump;
		}
		dump += INDENT "TouchPointerControllers:\n";
		for (const auto& [deviceId, touchPointerController] : mTouchPointersByDevice) {
		std::string pointerControllerDump = addLinePrefix(touchPointerController->dump(), INDENT);
		dump += INDENT + std::to_string(deviceId) + " : " + pointerControllerDump;
		}
		dump += INDENT "StylusPointerControllers:\n";
		for (const auto& [deviceId, stylusPointerController] : mStylusPointersByDevice) {
		std::string pointerControllerDump = addLinePrefix(stylusPointerController->dump(), INDENT);
		dump += INDENT + std::to_string(deviceId) + " : " + pointerControllerDump;
		}
		dump += "\n";
		}

		@@ -175,8 +270,16 @@ int32_t PointerChoreographer::getTargetMouseDisplayLocked(int32_t associatedDisp
		return associatedDisplayId == ADISPLAY_ID_NONE ? mDefaultMouseDisplayId : associatedDisplayId;
		}

		InputDeviceInfo* PointerChoreographer::findInputDeviceLocked(DeviceId deviceId) {
		auto it = std::find_if(mInputDeviceInfos.begin(), mInputDeviceInfos.end(),
		[deviceId](const auto& info) { return info.getId() == deviceId; });
		return it != mInputDeviceInfos.end() ? &(*it) : nullptr;
		}

		void PointerChoreographer::updatePointerControllersLocked() {
		std::set<int32_t /displayId/> mouseDisplaysToKeep;
		std::set<DeviceId> touchDevicesToKeep;
		std::set<DeviceId> stylusDevicesToKeep;

		// Mark the displayIds or deviceIds of PointerControllers currently needed.
		for (const auto& info : mInputDeviceInfos) {
		@@ -187,17 +290,25 @@ void PointerChoreographer::updatePointerControllersLocked() {
		getTargetMouseDisplayLocked(info.getAssociatedDisplayId());
		mouseDisplaysToKeep.insert(resolvedDisplayId);
		}
		if (isFromSource(sources, AINPUT_SOURCE_TOUCHSCREEN) && mShowTouchesEnabled &&
		info.getAssociatedDisplayId() != ADISPLAY_ID_NONE) {
		touchDevicesToKeep.insert(info.getId());
		}
		if (isFromSource(sources, AINPUT_SOURCE_STYLUS) && mStylusPointerIconEnabled &&
		info.getAssociatedDisplayId() != ADISPLAY_ID_NONE) {
		stylusDevicesToKeep.insert(info.getId());
		}
		}

		// Remove PointerControllers no longer needed.
		// This has the side-effect of fading pointers or clearing spots before removal.
		std::erase_if(mMousePointersByDisplay, [&mouseDisplaysToKeep](const auto& pair) {
		auto& [displayId, controller] = pair;
		if (mouseDisplaysToKeep.find(displayId) == mouseDisplaysToKeep.end()) {
		controller->fade(PointerControllerInterface::Transition::IMMEDIATE);
		return true;
		}
		return false;
		return mouseDisplaysToKeep.find(pair.first) == mouseDisplaysToKeep.end();
		});
		std::erase_if(mTouchPointersByDevice, [&touchDevicesToKeep](const auto& pair) {
		return touchDevicesToKeep.find(pair.first) == touchDevicesToKeep.end();
		});
		std::erase_if(mStylusPointersByDevice, [&stylusDevicesToKeep](const auto& pair) {
		return stylusDevicesToKeep.find(pair.first) == stylusDevicesToKeep.end();
		});

		// Notify the policy if there's a change on the pointer display ID.
		@@ -234,10 +345,17 @@ void PointerChoreographer::setDefaultMouseDisplayId(int32_t displayId) {
		void PointerChoreographer::setDisplayViewports(const std::vector<DisplayViewport>& viewports) {
		std::scoped_lock _l(mLock);
		for (const auto& viewport : viewports) {
		if (const auto it = mMousePointersByDisplay.find(viewport.displayId);
		const int32_t displayId = viewport.displayId;
		if (const auto it = mMousePointersByDisplay.find(displayId);
		it != mMousePointersByDisplay.end()) {
		it->second->setDisplayViewport(viewport);
		}
		for (const auto& [deviceId, stylusPointerController] : mStylusPointersByDevice) {
		const InputDeviceInfo* info = findInputDeviceLocked(deviceId);
		if (info && info->getAssociatedDisplayId() == displayId) {
		stylusPointerController->setDisplayViewport(viewport);
		}
		}
		}
		mViewports = viewports;
		notifyPointerDisplayIdChangedLocked();
		@@ -263,6 +381,24 @@ FloatPoint PointerChoreographer::getMouseCursorPosition(int32_t displayId) {
		return {AMOTION_EVENT_INVALID_CURSOR_POSITION, AMOTION_EVENT_INVALID_CURSOR_POSITION};
		}

		void PointerChoreographer::setShowTouchesEnabled(bool enabled) {
		std::scoped_lock _l(mLock);
		if (mShowTouchesEnabled == enabled) {
		return;
		}
		mShowTouchesEnabled = enabled;
		updatePointerControllersLocked();
		}

		void PointerChoreographer::setStylusPointerIconEnabled(bool enabled) {
		std::scoped_lock _l(mLock);
		if (mStylusPointerIconEnabled == enabled) {
		return;
		}
		mStylusPointerIconEnabled = enabled;
		updatePointerControllersLocked();
		}

		PointerChoreographer::ControllerConstructor PointerChoreographer::getMouseControllerConstructor(
		int32_t displayId) {
		std::function<std::shared_ptr<PointerControllerInterface>()> ctor =
		@@ -277,4 +413,18 @@ PointerChoreographer::ControllerConstructor PointerChoreographer::getMouseContro
		return ConstructorDelegate(std::move(ctor));
		}

		PointerChoreographer::ControllerConstructor PointerChoreographer::getStylusControllerConstructor(
		int32_t displayId) {
		std::function<std::shared_ptr<PointerControllerInterface>()> ctor =
		[this, displayId]() REQUIRES(mLock) {
		auto pc = mPolicy.createPointerController(
		PointerControllerInterface::ControllerType::STYLUS);
		if (const auto viewport = findViewportByIdLocked(displayId); viewport) {
		pc->setDisplayViewport(*viewport);
		}
		return pc;
		};
		return ConstructorDelegate(std::move(ctor));
		}

		} // namespace android

services/inputflinger/PointerChoreographer.h

+16 −1

Original line number	Diff line number	Diff line
		@@ -56,6 +56,8 @@ public:
		virtual std::optional<DisplayViewport> getViewportForPointerDevice(
		int32_t associatedDisplayId = ADISPLAY_ID_NONE) = 0;
		virtual FloatPoint getMouseCursorPosition(int32_t displayId) = 0;
		virtual void setShowTouchesEnabled(bool enabled) = 0;
		virtual void setStylusPointerIconEnabled(bool enabled) = 0;
		/**
		* This method may be called on any thread (usually by the input manager on a binder thread).
		*/
		@@ -73,6 +75,8 @@ public:
		std::optional<DisplayViewport> getViewportForPointerDevice(
		int32_t associatedDisplayId) override;
		FloatPoint getMouseCursorPosition(int32_t displayId) override;
		void setShowTouchesEnabled(bool enabled) override;
		void setStylusPointerIconEnabled(bool enabled) override;

		void notifyInputDevicesChanged(const NotifyInputDevicesChangedArgs& args) override;
		void notifyConfigurationChanged(const NotifyConfigurationChangedArgs& args) override;
		@@ -91,14 +95,19 @@ private:
		void notifyPointerDisplayIdChangedLocked() REQUIRES(mLock);
		const DisplayViewport* findViewportByIdLocked(int32_t displayId) const REQUIRES(mLock);
		int32_t getTargetMouseDisplayLocked(int32_t associatedDisplayId) const REQUIRES(mLock);
		InputDeviceInfo* findInputDeviceLocked(DeviceId deviceId) REQUIRES(mLock);

		NotifyMotionArgs processMotion(const NotifyMotionArgs& args);
		NotifyMotionArgs processMouseEventLocked(const NotifyMotionArgs& args) REQUIRES(mLock);
		NotifyMotionArgs processTouchscreenEventLocked(const NotifyMotionArgs& args) REQUIRES(mLock);
		void processTouchscreenAndStylusEventLocked(const NotifyMotionArgs& args) REQUIRES(mLock);
		void processStylusHoverEventLocked(const NotifyMotionArgs& args) REQUIRES(mLock);
		void processDeviceReset(const NotifyDeviceResetArgs& args);

		using ControllerConstructor =
		ConstructorDelegate<std::function<std::shared_ptr<PointerControllerInterface>()>>;
		ControllerConstructor mTouchControllerConstructor GUARDED_BY(mLock);
		ControllerConstructor getMouseControllerConstructor(int32_t displayId) REQUIRES(mLock);
		ControllerConstructor getStylusControllerConstructor(int32_t displayId) REQUIRES(mLock);

		std::mutex mLock;

		@@ -107,11 +116,17 @@ private:

		std::map<int32_t, std::shared_ptr<PointerControllerInterface>> mMousePointersByDisplay
		GUARDED_BY(mLock);
		std::map<DeviceId, std::shared_ptr<PointerControllerInterface>> mTouchPointersByDevice
		GUARDED_BY(mLock);
		std::map<DeviceId, std::shared_ptr<PointerControllerInterface>> mStylusPointersByDevice
		GUARDED_BY(mLock);

		int32_t mDefaultMouseDisplayId GUARDED_BY(mLock);
		int32_t mNotifiedPointerDisplayId GUARDED_BY(mLock);
		std::vector<InputDeviceInfo> mInputDeviceInfos GUARDED_BY(mLock);
		std::vector<DisplayViewport> mViewports GUARDED_BY(mLock);
		bool mShowTouchesEnabled GUARDED_BY(mLock);
		bool mStylusPointerIconEnabled GUARDED_BY(mLock);
		};

		} // namespace android

services/inputflinger/include/PointerControllerInterface.h

+7 −3

Original line number	Diff line number	Diff line
		@@ -63,6 +63,10 @@ public:
		LEGACY,
		// Represents a single mouse pointer.
		MOUSE,
		// Represents multiple touch spots.
		TOUCH,
		// Represents a single stylus pointer.
		STYLUS,
		};

		/* Dumps the state of the pointer controller. */