Send events wrapped in unique_ptr to InputConsumerCallbacks
This will allow the upper layers to release the ownership and hand the
object over to the ndk client. The client will then assume the
ownership. This is not possible with the current implementation of
rvalue, because the ndk interface is only using pointers.
Unfortunately, this makes things more clunky for tests (unless we modify
BlockingQueue).
Bug: 324271765
Test: TEST=libinput_tests; m $TEST && $ANDROID_HOST_OUT/nativetest64/$TEST/$TEST --gtest_repeat=100 --gtest_break_on_failure
Change-Id: I0cf326a22f840be6f8aa00d1e69f818815788487
diff --git a/include/input/InputConsumerNoResampling.h b/include/input/InputConsumerNoResampling.h
index 7e6ae9b..9e48b08 100644
--- a/include/input/InputConsumerNoResampling.h
+++ b/include/input/InputConsumerNoResampling.h
@@ -29,8 +29,8 @@
class InputConsumerCallbacks {
public:
virtual ~InputConsumerCallbacks(){};
- virtual void onKeyEvent(KeyEvent&& event, uint32_t seq) = 0;
- virtual void onMotionEvent(MotionEvent&& event, uint32_t seq) = 0;
+ virtual void onKeyEvent(std::unique_ptr<KeyEvent> event, uint32_t seq) = 0;
+ virtual void onMotionEvent(std::unique_ptr<MotionEvent> event, uint32_t seq) = 0;
/**
* When you receive this callback, you must (eventually) call "consumeBatchedInputEvents".
* If you don't want batching, then call "consumeBatchedInputEvents" immediately with
@@ -38,10 +38,10 @@
* @param pendingBatchSource the source of the pending batch.
*/
virtual void onBatchedInputEventPending(int32_t pendingBatchSource) = 0;
- virtual void onFocusEvent(FocusEvent&& event, uint32_t seq) = 0;
- virtual void onCaptureEvent(CaptureEvent&& event, uint32_t seq) = 0;
- virtual void onDragEvent(DragEvent&& event, uint32_t seq) = 0;
- virtual void onTouchModeEvent(TouchModeEvent&& event, uint32_t seq) = 0;
+ virtual void onFocusEvent(std::unique_ptr<FocusEvent> event, uint32_t seq) = 0;
+ virtual void onCaptureEvent(std::unique_ptr<CaptureEvent> event, uint32_t seq) = 0;
+ virtual void onDragEvent(std::unique_ptr<DragEvent> event, uint32_t seq) = 0;
+ virtual void onTouchModeEvent(std::unique_ptr<TouchModeEvent> event, uint32_t seq) = 0;
};
/**
diff --git a/libs/input/InputConsumerNoResampling.cpp b/libs/input/InputConsumerNoResampling.cpp
index 1462c90..52acb51 100644
--- a/libs/input/InputConsumerNoResampling.cpp
+++ b/libs/input/InputConsumerNoResampling.cpp
@@ -44,28 +44,37 @@
const bool DEBUG_TRANSPORT_CONSUMER =
__android_log_is_loggable(ANDROID_LOG_DEBUG, LOG_TAG "Consumer", ANDROID_LOG_INFO);
-void initializeKeyEvent(KeyEvent& event, const InputMessage& msg) {
- event.initialize(msg.body.key.eventId, msg.body.key.deviceId, msg.body.key.source,
- msg.body.key.displayId, msg.body.key.hmac, msg.body.key.action,
- msg.body.key.flags, msg.body.key.keyCode, msg.body.key.scanCode,
- msg.body.key.metaState, msg.body.key.repeatCount, msg.body.key.downTime,
- msg.body.key.eventTime);
+std::unique_ptr<KeyEvent> createKeyEvent(const InputMessage& msg) {
+ std::unique_ptr<KeyEvent> event = std::make_unique<KeyEvent>();
+ event->initialize(msg.body.key.eventId, msg.body.key.deviceId, msg.body.key.source,
+ msg.body.key.displayId, msg.body.key.hmac, msg.body.key.action,
+ msg.body.key.flags, msg.body.key.keyCode, msg.body.key.scanCode,
+ msg.body.key.metaState, msg.body.key.repeatCount, msg.body.key.downTime,
+ msg.body.key.eventTime);
+ return event;
}
-void initializeFocusEvent(FocusEvent& event, const InputMessage& msg) {
- event.initialize(msg.body.focus.eventId, msg.body.focus.hasFocus);
+std::unique_ptr<FocusEvent> createFocusEvent(const InputMessage& msg) {
+ std::unique_ptr<FocusEvent> event = std::make_unique<FocusEvent>();
+ event->initialize(msg.body.focus.eventId, msg.body.focus.hasFocus);
+ return event;
}
-void initializeCaptureEvent(CaptureEvent& event, const InputMessage& msg) {
- event.initialize(msg.body.capture.eventId, msg.body.capture.pointerCaptureEnabled);
+std::unique_ptr<CaptureEvent> createCaptureEvent(const InputMessage& msg) {
+ std::unique_ptr<CaptureEvent> event = std::make_unique<CaptureEvent>();
+ event->initialize(msg.body.capture.eventId, msg.body.capture.pointerCaptureEnabled);
+ return event;
}
-void initializeDragEvent(DragEvent& event, const InputMessage& msg) {
- event.initialize(msg.body.drag.eventId, msg.body.drag.x, msg.body.drag.y,
- msg.body.drag.isExiting);
+std::unique_ptr<DragEvent> createDragEvent(const InputMessage& msg) {
+ std::unique_ptr<DragEvent> event = std::make_unique<DragEvent>();
+ event->initialize(msg.body.drag.eventId, msg.body.drag.x, msg.body.drag.y,
+ msg.body.drag.isExiting);
+ return event;
}
-void initializeMotionEvent(MotionEvent& event, const InputMessage& msg) {
+std::unique_ptr<MotionEvent> createMotionEvent(const InputMessage& msg) {
+ std::unique_ptr<MotionEvent> event = std::make_unique<MotionEvent>();
const uint32_t pointerCount = msg.body.motion.pointerCount;
std::vector<PointerProperties> pointerProperties;
pointerProperties.reserve(pointerCount);
@@ -83,15 +92,16 @@
displayTransform.set({msg.body.motion.dsdxRaw, msg.body.motion.dtdxRaw, msg.body.motion.txRaw,
msg.body.motion.dtdyRaw, msg.body.motion.dsdyRaw, msg.body.motion.tyRaw,
0, 0, 1});
- event.initialize(msg.body.motion.eventId, msg.body.motion.deviceId, msg.body.motion.source,
- msg.body.motion.displayId, msg.body.motion.hmac, msg.body.motion.action,
- msg.body.motion.actionButton, msg.body.motion.flags, msg.body.motion.edgeFlags,
- msg.body.motion.metaState, msg.body.motion.buttonState,
- msg.body.motion.classification, transform, msg.body.motion.xPrecision,
- msg.body.motion.yPrecision, msg.body.motion.xCursorPosition,
- msg.body.motion.yCursorPosition, displayTransform, msg.body.motion.downTime,
- msg.body.motion.eventTime, pointerCount, pointerProperties.data(),
- pointerCoords.data());
+ event->initialize(msg.body.motion.eventId, msg.body.motion.deviceId, msg.body.motion.source,
+ msg.body.motion.displayId, msg.body.motion.hmac, msg.body.motion.action,
+ msg.body.motion.actionButton, msg.body.motion.flags,
+ msg.body.motion.edgeFlags, msg.body.motion.metaState,
+ msg.body.motion.buttonState, msg.body.motion.classification, transform,
+ msg.body.motion.xPrecision, msg.body.motion.yPrecision,
+ msg.body.motion.xCursorPosition, msg.body.motion.yCursorPosition,
+ displayTransform, msg.body.motion.downTime, msg.body.motion.eventTime,
+ pointerCount, pointerProperties.data(), pointerCoords.data());
+ return event;
}
void addSample(MotionEvent& event, const InputMessage& msg) {
@@ -107,8 +117,10 @@
event.addSample(msg.body.motion.eventTime, pointerCoords.data());
}
-void initializeTouchModeEvent(TouchModeEvent& event, const InputMessage& msg) {
- event.initialize(msg.body.touchMode.eventId, msg.body.touchMode.isInTouchMode);
+std::unique_ptr<TouchModeEvent> createTouchModeEvent(const InputMessage& msg) {
+ std::unique_ptr<TouchModeEvent> event = std::make_unique<TouchModeEvent>();
+ event->initialize(msg.body.touchMode.eventId, msg.body.touchMode.isInTouchMode);
+ return event;
}
std::string outboundMessageToString(const InputMessage& outboundMsg) {
@@ -388,15 +400,13 @@
void InputConsumerNoResampling::handleMessage(const InputMessage& msg) const {
switch (msg.header.type) {
case InputMessage::Type::KEY: {
- KeyEvent keyEvent;
- initializeKeyEvent(keyEvent, msg);
+ std::unique_ptr<KeyEvent> keyEvent = createKeyEvent(msg);
mCallbacks.onKeyEvent(std::move(keyEvent), msg.header.seq);
break;
}
case InputMessage::Type::MOTION: {
- MotionEvent motionEvent;
- initializeMotionEvent(motionEvent, msg);
+ std::unique_ptr<MotionEvent> motionEvent = createMotionEvent(msg);
mCallbacks.onMotionEvent(std::move(motionEvent), msg.header.seq);
break;
}
@@ -411,29 +421,25 @@
}
case InputMessage::Type::FOCUS: {
- FocusEvent focusEvent;
- initializeFocusEvent(focusEvent, msg);
+ std::unique_ptr<FocusEvent> focusEvent = createFocusEvent(msg);
mCallbacks.onFocusEvent(std::move(focusEvent), msg.header.seq);
break;
}
case InputMessage::Type::CAPTURE: {
- CaptureEvent captureEvent;
- initializeCaptureEvent(captureEvent, msg);
+ std::unique_ptr<CaptureEvent> captureEvent = createCaptureEvent(msg);
mCallbacks.onCaptureEvent(std::move(captureEvent), msg.header.seq);
break;
}
case InputMessage::Type::DRAG: {
- DragEvent dragEvent;
- initializeDragEvent(dragEvent, msg);
+ std::unique_ptr<DragEvent> dragEvent = createDragEvent(msg);
mCallbacks.onDragEvent(std::move(dragEvent), msg.header.seq);
break;
}
case InputMessage::Type::TOUCH_MODE: {
- TouchModeEvent touchModeEvent;
- initializeTouchModeEvent(touchModeEvent, msg);
+ std::unique_ptr<TouchModeEvent> touchModeEvent = createTouchModeEvent(msg);
mCallbacks.onTouchModeEvent(std::move(touchModeEvent), msg.header.seq);
break;
}
@@ -448,7 +454,7 @@
const nsecs_t frameTime = requestedFrameTime.value_or(std::numeric_limits<nsecs_t>::max());
bool producedEvents = false;
for (auto& [deviceId, messages] : mBatches) {
- MotionEvent motion;
+ std::unique_ptr<MotionEvent> motion;
std::optional<uint32_t> firstSeqForBatch;
std::vector<uint32_t> sequences;
while (!messages.empty()) {
@@ -456,20 +462,21 @@
if (msg.body.motion.eventTime > frameTime) {
break;
}
- if (!firstSeqForBatch.has_value()) {
- initializeMotionEvent(motion, msg);
+ if (motion == nullptr) {
+ motion = createMotionEvent(msg);
firstSeqForBatch = msg.header.seq;
const auto [_, inserted] = mBatchedSequenceNumbers.insert({*firstSeqForBatch, {}});
if (!inserted) {
LOG(FATAL) << "The sequence " << msg.header.seq << " was already present!";
}
} else {
- addSample(motion, msg);
+ addSample(*motion, msg);
mBatchedSequenceNumbers[*firstSeqForBatch].push_back(msg.header.seq);
}
messages.pop();
}
- if (firstSeqForBatch.has_value()) {
+ if (motion != nullptr) {
+ LOG_ALWAYS_FATAL_IF(!firstSeqForBatch.has_value());
mCallbacks.onMotionEvent(std::move(motion), *firstSeqForBatch);
producedEvents = true;
} else {
@@ -520,9 +527,8 @@
std::queue<InputMessage> tmpQueue = messages;
while (!tmpQueue.empty()) {
LOG_ALWAYS_FATAL_IF(tmpQueue.front().header.type != InputMessage::Type::MOTION);
- MotionEvent motion;
- initializeMotionEvent(motion, tmpQueue.front());
- out += std::string(" ") + streamableToString(motion) + "\n";
+ std::unique_ptr<MotionEvent> motion = createMotionEvent(tmpQueue.front());
+ out += std::string(" ") + streamableToString(*motion) + "\n";
tmpQueue.pop();
}
}
diff --git a/libs/input/tests/InputPublisherAndConsumerNoResampling_test.cpp b/libs/input/tests/InputPublisherAndConsumerNoResampling_test.cpp
index e24ae49..6593497 100644
--- a/libs/input/tests/InputPublisherAndConsumerNoResampling_test.cpp
+++ b/libs/input/tests/InputPublisherAndConsumerNoResampling_test.cpp
@@ -341,19 +341,19 @@
// The sequence number to use when publishing the next event
uint32_t mSeq = 1;
- BlockingQueue<KeyEvent> mKeyEvents;
- BlockingQueue<MotionEvent> mMotionEvents;
- BlockingQueue<FocusEvent> mFocusEvents;
- BlockingQueue<CaptureEvent> mCaptureEvents;
- BlockingQueue<DragEvent> mDragEvents;
- BlockingQueue<TouchModeEvent> mTouchModeEvents;
+ BlockingQueue<std::unique_ptr<KeyEvent>> mKeyEvents;
+ BlockingQueue<std::unique_ptr<MotionEvent>> mMotionEvents;
+ BlockingQueue<std::unique_ptr<FocusEvent>> mFocusEvents;
+ BlockingQueue<std::unique_ptr<CaptureEvent>> mCaptureEvents;
+ BlockingQueue<std::unique_ptr<DragEvent>> mDragEvents;
+ BlockingQueue<std::unique_ptr<TouchModeEvent>> mTouchModeEvents;
// InputConsumerCallbacks interface
- void onKeyEvent(KeyEvent&& event, uint32_t seq) override {
+ void onKeyEvent(std::unique_ptr<KeyEvent> event, uint32_t seq) override {
mKeyEvents.push(std::move(event));
mConsumer->finishInputEvent(seq, true);
}
- void onMotionEvent(MotionEvent&& event, uint32_t seq) override {
+ void onMotionEvent(std::unique_ptr<MotionEvent> event, uint32_t seq) override {
mMotionEvents.push(std::move(event));
mConsumer->finishInputEvent(seq, true);
}
@@ -363,19 +363,19 @@
}
mConsumer->consumeBatchedInputEvents(std::nullopt);
};
- void onFocusEvent(FocusEvent&& event, uint32_t seq) override {
+ void onFocusEvent(std::unique_ptr<FocusEvent> event, uint32_t seq) override {
mFocusEvents.push(std::move(event));
mConsumer->finishInputEvent(seq, true);
};
- void onCaptureEvent(CaptureEvent&& event, uint32_t seq) override {
+ void onCaptureEvent(std::unique_ptr<CaptureEvent> event, uint32_t seq) override {
mCaptureEvents.push(std::move(event));
mConsumer->finishInputEvent(seq, true);
};
- void onDragEvent(DragEvent&& event, uint32_t seq) override {
+ void onDragEvent(std::unique_ptr<DragEvent> event, uint32_t seq) override {
mDragEvents.push(std::move(event));
mConsumer->finishInputEvent(seq, true);
}
- void onTouchModeEvent(TouchModeEvent&& event, uint32_t seq) override {
+ void onTouchModeEvent(std::unique_ptr<TouchModeEvent> event, uint32_t seq) override {
mTouchModeEvents.push(std::move(event));
mConsumer->finishInputEvent(seq, true);
};
@@ -465,15 +465,15 @@
eventTime);
ASSERT_EQ(OK, status) << "publisher publishKeyEvent should return OK";
- std::optional<KeyEvent> keyEvent = mKeyEvents.popWithTimeout(TIMEOUT);
+ std::optional<std::unique_ptr<KeyEvent>> optKeyEvent = mKeyEvents.popWithTimeout(TIMEOUT);
+ ASSERT_TRUE(optKeyEvent.has_value()) << "consumer should have returned non-NULL event";
+ std::unique_ptr<KeyEvent> keyEvent = std::move(*optKeyEvent);
sendMessage(LooperMessage::CALL_PROBABLY_HAS_INPUT);
std::optional<bool> probablyHasInput = mProbablyHasInputResponses.popWithTimeout(TIMEOUT);
ASSERT_TRUE(probablyHasInput.has_value());
ASSERT_FALSE(probablyHasInput.value()) << "no events should be waiting after being consumed";
- ASSERT_TRUE(keyEvent.has_value()) << "consumer should have returned non-NULL event";
-
EXPECT_EQ(eventId, keyEvent->getId());
EXPECT_EQ(deviceId, keyEvent->getDeviceId());
EXPECT_EQ(source, keyEvent->getSource());
@@ -540,7 +540,8 @@
publishMotionEvent(*mPublisher, args);
// Ensure no event arrives because the UI thread is blocked
- std::optional<MotionEvent> noEvent = mMotionEvents.popWithTimeout(NO_EVENT_TIMEOUT);
+ std::optional<std::unique_ptr<MotionEvent>> noEvent =
+ mMotionEvents.popWithTimeout(NO_EVENT_TIMEOUT);
ASSERT_FALSE(noEvent.has_value()) << "Got unexpected event: " << *noEvent;
Result<InputPublisher::ConsumerResponse> result = mPublisher->receiveConsumerResponse();
@@ -559,8 +560,9 @@
}
mNotifyLooperMayProceed.notify_all();
- std::optional<MotionEvent> motion = mMotionEvents.popWithTimeout(TIMEOUT);
- ASSERT_TRUE(motion.has_value());
+ std::optional<std::unique_ptr<MotionEvent>> optMotion = mMotionEvents.popWithTimeout(TIMEOUT);
+ ASSERT_TRUE(optMotion.has_value());
+ std::unique_ptr<MotionEvent> motion = std::move(*optMotion);
ASSERT_EQ(ACTION_MOVE, motion->getAction());
verifyFinishedSignal(*mPublisher, seq, publishTime);
@@ -573,8 +575,9 @@
nsecs_t publishTime = systemTime(SYSTEM_TIME_MONOTONIC);
publishMotionEvent(*mPublisher, args);
- std::optional<MotionEvent> event = mMotionEvents.popWithTimeout(TIMEOUT);
- ASSERT_TRUE(event.has_value()) << "consumer should have returned non-NULL event";
+ std::optional<std::unique_ptr<MotionEvent>> optMotion = mMotionEvents.popWithTimeout(TIMEOUT);
+ ASSERT_TRUE(optMotion.has_value());
+ std::unique_ptr<MotionEvent> event = std::move(*optMotion);
verifyArgsEqualToEvent(args, *event);
@@ -592,8 +595,9 @@
status = mPublisher->publishFocusEvent(seq, eventId, hasFocus);
ASSERT_EQ(OK, status) << "publisher publishFocusEvent should return OK";
- std::optional<FocusEvent> focusEvent = mFocusEvents.popWithTimeout(TIMEOUT);
- ASSERT_TRUE(focusEvent.has_value()) << "consumer should have returned non-NULL event";
+ std::optional<std::unique_ptr<FocusEvent>> optFocusEvent = mFocusEvents.popWithTimeout(TIMEOUT);
+ ASSERT_TRUE(optFocusEvent.has_value()) << "consumer should have returned non-NULL event";
+ std::unique_ptr<FocusEvent> focusEvent = std::move(*optFocusEvent);
EXPECT_EQ(eventId, focusEvent->getId());
EXPECT_EQ(hasFocus, focusEvent->getHasFocus());
@@ -611,9 +615,9 @@
status = mPublisher->publishCaptureEvent(seq, eventId, captureEnabled);
ASSERT_EQ(OK, status) << "publisher publishCaptureEvent should return OK";
- std::optional<CaptureEvent> event = mCaptureEvents.popWithTimeout(TIMEOUT);
-
- ASSERT_TRUE(event.has_value()) << "consumer should have returned non-NULL event";
+ std::optional<std::unique_ptr<CaptureEvent>> optEvent = mCaptureEvents.popWithTimeout(TIMEOUT);
+ ASSERT_TRUE(optEvent.has_value()) << "consumer should have returned non-NULL event";
+ std::unique_ptr<CaptureEvent> event = std::move(*optEvent);
const CaptureEvent& captureEvent = *event;
EXPECT_EQ(eventId, captureEvent.getId());
@@ -635,9 +639,9 @@
status = mPublisher->publishDragEvent(seq, eventId, x, y, isExiting);
ASSERT_EQ(OK, status) << "publisher publishDragEvent should return OK";
- std::optional<DragEvent> event = mDragEvents.popWithTimeout(TIMEOUT);
-
- ASSERT_TRUE(event.has_value()) << "consumer should have returned non-NULL event";
+ std::optional<std::unique_ptr<DragEvent>> optEvent = mDragEvents.popWithTimeout(TIMEOUT);
+ ASSERT_TRUE(optEvent.has_value()) << "consumer should have returned non-NULL event";
+ std::unique_ptr<DragEvent> event = std::move(*optEvent);
const DragEvent& dragEvent = *event;
EXPECT_EQ(eventId, dragEvent.getId());
@@ -659,8 +663,10 @@
status = mPublisher->publishTouchModeEvent(seq, eventId, touchModeEnabled);
ASSERT_EQ(OK, status) << "publisher publishTouchModeEvent should return OK";
- std::optional<TouchModeEvent> event = mTouchModeEvents.popWithTimeout(TIMEOUT);
- ASSERT_NE(std::nullopt, event);
+ std::optional<std::unique_ptr<TouchModeEvent>> optEvent =
+ mTouchModeEvents.popWithTimeout(TIMEOUT);
+ ASSERT_TRUE(optEvent.has_value());
+ std::unique_ptr<TouchModeEvent> event = std::move(*optEvent);
const TouchModeEvent& touchModeEvent = *event;
EXPECT_EQ(eventId, touchModeEvent.getId());