diff options
43 files changed, 1087 insertions, 775 deletions
diff --git a/services/inputflinger/InputListener.cpp b/services/inputflinger/InputListener.cpp index 0972e224e9..d33b29888f 100644 --- a/services/inputflinger/InputListener.cpp +++ b/services/inputflinger/InputListener.cpp @@ -31,6 +31,11 @@ using android::base::StringPrintf; namespace android { +std::list<NotifyArgs>& operator+=(std::list<NotifyArgs>& keep, std::list<NotifyArgs>&& consume) { + keep.splice(keep.end(), consume); + return keep; +} + // --- InputListenerInterface --- // Helper to std::visit with lambdas. diff --git a/services/inputflinger/NotifyArgs.cpp b/services/inputflinger/NotifyArgs.cpp index 1f37774218..b192ad73c3 100644 --- a/services/inputflinger/NotifyArgs.cpp +++ b/services/inputflinger/NotifyArgs.cpp @@ -225,4 +225,27 @@ NotifyPointerCaptureChangedArgs::NotifyPointerCaptureChangedArgs( int32_t id, nsecs_t eventTime, const PointerCaptureRequest& request) : id(id), eventTime(eventTime), request(request) {} +// Helper to std::visit with lambdas. +template <typename... V> +struct Visitor : V... {}; +// explicit deduction guide (not needed as of C++20) +template <typename... V> +Visitor(V...) -> Visitor<V...>; + +const char* toString(const NotifyArgs& args) { + Visitor toStringVisitor{ + [&](const NotifyConfigurationChangedArgs&) { return "NotifyConfigurationChangedArgs"; }, + [&](const NotifyKeyArgs&) { return "NotifyKeyArgs"; }, + [&](const NotifyMotionArgs&) { return "NotifyMotionArgs"; }, + [&](const NotifySensorArgs&) { return "NotifySensorArgs"; }, + [&](const NotifySwitchArgs&) { return "NotifySwitchArgs"; }, + [&](const NotifyDeviceResetArgs&) { return "NotifyDeviceResetArgs"; }, + [&](const NotifyPointerCaptureChangedArgs&) { + return "NotifyPointerCaptureChangedArgs"; + }, + [&](const NotifyVibratorStateArgs&) { return "NotifyVibratorStateArgs"; }, + }; + return std::visit(toStringVisitor, args); +} + } // namespace android diff --git a/services/inputflinger/include/InputListener.h b/services/inputflinger/include/InputListener.h index 8647bcb737..1bb19686e7 100644 --- a/services/inputflinger/include/InputListener.h +++ b/services/inputflinger/include/InputListener.h @@ -25,6 +25,8 @@ namespace android { +std::list<NotifyArgs>& operator+=(std::list<NotifyArgs>& keep, std::list<NotifyArgs>&& consume); + /* * The interface used by the InputReader to notify the InputListener about input events. */ diff --git a/services/inputflinger/include/NotifyArgs.h b/services/inputflinger/include/NotifyArgs.h index 611b1aac81..f28dbf3039 100644 --- a/services/inputflinger/include/NotifyArgs.h +++ b/services/inputflinger/include/NotifyArgs.h @@ -213,4 +213,6 @@ using NotifyArgs = std::variant<NotifyConfigurationChangedArgs, NotifyKeyArgs, N NotifySensorArgs, NotifySwitchArgs, NotifyDeviceResetArgs, NotifyPointerCaptureChangedArgs, NotifyVibratorStateArgs>; +const char* toString(const NotifyArgs& args); + } // namespace android diff --git a/services/inputflinger/reader/InputDevice.cpp b/services/inputflinger/reader/InputDevice.cpp index 6b9b9f1255..5291776638 100644 --- a/services/inputflinger/reader/InputDevice.cpp +++ b/services/inputflinger/reader/InputDevice.cpp @@ -65,7 +65,8 @@ bool InputDevice::isEnabled() { return enabled; } -void InputDevice::setEnabled(bool enabled, nsecs_t when) { +std::list<NotifyArgs> InputDevice::setEnabled(bool enabled, nsecs_t when) { + std::list<NotifyArgs> out; if (enabled && mAssociatedDisplayPort && !mAssociatedViewport) { ALOGW("Cannot enable input device %s because it is associated with port %" PRIu8 ", " "but the corresponding viewport is not found", @@ -74,7 +75,7 @@ void InputDevice::setEnabled(bool enabled, nsecs_t when) { } if (isEnabled() == enabled) { - return; + return out; } // When resetting some devices, the driver needs to be queried to ensure that a proper reset is @@ -82,13 +83,14 @@ void InputDevice::setEnabled(bool enabled, nsecs_t when) { // but before disabling the device. See MultiTouchMotionAccumulator::reset for more information. if (enabled) { for_each_subdevice([](auto& context) { context.enableDevice(); }); - reset(when); + out += reset(when); } else { - reset(when); + out += reset(when); for_each_subdevice([](auto& context) { context.disableDevice(); }); } // Must change generation to flag this device as changed bumpGeneration(); + return out; } void InputDevice::dump(std::string& dump, const std::string& eventHubDevStr) { @@ -241,8 +243,9 @@ void InputDevice::removeEventHubDevice(int32_t eventHubId) { mDevices.erase(eventHubId); } -void InputDevice::configure(nsecs_t when, const InputReaderConfiguration* config, - uint32_t changes) { +std::list<NotifyArgs> InputDevice::configure(nsecs_t when, const InputReaderConfiguration* config, + uint32_t changes) { + std::list<NotifyArgs> out; mSources = 0; mClasses = ftl::Flags<InputDeviceClass>(0); mControllerNumber = 0; @@ -313,7 +316,7 @@ void InputDevice::configure(nsecs_t when, const InputReaderConfiguration* config if (!changes || (changes & InputReaderConfiguration::CHANGE_ENABLED_STATE)) { auto it = config->disabledDevices.find(mId); bool enabled = it == config->disabledDevices.end(); - setEnabled(enabled, when); + out += setEnabled(enabled, when); } if (!changes || (changes & InputReaderConfiguration::CHANGE_DISPLAY_INFO)) { @@ -366,37 +369,42 @@ void InputDevice::configure(nsecs_t when, const InputReaderConfiguration* config // For first-time configuration, only allow device to be disabled after mappers have // finished configuring. This is because we need to read some of the properties from // the device's open fd. - setEnabled(enabled, when); + out += setEnabled(enabled, when); } } - for_each_mapper([this, when, config, changes](InputMapper& mapper) { - mapper.configure(when, config, changes); + for_each_mapper([this, when, &config, changes, &out](InputMapper& mapper) { + out += mapper.configure(when, config, changes); mSources |= mapper.getSources(); }); // If a device is just plugged but it might be disabled, we need to update some info like // axis range of touch from each InputMapper first, then disable it. if (!changes) { - setEnabled(config->disabledDevices.find(mId) == config->disabledDevices.end(), when); + out += setEnabled(config->disabledDevices.find(mId) == config->disabledDevices.end(), + when); } } + return out; } -void InputDevice::reset(nsecs_t when) { - for_each_mapper([when](InputMapper& mapper) { mapper.reset(when); }); +std::list<NotifyArgs> InputDevice::reset(nsecs_t when) { + std::list<NotifyArgs> out; + for_each_mapper([&](InputMapper& mapper) { out += mapper.reset(when); }); mContext->updateGlobalMetaState(); - notifyReset(when); + out.push_back(notifyReset(when)); + return out; } -void InputDevice::process(const RawEvent* rawEvents, size_t count) { +std::list<NotifyArgs> InputDevice::process(const RawEvent* rawEvents, size_t count) { // Process all of the events in order for each mapper. // We cannot simply ask each mapper to process them in bulk because mappers may // have side-effects that must be interleaved. For example, joystick movement events and // gamepad button presses are handled by different mappers but they should be dispatched // in the order received. + std::list<NotifyArgs> out; for (const RawEvent* rawEvent = rawEvents; count != 0; rawEvent++) { if (DEBUG_RAW_EVENTS) { ALOGD("Input event: device=%d type=0x%04x code=0x%04x value=0x%08x when=%" PRId64, @@ -418,22 +426,27 @@ void InputDevice::process(const RawEvent* rawEvents, size_t count) { } else if (rawEvent->type == EV_SYN && rawEvent->code == SYN_DROPPED) { ALOGI("Detected input event buffer overrun for device %s.", getName().c_str()); mDropUntilNextSync = true; - reset(rawEvent->when); + out += reset(rawEvent->when); } else { - for_each_mapper_in_subdevice(rawEvent->deviceId, [rawEvent](InputMapper& mapper) { - mapper.process(rawEvent); + for_each_mapper_in_subdevice(rawEvent->deviceId, [&](InputMapper& mapper) { + out += mapper.process(rawEvent); }); } --count; } + return out; } -void InputDevice::timeoutExpired(nsecs_t when) { - for_each_mapper([when](InputMapper& mapper) { mapper.timeoutExpired(when); }); +std::list<NotifyArgs> InputDevice::timeoutExpired(nsecs_t when) { + std::list<NotifyArgs> out; + for_each_mapper([&](InputMapper& mapper) { out += mapper.timeoutExpired(when); }); + return out; } -void InputDevice::updateExternalStylusState(const StylusState& state) { - for_each_mapper([state](InputMapper& mapper) { mapper.updateExternalStylusState(state); }); +std::list<NotifyArgs> InputDevice::updateExternalStylusState(const StylusState& state) { + std::list<NotifyArgs> out; + for_each_mapper([&](InputMapper& mapper) { out += mapper.updateExternalStylusState(state); }); + return out; } InputDeviceInfo InputDevice::getDeviceInfo() { @@ -511,14 +524,17 @@ int32_t InputDevice::getKeyCodeForKeyLocation(int32_t locationKeyCode) const { return *result; } -void InputDevice::vibrate(const VibrationSequence& sequence, ssize_t repeat, int32_t token) { - for_each_mapper([sequence, repeat, token](InputMapper& mapper) { - mapper.vibrate(sequence, repeat, token); - }); +std::list<NotifyArgs> InputDevice::vibrate(const VibrationSequence& sequence, ssize_t repeat, + int32_t token) { + std::list<NotifyArgs> out; + for_each_mapper([&](InputMapper& mapper) { out += mapper.vibrate(sequence, repeat, token); }); + return out; } -void InputDevice::cancelVibrate(int32_t token) { - for_each_mapper([token](InputMapper& mapper) { mapper.cancelVibrate(token); }); +std::list<NotifyArgs> InputDevice::cancelVibrate(int32_t token) { + std::list<NotifyArgs> out; + for_each_mapper([&](InputMapper& mapper) { out += mapper.cancelVibrate(token); }); + return out; } bool InputDevice::isVibrating() { @@ -561,8 +577,10 @@ void InputDevice::flushSensor(InputDeviceSensorType sensorType) { for_each_mapper([sensorType](InputMapper& mapper) { mapper.flushSensor(sensorType); }); } -void InputDevice::cancelTouch(nsecs_t when, nsecs_t readTime) { - for_each_mapper([when, readTime](InputMapper& mapper) { mapper.cancelTouch(when, readTime); }); +std::list<NotifyArgs> InputDevice::cancelTouch(nsecs_t when, nsecs_t readTime) { + std::list<NotifyArgs> out; + for_each_mapper([&](InputMapper& mapper) { out += mapper.cancelTouch(when, readTime); }); + return out; } bool InputDevice::setLightColor(int32_t lightId, int32_t color) { @@ -601,9 +619,8 @@ void InputDevice::bumpGeneration() { mGeneration = mContext->bumpGeneration(); } -void InputDevice::notifyReset(nsecs_t when) { - NotifyDeviceResetArgs args(mContext->getNextId(), when, mId); - mContext->getListener().notifyDeviceReset(&args); +NotifyDeviceResetArgs InputDevice::notifyReset(nsecs_t when) { + return NotifyDeviceResetArgs(mContext->getNextId(), when, mId); } std::optional<int32_t> InputDevice::getAssociatedDisplayId() { diff --git a/services/inputflinger/reader/InputReader.cpp b/services/inputflinger/reader/InputReader.cpp index 86508766f5..428e999c1b 100644 --- a/services/inputflinger/reader/InputReader.cpp +++ b/services/inputflinger/reader/InputReader.cpp @@ -127,7 +127,7 @@ void InputReader::loopOnce() { mReaderIsAliveCondition.notify_all(); if (!events.empty()) { - processEventsLocked(events.data(), events.size()); + notifyAll(processEventsLocked(events.data(), events.size())); } if (mNextTimeout != LLONG_MAX) { @@ -137,7 +137,7 @@ void InputReader::loopOnce() { ALOGD("Timeout expired, latency=%0.3fms", (now - mNextTimeout) * 0.000001f); } mNextTimeout = LLONG_MAX; - timeoutExpiredLocked(now); + notifyAll(timeoutExpiredLocked(now)); } } @@ -162,7 +162,8 @@ void InputReader::loopOnce() { mQueuedListener.flush(); } -void InputReader::processEventsLocked(const RawEvent* rawEvents, size_t count) { +std::list<NotifyArgs> InputReader::processEventsLocked(const RawEvent* rawEvents, size_t count) { + std::list<NotifyArgs> out; for (const RawEvent* rawEvent = rawEvents; count;) { int32_t type = rawEvent->type; size_t batchSize = 1; @@ -178,7 +179,7 @@ void InputReader::processEventsLocked(const RawEvent* rawEvents, size_t count) { if (DEBUG_RAW_EVENTS) { ALOGD("BatchSize: %zu Count: %zu", batchSize, count); } - processEventsForDeviceLocked(deviceId, rawEvent, batchSize); + out += processEventsForDeviceLocked(deviceId, rawEvent, batchSize); } else { switch (rawEvent->type) { case EventHubInterface::DEVICE_ADDED: @@ -198,6 +199,7 @@ void InputReader::processEventsLocked(const RawEvent* rawEvents, size_t count) { count -= batchSize; rawEvent += batchSize; } + return out; } void InputReader::addDeviceLocked(nsecs_t when, int32_t eventHubId) { @@ -208,8 +210,9 @@ void InputReader::addDeviceLocked(nsecs_t when, int32_t eventHubId) { InputDeviceIdentifier identifier = mEventHub->getDeviceIdentifier(eventHubId); std::shared_ptr<InputDevice> device = createDeviceLocked(eventHubId, identifier); - device->configure(when, &mConfig, 0); - device->reset(when); + + notifyAll(device->configure(when, &mConfig, 0)); + notifyAll(device->reset(when)); if (device->isIgnored()) { ALOGI("Device added: id=%d, eventHubId=%d, name='%s', descriptor='%s' " @@ -282,10 +285,12 @@ void InputReader::removeDeviceLocked(nsecs_t when, int32_t eventHubId) { notifyExternalStylusPresenceChangedLocked(); } + std::list<NotifyArgs> resetEvents; if (device->hasEventHubDevices()) { - device->configure(when, &mConfig, 0); + resetEvents += device->configure(when, &mConfig, 0); } - device->reset(when); + resetEvents += device->reset(when); + notifyAll(std::move(resetEvents)); } std::shared_ptr<InputDevice> InputReader::createDeviceLocked( @@ -308,21 +313,22 @@ std::shared_ptr<InputDevice> InputReader::createDeviceLocked( return device; } -void InputReader::processEventsForDeviceLocked(int32_t eventHubId, const RawEvent* rawEvents, - size_t count) { +std::list<NotifyArgs> InputReader::processEventsForDeviceLocked(int32_t eventHubId, + const RawEvent* rawEvents, + size_t count) { auto deviceIt = mDevices.find(eventHubId); if (deviceIt == mDevices.end()) { ALOGW("Discarding event for unknown eventHubId %d.", eventHubId); - return; + return {}; } std::shared_ptr<InputDevice>& device = deviceIt->second; if (device->isIgnored()) { // ALOGD("Discarding event for ignored deviceId %d.", deviceId); - return; + return {}; } - device->process(rawEvents, count); + return device->process(rawEvents, count); } InputDevice* InputReader::findInputDeviceLocked(int32_t deviceId) const { @@ -336,13 +342,15 @@ InputDevice* InputReader::findInputDeviceLocked(int32_t deviceId) const { return nullptr; } -void InputReader::timeoutExpiredLocked(nsecs_t when) { +std::list<NotifyArgs> InputReader::timeoutExpiredLocked(nsecs_t when) { + std::list<NotifyArgs> out; for (auto& devicePair : mDevices) { std::shared_ptr<InputDevice>& device = devicePair.second; if (!device->isIgnored()) { - device->timeoutExpired(when); + out += device->timeoutExpired(when); } } + return out; } int32_t InputReader::nextInputDeviceIdLocked() { @@ -377,7 +385,7 @@ void InputReader::refreshConfigurationLocked(uint32_t changes) { } else { for (auto& devicePair : mDevices) { std::shared_ptr<InputDevice>& device = devicePair.second; - device->configure(now, &mConfig, changes); + notifyAll(device->configure(now, &mConfig, changes)); } } @@ -394,6 +402,12 @@ void InputReader::refreshConfigurationLocked(uint32_t changes) { } } +void InputReader::notifyAll(std::list<NotifyArgs>&& argsList) { + for (const NotifyArgs& args : argsList) { + mQueuedListener.notify(args); + } +} + void InputReader::updateGlobalMetaStateLocked() { mGlobalMetaState = 0; @@ -432,11 +446,13 @@ void InputReader::getExternalStylusDevicesLocked(std::vector<InputDeviceInfo>& o } } -void InputReader::dispatchExternalStylusStateLocked(const StylusState& state) { +std::list<NotifyArgs> InputReader::dispatchExternalStylusStateLocked(const StylusState& state) { + std::list<NotifyArgs> out; for (auto& devicePair : mDevices) { std::shared_ptr<InputDevice>& device = devicePair.second; - device->updateExternalStylusState(state); + out += device->updateExternalStylusState(state); } + return out; } void InputReader::disableVirtualKeysUntilLocked(nsecs_t time) { @@ -642,7 +658,7 @@ void InputReader::vibrate(int32_t deviceId, const VibrationSequence& sequence, s InputDevice* device = findInputDeviceLocked(deviceId); if (device) { - device->vibrate(sequence, repeat, token); + notifyAll(device->vibrate(sequence, repeat, token)); } } @@ -651,7 +667,7 @@ void InputReader::cancelVibrate(int32_t deviceId, int32_t token) { InputDevice* device = findInputDeviceLocked(deviceId); if (device) { - device->cancelVibrate(token); + notifyAll(device->cancelVibrate(token)); } } @@ -1015,18 +1031,15 @@ void InputReader::ContextImpl::getExternalStylusDevices(std::vector<InputDeviceI mReader->getExternalStylusDevicesLocked(outDevices); } -void InputReader::ContextImpl::dispatchExternalStylusState(const StylusState& state) { - mReader->dispatchExternalStylusStateLocked(state); +std::list<NotifyArgs> InputReader::ContextImpl::dispatchExternalStylusState( + const StylusState& state) { + return mReader->dispatchExternalStylusStateLocked(state); } InputReaderPolicyInterface* InputReader::ContextImpl::getPolicy() { return mReader->mPolicy.get(); } -InputListenerInterface& InputReader::ContextImpl::getListener() { - return mReader->mQueuedListener; -} - EventHubInterface* InputReader::ContextImpl::getEventHub() { return mReader->mEventHub.get(); } diff --git a/services/inputflinger/reader/include/InputDevice.h b/services/inputflinger/reader/include/InputDevice.h index 4ae9ae9dd0..afb1bed1f2 100644 --- a/services/inputflinger/reader/include/InputDevice.h +++ b/services/inputflinger/reader/include/InputDevice.h @@ -29,6 +29,7 @@ #include "EventHub.h" #include "InputReaderBase.h" #include "InputReaderContext.h" +#include "NotifyArgs.h" namespace android { @@ -69,16 +70,18 @@ public: inline bool isIgnored() { return !getMapperCount(); } bool isEnabled(); - void setEnabled(bool enabled, nsecs_t when); + [[nodiscard]] std::list<NotifyArgs> setEnabled(bool enabled, nsecs_t when); void dump(std::string& dump, const std::string& eventHubDevStr); void addEventHubDevice(int32_t eventHubId, bool populateMappers = true); void removeEventHubDevice(int32_t eventHubId); - void configure(nsecs_t when, const InputReaderConfiguration* config, uint32_t changes); - void reset(nsecs_t when); - void process(const RawEvent* rawEvents, size_t count); - void timeoutExpired(nsecs_t when); - void updateExternalStylusState(const StylusState& state); + [[nodiscard]] std::list<NotifyArgs> configure(nsecs_t when, + const InputReaderConfiguration* config, + uint32_t changes); + [[nodiscard]] std::list<NotifyArgs> reset(nsecs_t when); + [[nodiscard]] std::list<NotifyArgs> process(const RawEvent* rawEvents, size_t count); + [[nodiscard]] std::list<NotifyArgs> timeoutExpired(nsecs_t when); + [[nodiscard]] std::list<NotifyArgs> updateExternalStylusState(const StylusState& state); InputDeviceInfo getDeviceInfo(); int32_t getKeyCodeState(uint32_t sourceMask, int32_t keyCode); @@ -87,11 +90,12 @@ public: int32_t getKeyCodeForKeyLocation(int32_t locationKeyCode) const; bool markSupportedKeyCodes(uint32_t sourceMask, const std::vector<int32_t>& keyCodes, uint8_t* outFlags); - void vibrate(const VibrationSequence& sequence, ssize_t repeat, int32_t token); - void cancelVibrate(int32_t token); + [[nodiscard]] std::list<NotifyArgs> vibrate(const VibrationSequence& sequence, ssize_t repeat, + int32_t token); + [[nodiscard]] std::list<NotifyArgs> cancelVibrate(int32_t token); bool isVibrating(); std::vector<int32_t> getVibratorIds(); - void cancelTouch(nsecs_t when, nsecs_t readTime); + [[nodiscard]] std::list<NotifyArgs> cancelTouch(nsecs_t when, nsecs_t readTime); bool enableSensor(InputDeviceSensorType sensorType, std::chrono::microseconds samplingPeriod, std::chrono::microseconds maxBatchReportLatency); void disableSensor(InputDeviceSensorType sensorType); @@ -109,7 +113,7 @@ public: void bumpGeneration(); - void notifyReset(nsecs_t when); + [[nodiscard]] NotifyDeviceResetArgs notifyReset(nsecs_t when); inline const PropertyMap& getConfiguration() { return mConfiguration; } inline EventHubInterface* getEventHub() { return mContext->getEventHub(); } @@ -395,7 +399,9 @@ public: inline std::optional<DisplayViewport> getAssociatedViewport() const { return mDevice.getAssociatedViewport(); } - inline void cancelTouch(nsecs_t when, nsecs_t readTime) { mDevice.cancelTouch(when, readTime); } + [[nodiscard]] inline std::list<NotifyArgs> cancelTouch(nsecs_t when, nsecs_t readTime) { + return mDevice.cancelTouch(when, readTime); + } inline void bumpGeneration() { mDevice.bumpGeneration(); } inline const PropertyMap& getConfiguration() { return mDevice.getConfiguration(); } diff --git a/services/inputflinger/reader/include/InputReader.h b/services/inputflinger/reader/include/InputReader.h index 012d43fc3a..de268cf66c 100644 --- a/services/inputflinger/reader/include/InputReader.h +++ b/services/inputflinger/reader/include/InputReader.h @@ -142,10 +142,9 @@ protected: int32_t bumpGeneration() NO_THREAD_SAFETY_ANALYSIS override; void getExternalStylusDevices(std::vector<InputDeviceInfo>& outDevices) REQUIRES(mReader->mLock) override; - void dispatchExternalStylusState(const StylusState& outState) + [[nodiscard]] std::list<NotifyArgs> dispatchExternalStylusState(const StylusState& outState) REQUIRES(mReader->mLock) override; InputReaderPolicyInterface* getPolicy() REQUIRES(mReader->mLock) override; - InputListenerInterface& getListener() REQUIRES(mReader->mLock) override; EventHubInterface* getEventHub() REQUIRES(mReader->mLock) override; int32_t getNextId() NO_THREAD_SAFETY_ANALYSIS override; void updateLedMetaState(int32_t metaState) REQUIRES(mReader->mLock) override; @@ -181,13 +180,15 @@ private: mDeviceToEventHubIdsMap GUARDED_BY(mLock); // low-level input event decoding and device management - void processEventsLocked(const RawEvent* rawEvents, size_t count) REQUIRES(mLock); + [[nodiscard]] std::list<NotifyArgs> processEventsLocked(const RawEvent* rawEvents, size_t count) + REQUIRES(mLock); void addDeviceLocked(nsecs_t when, int32_t eventHubId) REQUIRES(mLock); void removeDeviceLocked(nsecs_t when, int32_t eventHubId) REQUIRES(mLock); - void processEventsForDeviceLocked(int32_t eventHubId, const RawEvent* rawEvents, size_t count) - REQUIRES(mLock); - void timeoutExpiredLocked(nsecs_t when) REQUIRES(mLock); + [[nodiscard]] std::list<NotifyArgs> processEventsForDeviceLocked(int32_t eventHubId, + const RawEvent* rawEvents, + size_t count) REQUIRES(mLock); + [[nodiscard]] std::list<NotifyArgs> timeoutExpiredLocked(nsecs_t when) REQUIRES(mLock); void handleConfigurationChangedLocked(nsecs_t when) REQUIRES(mLock); @@ -201,7 +202,8 @@ private: void notifyExternalStylusPresenceChangedLocked() REQUIRES(mLock); void getExternalStylusDevicesLocked(std::vector<InputDeviceInfo>& outDevices) REQUIRES(mLock); - void dispatchExternalStylusStateLocked(const StylusState& state) REQUIRES(mLock); + [[nodiscard]] std::list<NotifyArgs> dispatchExternalStylusStateLocked(const StylusState& state) + REQUIRES(mLock); // The PointerController that is shared among all the input devices that need it. std::weak_ptr<PointerControllerInterface> mPointerController; @@ -228,6 +230,8 @@ private: uint32_t mConfigurationChangesToRefresh GUARDED_BY(mLock); void refreshConfigurationLocked(uint32_t changes) REQUIRES(mLock); + void notifyAll(std::list<NotifyArgs>&& argsList); + PointerCaptureRequest mCurrentPointerCaptureRequest GUARDED_BY(mLock); // state queries diff --git a/services/inputflinger/reader/include/InputReaderContext.h b/services/inputflinger/reader/include/InputReaderContext.h index f2f156c6e2..0beace19ab 100644 --- a/services/inputflinger/reader/include/InputReaderContext.h +++ b/services/inputflinger/reader/include/InputReaderContext.h @@ -17,6 +17,7 @@ #pragma once #include <input/InputDevice.h> +#include "NotifyArgs.h" #include <vector> @@ -51,10 +52,10 @@ public: virtual int32_t bumpGeneration() = 0; virtual void getExternalStylusDevices(std::vector<InputDeviceInfo>& outDevices) = 0; - virtual void dispatchExternalStylusState(const StylusState& outState) = 0; + [[nodiscard]] virtual std::list<NotifyArgs> dispatchExternalStylusState( + const StylusState& outState) = 0; virtual InputReaderPolicyInterface* getPolicy() = 0; - virtual InputListenerInterface& getListener() = 0; virtual EventHubInterface* getEventHub() = 0; virtual int32_t getNextId() = 0; diff --git a/services/inputflinger/reader/mapper/CursorInputMapper.cpp b/services/inputflinger/reader/mapper/CursorInputMapper.cpp index d6d324b5b2..c691ca943f 100644 --- a/services/inputflinger/reader/mapper/CursorInputMapper.cpp +++ b/services/inputflinger/reader/mapper/CursorInputMapper.cpp @@ -126,9 +126,10 @@ void CursorInputMapper::dump(std::string& dump) { dump += StringPrintf(INDENT3 "DownTime: %" PRId64 "\n", mDownTime); } -void CursorInputMapper::configure(nsecs_t when, const InputReaderConfiguration* config, - uint32_t changes) { - InputMapper::configure(when, config, changes); +std::list<NotifyArgs> CursorInputMapper::configure(nsecs_t when, + const InputReaderConfiguration* config, + uint32_t changes) { + std::list<NotifyArgs> out = InputMapper::configure(when, config, changes); if (!changes) { // first time only mCursorScrollAccumulator.configure(getDeviceContext()); @@ -187,8 +188,7 @@ void CursorInputMapper::configure(nsecs_t when, const InputReaderConfiguration* } bumpGeneration(); if (changes) { - NotifyDeviceResetArgs args(getContext()->getNextId(), when, getDeviceId()); - getListener().notifyDeviceReset(&args); + out.push_back(NotifyDeviceResetArgs(getContext()->getNextId(), when, getDeviceId())); } } @@ -241,6 +241,7 @@ void CursorInputMapper::configure(nsecs_t when, const InputReaderConfiguration* bumpGeneration(); } + return out; } void CursorInputMapper::configureParameters() { @@ -272,7 +273,7 @@ void CursorInputMapper::dumpParameters(std::string& dump) { dump += StringPrintf(INDENT4 "OrientationAware: %s\n", toString(mParameters.orientationAware)); } -void CursorInputMapper::reset(nsecs_t when) { +std::list<NotifyArgs> CursorInputMapper::reset(nsecs_t when) { mButtonState = 0; mDownTime = 0; @@ -284,23 +285,26 @@ void CursorInputMapper::reset(nsecs_t when) { mCursorMotionAccumulator.reset(getDeviceContext()); mCursorScrollAccumulator.reset(getDeviceContext()); - InputMapper::reset(when); + return InputMapper::reset(when); } -void CursorInputMapper::process(const RawEvent* rawEvent) { +std::list<NotifyArgs> CursorInputMapper::process(const RawEvent* rawEvent) { + std::list<NotifyArgs> out; mCursorButtonAccumulator.process(rawEvent); mCursorMotionAccumulator.process(rawEvent); mCursorScrollAccumulator.process(rawEvent); if (rawEvent->type == EV_SYN && rawEvent->code == SYN_REPORT) { - sync(rawEvent->when, rawEvent->readTime); + out += sync(rawEvent->when, rawEvent->readTime); } + return out; } -void CursorInputMapper::sync(nsecs_t when, nsecs_t readTime) { +std::list<NotifyArgs> CursorInputMapper::sync(nsecs_t when, nsecs_t readTime) { + std::list<NotifyArgs> out; if (!mDisplayId) { // Ignore events when there is no target display configured. - return; + return out; } int32_t lastButtonState = mButtonState; @@ -391,8 +395,9 @@ void CursorInputMapper::sync(nsecs_t when, nsecs_t readTime) { } // Synthesize key down from buttons if needed. - synthesizeButtonKeys(getContext(), AKEY_EVENT_ACTION_DOWN, when, readTime, getDeviceId(), - mSource, *mDisplayId, policyFlags, lastButtonState, currentButtonState); + out += synthesizeButtonKeys(getContext(), AKEY_EVENT_ACTION_DOWN, when, readTime, getDeviceId(), + mSource, *mDisplayId, policyFlags, lastButtonState, + currentButtonState); // Send motion event. if (downChanged || moved || scrolled || buttonsChanged) { @@ -412,40 +417,38 @@ void CursorInputMapper::sync(nsecs_t when, nsecs_t readTime) { while (!released.isEmpty()) { int32_t actionButton = BitSet32::valueForBit(released.clearFirstMarkedBit()); buttonState &= ~actionButton; - NotifyMotionArgs releaseArgs(getContext()->getNextId(), when, readTime, - getDeviceId(), mSource, *mDisplayId, policyFlags, - AMOTION_EVENT_ACTION_BUTTON_RELEASE, actionButton, 0, - metaState, buttonState, MotionClassification::NONE, - AMOTION_EVENT_EDGE_FLAG_NONE, 1, &pointerProperties, - &pointerCoords, mXPrecision, mYPrecision, - xCursorPosition, yCursorPosition, downTime, - /* videoFrames */ {}); - getListener().notifyMotion(&releaseArgs); + out.push_back(NotifyMotionArgs(getContext()->getNextId(), when, readTime, + getDeviceId(), mSource, *mDisplayId, policyFlags, + AMOTION_EVENT_ACTION_BUTTON_RELEASE, actionButton, 0, + metaState, buttonState, MotionClassification::NONE, + AMOTION_EVENT_EDGE_FLAG_NONE, 1, &pointerProperties, + &pointerCoords, mXPrecision, mYPrecision, + xCursorPosition, yCursorPosition, downTime, + /* videoFrames */ {})); } } - NotifyMotionArgs args(getContext()->getNextId(), when, readTime, getDeviceId(), mSource, - *mDisplayId, policyFlags, motionEventAction, 0, 0, metaState, - currentButtonState, MotionClassification::NONE, - AMOTION_EVENT_EDGE_FLAG_NONE, 1, &pointerProperties, &pointerCoords, - mXPrecision, mYPrecision, xCursorPosition, yCursorPosition, downTime, - /* videoFrames */ {}); - getListener().notifyMotion(&args); + out.push_back(NotifyMotionArgs(getContext()->getNextId(), when, readTime, getDeviceId(), + mSource, *mDisplayId, policyFlags, motionEventAction, 0, 0, + metaState, currentButtonState, MotionClassification::NONE, + AMOTION_EVENT_EDGE_FLAG_NONE, 1, &pointerProperties, + &pointerCoords, mXPrecision, mYPrecision, xCursorPosition, + yCursorPosition, downTime, + /* videoFrames */ {})); if (buttonsPressed) { BitSet32 pressed(buttonsPressed); while (!pressed.isEmpty()) { int32_t actionButton = BitSet32::valueForBit(pressed.clearFirstMarkedBit()); buttonState |= actionButton; - NotifyMotionArgs pressArgs(getContext()->getNextId(), when, readTime, getDeviceId(), - mSource, *mDisplayId, policyFlags, - AMOTION_EVENT_ACTION_BUTTON_PRESS, actionButton, 0, - metaState, buttonState, MotionClassification::NONE, - AMOTION_EVENT_EDGE_FLAG_NONE, 1, &pointerProperties, - &pointerCoords, mXPrecision, mYPrecision, - xCursorPosition, yCursorPosition, downTime, - /* videoFrames */ {}); - getListener().notifyMotion(&pressArgs); + out.push_back(NotifyMotionArgs(getContext()->getNextId(), when, readTime, + getDeviceId(), mSource, *mDisplayId, policyFlags, + AMOTION_EVENT_ACTION_BUTTON_PRESS, actionButton, 0, + metaState, buttonState, MotionClassification::NONE, + AMOTION_EVENT_EDGE_FLAG_NONE, 1, &pointerProperties, + &pointerCoords, mXPrecision, mYPrecision, + xCursorPosition, yCursorPosition, downTime, + /* videoFrames */ {})); } } @@ -453,14 +456,14 @@ void CursorInputMapper::sync(nsecs_t when, nsecs_t readTime) { // Send hover move after UP to tell the application that the mouse is hovering now. if (motionEventAction == AMOTION_EVENT_ACTION_UP && (mSource == AINPUT_SOURCE_MOUSE)) { - NotifyMotionArgs hoverArgs(getContext()->getNextId(), when, readTime, getDeviceId(), - mSource, *mDisplayId, policyFlags, - AMOTION_EVENT_ACTION_HOVER_MOVE, 0, 0, metaState, - currentButtonState, MotionClassification::NONE, - AMOTION_EVENT_EDGE_FLAG_NONE, 1, &pointerProperties, - &pointerCoords, mXPrecision, mYPrecision, xCursorPosition, - yCursorPosition, downTime, /* videoFrames */ {}); - getListener().notifyMotion(&hoverArgs); + out.push_back(NotifyMotionArgs(getContext()->getNextId(), when, readTime, getDeviceId(), + mSource, *mDisplayId, policyFlags, + AMOTION_EVENT_ACTION_HOVER_MOVE, 0, 0, metaState, + currentButtonState, MotionClassification::NONE, + AMOTION_EVENT_EDGE_FLAG_NONE, 1, &pointerProperties, + &pointerCoords, mXPrecision, mYPrecision, + xCursorPosition, yCursorPosition, downTime, + /* videoFrames */ {})); } // Send scroll events. @@ -468,23 +471,25 @@ void CursorInputMapper::sync(nsecs_t when, nsecs_t readTime) { pointerCoords.setAxisValue(AMOTION_EVENT_AXIS_VSCROLL, vscroll); pointerCoords.setAxisValue(AMOTION_EVENT_AXIS_HSCROLL, hscroll); - NotifyMotionArgs scrollArgs(getContext()->getNextId(), when, readTime, getDeviceId(), - mSource, *mDisplayId, policyFlags, - AMOTION_EVENT_ACTION_SCROLL, 0, 0, metaState, - currentButtonState, MotionClassification::NONE, - AMOTION_EVENT_EDGE_FLAG_NONE, 1, &pointerProperties, - &pointerCoords, mXPrecision, mYPrecision, xCursorPosition, - yCursorPosition, downTime, /* videoFrames */ {}); - getListener().notifyMotion(&scrollArgs); + out.push_back(NotifyMotionArgs(getContext()->getNextId(), when, readTime, getDeviceId(), + mSource, *mDisplayId, policyFlags, + AMOTION_EVENT_ACTION_SCROLL, 0, 0, metaState, + currentButtonState, MotionClassification::NONE, + AMOTION_EVENT_EDGE_FLAG_NONE, 1, &pointerProperties, + &pointerCoords, mXPrecision, mYPrecision, + xCursorPosition, yCursorPosition, downTime, + /* videoFrames */ {})); } } // Synthesize key up from buttons if needed. - synthesizeButtonKeys(getContext(), AKEY_EVENT_ACTION_UP, when, readTime, getDeviceId(), mSource, - *mDisplayId, policyFlags, lastButtonState, currentButtonState); + out += synthesizeButtonKeys(getContext(), AKEY_EVENT_ACTION_UP, when, readTime, getDeviceId(), + mSource, *mDisplayId, policyFlags, lastButtonState, + currentButtonState); mCursorMotionAccumulator.finishSync(); mCursorScrollAccumulator.finishSync(); + return out; } int32_t CursorInputMapper::getScanCodeState(uint32_t sourceMask, int32_t scanCode) { diff --git a/services/inputflinger/reader/mapper/CursorInputMapper.h b/services/inputflinger/reader/mapper/CursorInputMapper.h index a0229a74c7..6a4275ed54 100644 --- a/services/inputflinger/reader/mapper/CursorInputMapper.h +++ b/services/inputflinger/reader/mapper/CursorInputMapper.h @@ -58,10 +58,11 @@ public: virtual uint32_t getSources() const override; virtual void populateDeviceInfo(InputDeviceInfo* deviceInfo) override; virtual void dump(std::string& dump) override; - virtual void configure(nsecs_t when, const InputReaderConfiguration* config, - uint32_t changes) override; - virtual void reset(nsecs_t when) override; - virtual void process(const RawEvent* rawEvent) override; + [[nodiscard]] std::list<NotifyArgs> configure(nsecs_t when, + const InputReaderConfiguration* config, + uint32_t changes) override; + [[nodiscard]] std::list<NotifyArgs> reset(nsecs_t when) override; + [[nodiscard]] std::list<NotifyArgs> process(const RawEvent* rawEvent) override; virtual int32_t getScanCodeState(uint32_t sourceMask, int32_t scanCode) override; @@ -124,7 +125,7 @@ private: void configureParameters(); void dumpParameters(std::string& dump); - void sync(nsecs_t when, nsecs_t readTime); + [[nodiscard]] std::list<NotifyArgs> sync(nsecs_t when, nsecs_t readTime); }; } // namespace android diff --git a/services/inputflinger/reader/mapper/ExternalStylusInputMapper.cpp b/services/inputflinger/reader/mapper/ExternalStylusInputMapper.cpp index 6b5d37f8d5..0404c9acc1 100644 --- a/services/inputflinger/reader/mapper/ExternalStylusInputMapper.cpp +++ b/services/inputflinger/reader/mapper/ExternalStylusInputMapper.cpp @@ -44,28 +44,32 @@ void ExternalStylusInputMapper::dump(std::string& dump) { dumpStylusState(dump, mStylusState); } -void ExternalStylusInputMapper::configure(nsecs_t when, const InputReaderConfiguration* config, - uint32_t changes) { +std::list<NotifyArgs> ExternalStylusInputMapper::configure(nsecs_t when, + const InputReaderConfiguration* config, + uint32_t changes) { getAbsoluteAxisInfo(ABS_PRESSURE, &mRawPressureAxis); mTouchButtonAccumulator.configure(getDeviceContext()); + return {}; } -void ExternalStylusInputMapper::reset(nsecs_t when) { +std::list<NotifyArgs> ExternalStylusInputMapper::reset(nsecs_t when) { mSingleTouchMotionAccumulator.reset(getDeviceContext()); mTouchButtonAccumulator.reset(getDeviceContext()); - InputMapper::reset(when); + return InputMapper::reset(when); } -void ExternalStylusInputMapper::process(const RawEvent* rawEvent) { +std::list<NotifyArgs> ExternalStylusInputMapper::process(const RawEvent* rawEvent) { + std::list<NotifyArgs> out; mSingleTouchMotionAccumulator.process(rawEvent); mTouchButtonAccumulator.process(rawEvent); if (rawEvent->type == EV_SYN && rawEvent->code == SYN_REPORT) { - sync(rawEvent->when); + out += sync(rawEvent->when); } + return out; } -void ExternalStylusInputMapper::sync(nsecs_t when) { +std::list<NotifyArgs> ExternalStylusInputMapper::sync(nsecs_t when) { mStylusState.clear(); mStylusState.when = when; @@ -86,7 +90,7 @@ void ExternalStylusInputMapper::sync(nsecs_t when) { mStylusState.buttons = mTouchButtonAccumulator.getButtonState(); - getContext()->dispatchExternalStylusState(mStylusState); + return getContext()->dispatchExternalStylusState(mStylusState); } } // namespace android diff --git a/services/inputflinger/reader/mapper/ExternalStylusInputMapper.h b/services/inputflinger/reader/mapper/ExternalStylusInputMapper.h index 03d9909b51..b6c9055cb7 100644 --- a/services/inputflinger/reader/mapper/ExternalStylusInputMapper.h +++ b/services/inputflinger/reader/mapper/ExternalStylusInputMapper.h @@ -29,13 +29,14 @@ public: explicit ExternalStylusInputMapper(InputDeviceContext& deviceContext); virtual ~ExternalStylusInputMapper() = default; - virtual uint32_t getSources() const override; - virtual void populateDeviceInfo(InputDeviceInfo* deviceInfo) override; - virtual void dump(std::string& dump) override; - virtual void configure(nsecs_t when, const InputReaderConfiguration* config, - uint32_t changes) override; - virtual void reset(nsecs_t when) override; - virtual void process(const RawEvent* rawEvent) override; + uint32_t getSources() const override; + void populateDeviceInfo(InputDeviceInfo* deviceInfo) override; + void dump(std::string& dump) override; + [[nodiscard]] std::list<NotifyArgs> configure(nsecs_t when, + const InputReaderConfiguration* config, + uint32_t changes) override; + [[nodiscard]] std::list<NotifyArgs> reset(nsecs_t when) override; + [[nodiscard]] std::list<NotifyArgs> process(const RawEvent* rawEvent) override; private: SingleTouchMotionAccumulator mSingleTouchMotionAccumulator; @@ -44,7 +45,7 @@ private: StylusState mStylusState; - void sync(nsecs_t when); + [[nodiscard]] std::list<NotifyArgs> sync(nsecs_t when); }; } // namespace android diff --git a/services/inputflinger/reader/mapper/InputMapper.cpp b/services/inputflinger/reader/mapper/InputMapper.cpp index 75cebf3ddb..844afe0522 100644 --- a/services/inputflinger/reader/mapper/InputMapper.cpp +++ b/services/inputflinger/reader/mapper/InputMapper.cpp @@ -32,12 +32,18 @@ void InputMapper::populateDeviceInfo(InputDeviceInfo* info) { void InputMapper::dump(std::string& dump) {} -void InputMapper::configure(nsecs_t when, const InputReaderConfiguration* config, - uint32_t changes) {} +std::list<NotifyArgs> InputMapper::configure(nsecs_t when, const InputReaderConfiguration* config, + uint32_t changes) { + return {}; +} -void InputMapper::reset(nsecs_t when) {} +std::list<NotifyArgs> InputMapper::reset(nsecs_t when) { + return {}; +} -void InputMapper::timeoutExpired(nsecs_t when) {} +std::list<NotifyArgs> InputMapper::timeoutExpired(nsecs_t when) { + return {}; +} int32_t InputMapper::getKeyCodeState(uint32_t sourceMask, int32_t keyCode) { return AKEY_STATE_UNKNOWN; @@ -60,9 +66,14 @@ bool InputMapper::markSupportedKeyCodes(uint32_t sourceMask, const std::vector<i return false; } -void InputMapper::vibrate(const VibrationSequence& sequence, ssize_t repeat, int32_t token) {} +std::list<NotifyArgs> InputMapper::vibrate(const VibrationSequence& sequence, ssize_t repeat, + int32_t token) { + return {}; +} -void InputMapper::cancelVibrate(int32_t token) {} +std::list<NotifyArgs> InputMapper::cancelVibrate(int32_t token) { + return {}; +} bool InputMapper::isVibrating() { return false; @@ -72,7 +83,9 @@ std::vector<int32_t> InputMapper::getVibratorIds() { return {}; } -void InputMapper::cancelTouch(nsecs_t when, nsecs_t readTime) {} +std::list<NotifyArgs> InputMapper::cancelTouch(nsecs_t when, nsecs_t readTime) { + return {}; +} bool InputMapper::enableSensor(InputDeviceSensorType sensorType, std::chrono::microseconds samplingPeriod, @@ -92,7 +105,9 @@ bool InputMapper::updateMetaState(int32_t keyCode) { return false; } -void InputMapper::updateExternalStylusState(const StylusState& state) {} +std::list<NotifyArgs> InputMapper::updateExternalStylusState(const StylusState& state) { + return {}; +} status_t InputMapper::getAbsoluteAxisInfo(int32_t axis, RawAbsoluteAxisInfo* axisInfo) { return getDeviceContext().getAbsoluteAxisInfo(axis, axisInfo); diff --git a/services/inputflinger/reader/mapper/InputMapper.h b/services/inputflinger/reader/mapper/InputMapper.h index 5567cac6a9..104305b730 100644 --- a/services/inputflinger/reader/mapper/InputMapper.h +++ b/services/inputflinger/reader/mapper/InputMapper.h @@ -20,6 +20,7 @@ #include "InputDevice.h" #include "InputListener.h" #include "InputReaderContext.h" +#include "NotifyArgs.h" #include "StylusState.h" #include "VibrationElement.h" @@ -48,15 +49,16 @@ public: inline const std::string getDeviceName() const { return mDeviceContext.getName(); } inline InputReaderContext* getContext() { return mDeviceContext.getContext(); } inline InputReaderPolicyInterface* getPolicy() { return getContext()->getPolicy(); } - inline InputListenerInterface& getListener() { return getContext()->getListener(); } virtual uint32_t getSources() const = 0; virtual void populateDeviceInfo(InputDeviceInfo* deviceInfo); virtual void dump(std::string& dump); - virtual void configure(nsecs_t when, const InputReaderConfiguration* config, uint32_t changes); - virtual void reset(nsecs_t when); - virtual void process(const RawEvent* rawEvent) = 0; - virtual void timeoutExpired(nsecs_t when); + [[nodiscard]] virtual std::list<NotifyArgs> configure(nsecs_t when, + const InputReaderConfiguration* config, + uint32_t changes); + [[nodiscard]] virtual std::list<NotifyArgs> reset(nsecs_t when); + [[nodiscard]] virtual std::list<NotifyArgs> process(const RawEvent* rawEvent) = 0; + [[nodiscard]] virtual std::list<NotifyArgs> timeoutExpired(nsecs_t when); virtual int32_t getKeyCodeState(uint32_t sourceMask, int32_t keyCode); virtual int32_t getScanCodeState(uint32_t sourceMask, int32_t scanCode); @@ -65,11 +67,12 @@ public: virtual bool markSupportedKeyCodes(uint32_t sourceMask, const std::vector<int32_t>& keyCodes, uint8_t* outFlags); - virtual void vibrate(const VibrationSequence& sequence, ssize_t repeat, int32_t token); - virtual void cancelVibrate(int32_t token); + [[nodiscard]] virtual std::list<NotifyArgs> vibrate(const VibrationSequence& sequence, + ssize_t repeat, int32_t token); + [[nodiscard]] virtual std::list<NotifyArgs> cancelVibrate(int32_t token); virtual bool isVibrating(); virtual std::vector<int32_t> getVibratorIds(); - virtual void cancelTouch(nsecs_t when, nsecs_t readTime); + [[nodiscard]] virtual std::list<NotifyArgs> cancelTouch(nsecs_t when, nsecs_t readTime); virtual bool enableSensor(InputDeviceSensorType sensorType, std::chrono::microseconds samplingPeriod, std::chrono::microseconds maxBatchReportLatency); @@ -91,7 +94,7 @@ public: */ virtual bool updateMetaState(int32_t keyCode); - virtual void updateExternalStylusState(const StylusState& state); + [[nodiscard]] virtual std::list<NotifyArgs> updateExternalStylusState(const StylusState& state); virtual std::optional<int32_t> getAssociatedDisplayId() { return std::nullopt; } virtual void updateLedState(bool reset) {} diff --git a/services/inputflinger/reader/mapper/JoystickInputMapper.cpp b/services/inputflinger/reader/mapper/JoystickInputMapper.cpp index 7d30d0c1eb..42b80129a1 100644 --- a/services/inputflinger/reader/mapper/JoystickInputMapper.cpp +++ b/services/inputflinger/reader/mapper/JoystickInputMapper.cpp @@ -103,9 +103,10 @@ void JoystickInputMapper::dump(std::string& dump) { } } -void JoystickInputMapper::configure(nsecs_t when, const InputReaderConfiguration* config, - uint32_t changes) { - InputMapper::configure(when, config, changes); +std::list<NotifyArgs> JoystickInputMapper::configure(nsecs_t when, + const InputReaderConfiguration* config, + uint32_t changes) { + std::list<NotifyArgs> out = InputMapper::configure(when, config, changes); if (!changes) { // first time only // Collect all axes. @@ -164,6 +165,7 @@ void JoystickInputMapper::configure(nsecs_t when, const InputReaderConfiguration it++; } } + return out; } JoystickInputMapper::Axis JoystickInputMapper::createAxis(const AxisInfo& axisInfo, @@ -246,17 +248,18 @@ bool JoystickInputMapper::isCenteredAxis(int32_t axis) { } } -void JoystickInputMapper::reset(nsecs_t when) { +std::list<NotifyArgs> JoystickInputMapper::reset(nsecs_t when) { // Recenter all axes. for (std::pair<const int32_t, Axis>& pair : mAxes) { Axis& axis = pair.second; axis.resetValue(); } - InputMapper::reset(when); + return InputMapper::reset(when); } -void JoystickInputMapper::process(const RawEvent* rawEvent) { +std::list<NotifyArgs> JoystickInputMapper::process(const RawEvent* rawEvent) { + std::list<NotifyArgs> out; switch (rawEvent->type) { case EV_ABS: { auto it = mAxes.find(rawEvent->code); @@ -298,16 +301,18 @@ void JoystickInputMapper::process(const RawEvent* rawEvent) { case EV_SYN: switch (rawEvent->code) { case SYN_REPORT: - sync(rawEvent->when, rawEvent->readTime, false /*force*/); + out += sync(rawEvent->when, rawEvent->readTime, false /*force*/); break; } break; } + return out; } -void JoystickInputMapper::sync(nsecs_t when, nsecs_t readTime, bool force) { +std::list<NotifyArgs> JoystickInputMapper::sync(nsecs_t when, nsecs_t readTime, bool force) { + std::list<NotifyArgs> out; if (!filterAxes(force)) { - return; + return out; } int32_t metaState = getContext()->getGlobalMetaState(); @@ -340,13 +345,14 @@ void JoystickInputMapper::sync(nsecs_t when, nsecs_t readTime, bool force) { displayId = getDeviceContext().getAssociatedViewport()->displayId; } - NotifyMotionArgs args(getContext()->getNextId(), when, readTime, getDeviceId(), - AINPUT_SOURCE_JOYSTICK, displayId, policyFlags, AMOTION_EVENT_ACTION_MOVE, - 0, 0, metaState, buttonState, MotionClassification::NONE, - AMOTION_EVENT_EDGE_FLAG_NONE, 1, &pointerProperties, &pointerCoords, 0, 0, - AMOTION_EVENT_INVALID_CURSOR_POSITION, - AMOTION_EVENT_INVALID_CURSOR_POSITION, 0, /* videoFrames */ {}); - getListener().notifyMotion(&args); + out.push_back(NotifyMotionArgs(getContext()->getNextId(), when, readTime, getDeviceId(), + AINPUT_SOURCE_JOYSTICK, displayId, policyFlags, + AMOTION_EVENT_ACTION_MOVE, 0, 0, metaState, buttonState, + MotionClassification::NONE, AMOTION_EVENT_EDGE_FLAG_NONE, 1, + &pointerProperties, &pointerCoords, 0, 0, + AMOTION_EVENT_INVALID_CURSOR_POSITION, + AMOTION_EVENT_INVALID_CURSOR_POSITION, 0, /* videoFrames */ {})); + return out; } void JoystickInputMapper::setPointerCoordsAxisValue(PointerCoords* pointerCoords, int32_t axis, diff --git a/services/inputflinger/reader/mapper/JoystickInputMapper.h b/services/inputflinger/reader/mapper/JoystickInputMapper.h index e0023970de..72b8a528b5 100644 --- a/services/inputflinger/reader/mapper/JoystickInputMapper.h +++ b/services/inputflinger/reader/mapper/JoystickInputMapper.h @@ -28,10 +28,11 @@ public: virtual uint32_t getSources() const override; virtual void populateDeviceInfo(InputDeviceInfo* deviceInfo) override; virtual void dump(std::string& dump) override; - virtual void configure(nsecs_t when, const InputReaderConfiguration* config, - uint32_t changes) override; - virtual void reset(nsecs_t when) override; - virtual void process(const RawEvent* rawEvent) override; + [[nodiscard]] std::list<NotifyArgs> configure(nsecs_t when, + const InputReaderConfiguration* config, + uint32_t changes) override; + [[nodiscard]] std::list<NotifyArgs> reset(nsecs_t when) override; + [[nodiscard]] std::list<NotifyArgs> process(const RawEvent* rawEvent) override; private: struct Axis { @@ -91,7 +92,7 @@ private: // Axes indexed by raw ABS_* axis index. std::unordered_map<int32_t, Axis> mAxes; - void sync(nsecs_t when, nsecs_t readTime, bool force); + [[nodiscard]] std::list<NotifyArgs> sync(nsecs_t when, nsecs_t readTime, bool force); bool haveAxis(int32_t axisId); void pruneAxes(bool ignoreExplicitlyMappedAxes); diff --git a/services/inputflinger/reader/mapper/KeyboardInputMapper.cpp b/services/inputflinger/reader/mapper/KeyboardInputMapper.cpp index 9bb6273d71..8704d1b211 100644 --- a/services/inputflinger/reader/mapper/KeyboardInputMapper.cpp +++ b/services/inputflinger/reader/mapper/KeyboardInputMapper.cpp @@ -143,9 +143,10 @@ std::optional<DisplayViewport> KeyboardInputMapper::findViewport( return std::nullopt; } -void KeyboardInputMapper::configure(nsecs_t when, const InputReaderConfiguration* config, - uint32_t changes) { - InputMapper::configure(when, config, changes); +std::list<NotifyArgs> KeyboardInputMapper::configure(nsecs_t when, + const InputReaderConfiguration* config, + uint32_t changes) { + std::list<NotifyArgs> out = InputMapper::configure(when, config, changes); if (!changes) { // first time only // Configure basic parameters. @@ -155,6 +156,7 @@ void KeyboardInputMapper::configure(nsecs_t when, const InputReaderConfiguration if (!changes || (changes & InputReaderConfiguration::CHANGE_DISPLAY_INFO)) { mViewport = findViewport(when, config); } + return out; } static void mapStemKey(int32_t keyCode, const PropertyMap& config, char const* property) { @@ -194,16 +196,18 @@ void KeyboardInputMapper::dumpParameters(std::string& dump) { dump += StringPrintf(INDENT4 "HandlesKeyRepeat: %s\n", toString(mParameters.handlesKeyRepeat)); } -void KeyboardInputMapper::reset(nsecs_t when) { - cancelAllDownKeys(when); +std::list<NotifyArgs> KeyboardInputMapper::reset(nsecs_t when) { + std::list<NotifyArgs> out = cancelAllDownKeys(when); mCurrentHidUsage = 0; resetLedState(); - InputMapper::reset(when); + out += InputMapper::reset(when); + return out; } -void KeyboardInputMapper::process(const RawEvent* rawEvent) { +std::list<NotifyArgs> KeyboardInputMapper::process(const RawEvent* rawEvent) { + std::list<NotifyArgs> out; switch (rawEvent->type) { case EV_KEY: { int32_t scanCode = rawEvent->code; @@ -211,8 +215,8 @@ void KeyboardInputMapper::process(const RawEvent* rawEvent) { mCurrentHidUsage = 0; if (isKeyboardOrGamepadKey(scanCode)) { - processKey(rawEvent->when, rawEvent->readTime, rawEvent->value != 0, scanCode, - usageCode); + out += processKey(rawEvent->when, rawEvent->readTime, rawEvent->value != 0, + scanCode, usageCode); } break; } @@ -228,6 +232,7 @@ void KeyboardInputMapper::process(const RawEvent* rawEvent) { } } } + return out; } bool KeyboardInputMapper::isKeyboardOrGamepadKey(int32_t scanCode) { @@ -265,8 +270,9 @@ bool KeyboardInputMapper::isMediaKey(int32_t keyCode) { return false; } -void KeyboardInputMapper::processKey(nsecs_t when, nsecs_t readTime, bool down, int32_t scanCode, - int32_t usageCode) { +std::list<NotifyArgs> KeyboardInputMapper::processKey(nsecs_t when, nsecs_t readTime, bool down, + int32_t scanCode, int32_t usageCode) { + std::list<NotifyArgs> out; int32_t keyCode; int32_t keyMetaState; uint32_t policyFlags; @@ -295,10 +301,10 @@ void KeyboardInputMapper::processKey(nsecs_t when, nsecs_t readTime, bool down, // key down if ((policyFlags & POLICY_FLAG_VIRTUAL) && getContext()->shouldDropVirtualKey(when, keyCode, scanCode)) { - return; + return out; } if (policyFlags & POLICY_FLAG_GESTURE) { - getDeviceContext().cancelTouch(when, readTime); + out += getDeviceContext().cancelTouch(when, readTime); } KeyDown keyDown; @@ -320,7 +326,7 @@ void KeyboardInputMapper::processKey(nsecs_t when, nsecs_t readTime, bool down, ALOGI("Dropping key up from device %s because the key was not down. " "keyCode=%d, scanCode=%d", getDeviceName().c_str(), keyCode, scanCode); - return; + return out; } } @@ -347,11 +353,12 @@ void KeyboardInputMapper::processKey(nsecs_t when, nsecs_t readTime, bool down, policyFlags |= POLICY_FLAG_DISABLE_KEY_REPEAT; } - NotifyKeyArgs args(getContext()->getNextId(), when, readTime, getDeviceId(), mSource, - getDisplayId(), policyFlags, - down ? AKEY_EVENT_ACTION_DOWN : AKEY_EVENT_ACTION_UP, - AKEY_EVENT_FLAG_FROM_SYSTEM, keyCode, scanCode, keyMetaState, downTime); - getListener().notifyKey(&args); + out.push_back(NotifyKeyArgs(getContext()->getNextId(), when, readTime, getDeviceId(), mSource, + getDisplayId(), policyFlags, + down ? AKEY_EVENT_ACTION_DOWN : AKEY_EVENT_ACTION_UP, + AKEY_EVENT_FLAG_FROM_SYSTEM, keyCode, scanCode, keyMetaState, + downTime)); + return out; } ssize_t KeyboardInputMapper::findKeyDown(int32_t scanCode) { @@ -470,19 +477,20 @@ std::optional<int32_t> KeyboardInputMapper::getAssociatedDisplayId() { return std::nullopt; } -void KeyboardInputMapper::cancelAllDownKeys(nsecs_t when) { +std::list<NotifyArgs> KeyboardInputMapper::cancelAllDownKeys(nsecs_t when) { + std::list<NotifyArgs> out; size_t n = mKeyDowns.size(); for (size_t i = 0; i < n; i++) { - NotifyKeyArgs args(getContext()->getNextId(), when, systemTime(SYSTEM_TIME_MONOTONIC), - getDeviceId(), mSource, getDisplayId(), 0 /*policyFlags*/, - AKEY_EVENT_ACTION_UP, - AKEY_EVENT_FLAG_FROM_SYSTEM | AKEY_EVENT_FLAG_CANCELED, - mKeyDowns[i].keyCode, mKeyDowns[i].scanCode, AMETA_NONE, - mKeyDowns[i].downTime); - getListener().notifyKey(&args); + out.push_back(NotifyKeyArgs(getContext()->getNextId(), when, + systemTime(SYSTEM_TIME_MONOTONIC), getDeviceId(), mSource, + getDisplayId(), 0 /*policyFlags*/, AKEY_EVENT_ACTION_UP, + AKEY_EVENT_FLAG_FROM_SYSTEM | AKEY_EVENT_FLAG_CANCELED, + mKeyDowns[i].keyCode, mKeyDowns[i].scanCode, AMETA_NONE, + mKeyDowns[i].downTime)); } mKeyDowns.clear(); mMetaState = AMETA_NONE; + return out; } } // namespace android diff --git a/services/inputflinger/reader/mapper/KeyboardInputMapper.h b/services/inputflinger/reader/mapper/KeyboardInputMapper.h index 2136d253c9..8d72ee9629 100644 --- a/services/inputflinger/reader/mapper/KeyboardInputMapper.h +++ b/services/inputflinger/reader/mapper/KeyboardInputMapper.h @@ -25,24 +25,25 @@ public: KeyboardInputMapper(InputDeviceContext& deviceContext, uint32_t source, int32_t keyboardType); virtual ~KeyboardInputMapper(); - virtual uint32_t getSources() const override; - virtual void populateDeviceInfo(InputDeviceInfo* deviceInfo) override; - virtual void dump(std::string& dump) override; - virtual void configure(nsecs_t when, const InputReaderConfiguration* config, - uint32_t changes) override; - virtual void reset(nsecs_t when) override; - virtual void process(const RawEvent* rawEvent) override; - - virtual int32_t getKeyCodeState(uint32_t sourceMask, int32_t keyCode) override; - virtual int32_t getScanCodeState(uint32_t sourceMask, int32_t scanCode) override; - virtual bool markSupportedKeyCodes(uint32_t sourceMask, const std::vector<int32_t>& keyCodes, - uint8_t* outFlags) override; - virtual int32_t getKeyCodeForKeyLocation(int32_t locationKeyCode) const override; - - virtual int32_t getMetaState() override; - virtual bool updateMetaState(int32_t keyCode) override; - virtual std::optional<int32_t> getAssociatedDisplayId() override; - virtual void updateLedState(bool reset); + uint32_t getSources() const override; + void populateDeviceInfo(InputDeviceInfo* deviceInfo) override; + void dump(std::string& dump) override; + [[nodiscard]] std::list<NotifyArgs> configure(nsecs_t when, + const InputReaderConfiguration* config, + uint32_t changes) override; + [[nodiscard]] std::list<NotifyArgs> reset(nsecs_t when) override; + [[nodiscard]] std::list<NotifyArgs> process(const RawEvent* rawEvent) override; + + int32_t getKeyCodeState(uint32_t sourceMask, int32_t keyCode) override; + int32_t getScanCodeState(uint32_t sourceMask, int32_t scanCode) override; + bool markSupportedKeyCodes(uint32_t sourceMask, const std::vector<int32_t>& keyCodes, + uint8_t* outFlags) override; + int32_t getKeyCodeForKeyLocation(int32_t locationKeyCode) const override; + + int32_t getMetaState() override; + bool updateMetaState(int32_t keyCode) override; + std::optional<int32_t> getAssociatedDisplayId() override; + void updateLedState(bool reset) override; private: // The current viewport. @@ -86,7 +87,8 @@ private: bool isKeyboardOrGamepadKey(int32_t scanCode); bool isMediaKey(int32_t keyCode); - void processKey(nsecs_t when, nsecs_t readTime, bool down, int32_t scanCode, int32_t usageCode); + [[nodiscard]] std::list<NotifyArgs> processKey(nsecs_t when, nsecs_t readTime, bool down, + int32_t scanCode, int32_t usageCode); bool updateMetaStateIfNeeded(int32_t keyCode, bool down); @@ -97,7 +99,7 @@ private: void updateLedStateForModifier(LedState& ledState, int32_t led, int32_t modifier, bool reset); std::optional<DisplayViewport> findViewport(nsecs_t when, const InputReaderConfiguration* config); - void cancelAllDownKeys(nsecs_t when); + [[nodiscard]] std::list<NotifyArgs> cancelAllDownKeys(nsecs_t when); }; } // namespace android diff --git a/services/inputflinger/reader/mapper/MultiTouchInputMapper.cpp b/services/inputflinger/reader/mapper/MultiTouchInputMapper.cpp index 047f068751..1d53eaba6e 100644 --- a/services/inputflinger/reader/mapper/MultiTouchInputMapper.cpp +++ b/services/inputflinger/reader/mapper/MultiTouchInputMapper.cpp @@ -191,20 +191,21 @@ MultiTouchInputMapper::MultiTouchInputMapper(InputDeviceContext& deviceContext) MultiTouchInputMapper::~MultiTouchInputMapper() {} -void MultiTouchInputMapper::reset(nsecs_t when) { +std::list<NotifyArgs> MultiTouchInputMapper::reset(nsecs_t when) { // The evdev multi-touch protocol does not allow userspace applications to query the initial or // current state of the pointers at any time. This means if we clear our accumulated state when // resetting the input mapper, there's no way to rebuild the full initial state of the pointers. // We can only wait for updates to all the pointers and axes. Rather than clearing the state and // rebuilding the state from scratch, we work around this kernel API limitation by never // fully clearing any state specific to the multi-touch protocol. - TouchInputMapper::reset(when); + return TouchInputMapper::reset(when); } -void MultiTouchInputMapper::process(const RawEvent* rawEvent) { - TouchInputMapper::process(rawEvent); +std::list<NotifyArgs> MultiTouchInputMapper::process(const RawEvent* rawEvent) { + std::list<NotifyArgs> out = TouchInputMapper::process(rawEvent); mMultiTouchMotionAccumulator.process(rawEvent); + return out; } std::optional<int32_t> MultiTouchInputMapper::getActiveBitId( diff --git a/services/inputflinger/reader/mapper/MultiTouchInputMapper.h b/services/inputflinger/reader/mapper/MultiTouchInputMapper.h index 75cde8e6db..047e62de62 100644 --- a/services/inputflinger/reader/mapper/MultiTouchInputMapper.h +++ b/services/inputflinger/reader/mapper/MultiTouchInputMapper.h @@ -93,8 +93,8 @@ public: explicit MultiTouchInputMapper(InputDeviceContext& deviceContext); ~MultiTouchInputMapper() override; - void reset(nsecs_t when) override; - void process(const RawEvent* rawEvent) override; + [[nodiscard]] std::list<NotifyArgs> reset(nsecs_t when) override; + [[nodiscard]] std::list<NotifyArgs> process(const RawEvent* rawEvent) override; protected: void syncTouch(nsecs_t when, RawState* outState) override; diff --git a/services/inputflinger/reader/mapper/RotaryEncoderInputMapper.cpp b/services/inputflinger/reader/mapper/RotaryEncoderInputMapper.cpp index 05973f783c..29a1bda3ee 100644 --- a/services/inputflinger/reader/mapper/RotaryEncoderInputMapper.cpp +++ b/services/inputflinger/reader/mapper/RotaryEncoderInputMapper.cpp @@ -60,9 +60,10 @@ void RotaryEncoderInputMapper::dump(std::string& dump) { toString(mRotaryEncoderScrollAccumulator.haveRelativeVWheel())); } -void RotaryEncoderInputMapper::configure(nsecs_t when, const InputReaderConfiguration* config, - uint32_t changes) { - InputMapper::configure(when, config, changes); +std::list<NotifyArgs> RotaryEncoderInputMapper::configure(nsecs_t when, + const InputReaderConfiguration* config, + uint32_t changes) { + std::list<NotifyArgs> out = InputMapper::configure(when, config, changes); if (!changes) { mRotaryEncoderScrollAccumulator.configure(getDeviceContext()); } @@ -75,23 +76,27 @@ void RotaryEncoderInputMapper::configure(nsecs_t when, const InputReaderConfigur mOrientation = DISPLAY_ORIENTATION_0; } } + return out; } -void RotaryEncoderInputMapper::reset(nsecs_t when) { +std::list<NotifyArgs> RotaryEncoderInputMapper::reset(nsecs_t when) { mRotaryEncoderScrollAccumulator.reset(getDeviceContext()); - InputMapper::reset(when); + return InputMapper::reset(when); } -void RotaryEncoderInputMapper::process(const RawEvent* rawEvent) { +std::list<NotifyArgs> RotaryEncoderInputMapper::process(const RawEvent* rawEvent) { + std::list<NotifyArgs> out; mRotaryEncoderScrollAccumulator.process(rawEvent); if (rawEvent->type == EV_SYN && rawEvent->code == SYN_REPORT) { - sync(rawEvent->when, rawEvent->readTime); + out += sync(rawEvent->when, rawEvent->readTime); } + return out; } -void RotaryEncoderInputMapper::sync(nsecs_t when, nsecs_t readTime) { +std::list<NotifyArgs> RotaryEncoderInputMapper::sync(nsecs_t when, nsecs_t readTime) { + std::list<NotifyArgs> out; PointerCoords pointerCoords; pointerCoords.clear(); @@ -121,16 +126,17 @@ void RotaryEncoderInputMapper::sync(nsecs_t when, nsecs_t readTime) { int32_t metaState = getContext()->getGlobalMetaState(); pointerCoords.setAxisValue(AMOTION_EVENT_AXIS_SCROLL, scroll * mScalingFactor); - NotifyMotionArgs scrollArgs(getContext()->getNextId(), when, readTime, getDeviceId(), - mSource, displayId, policyFlags, AMOTION_EVENT_ACTION_SCROLL, 0, - 0, metaState, /* buttonState */ 0, MotionClassification::NONE, - AMOTION_EVENT_EDGE_FLAG_NONE, 1, &pointerProperties, - &pointerCoords, 0, 0, AMOTION_EVENT_INVALID_CURSOR_POSITION, - AMOTION_EVENT_INVALID_CURSOR_POSITION, 0, /* videoFrames */ {}); - getListener().notifyMotion(&scrollArgs); + out.push_back( + NotifyMotionArgs(getContext()->getNextId(), when, readTime, getDeviceId(), mSource, + displayId, policyFlags, AMOTION_EVENT_ACTION_SCROLL, 0, 0, + metaState, /* buttonState */ 0, MotionClassification::NONE, + AMOTION_EVENT_EDGE_FLAG_NONE, 1, &pointerProperties, + &pointerCoords, 0, 0, AMOTION_EVENT_INVALID_CURSOR_POSITION, + AMOTION_EVENT_INVALID_CURSOR_POSITION, 0, /* videoFrames */ {})); } mRotaryEncoderScrollAccumulator.finishSync(); + return out; } } // namespace android diff --git a/services/inputflinger/reader/mapper/RotaryEncoderInputMapper.h b/services/inputflinger/reader/mapper/RotaryEncoderInputMapper.h index 42e2421c37..f4352e76a0 100644 --- a/services/inputflinger/reader/mapper/RotaryEncoderInputMapper.h +++ b/services/inputflinger/reader/mapper/RotaryEncoderInputMapper.h @@ -29,10 +29,11 @@ public: virtual uint32_t getSources() const override; virtual void populateDeviceInfo(InputDeviceInfo* deviceInfo) override; virtual void dump(std::string& dump) override; - virtual void configure(nsecs_t when, const InputReaderConfiguration* config, - uint32_t changes) override; - virtual void reset(nsecs_t when) override; - virtual void process(const RawEvent* rawEvent) override; + [[nodiscard]] std::list<NotifyArgs> configure(nsecs_t when, + const InputReaderConfiguration* config, + uint32_t changes) override; + [[nodiscard]] std::list<NotifyArgs> reset(nsecs_t when) override; + [[nodiscard]] std::list<NotifyArgs> process(const RawEvent* rawEvent) override; private: CursorScrollAccumulator mRotaryEncoderScrollAccumulator; @@ -41,7 +42,7 @@ private: float mScalingFactor; int32_t mOrientation; - void sync(nsecs_t when, nsecs_t readTime); + [[nodiscard]] std::list<NotifyArgs> sync(nsecs_t when, nsecs_t readTime); }; } // namespace android diff --git a/services/inputflinger/reader/mapper/SensorInputMapper.cpp b/services/inputflinger/reader/mapper/SensorInputMapper.cpp index 573f99cf87..d81022f6e5 100644 --- a/services/inputflinger/reader/mapper/SensorInputMapper.cpp +++ b/services/inputflinger/reader/mapper/SensorInputMapper.cpp @@ -122,9 +122,10 @@ void SensorInputMapper::dump(std::string& dump) { } } -void SensorInputMapper::configure(nsecs_t when, const InputReaderConfiguration* config, - uint32_t changes) { - InputMapper::configure(when, config, changes); +std::list<NotifyArgs> SensorInputMapper::configure(nsecs_t when, + const InputReaderConfiguration* config, + uint32_t changes) { + std::list<NotifyArgs> out = InputMapper::configure(when, config, changes); if (!changes) { // first time only mDeviceEnabled = true; @@ -158,6 +159,7 @@ void SensorInputMapper::configure(nsecs_t when, const InputReaderConfiguration* } } } + return out; } SensorInputMapper::Axis SensorInputMapper::createAxis(const AxisInfo& axisInfo, @@ -185,7 +187,7 @@ SensorInputMapper::Axis SensorInputMapper::createAxis(const AxisInfo& axisInfo, return Axis(rawAxisInfo, axisInfo, scale, offset, min, max, flat, fuzz, resolution, filter); } -void SensorInputMapper::reset(nsecs_t when) { +std::list<NotifyArgs> SensorInputMapper::reset(nsecs_t when) { // Recenter all axes. for (std::pair<const int32_t, Axis>& pair : mAxes) { Axis& axis = pair.second; @@ -193,7 +195,7 @@ void SensorInputMapper::reset(nsecs_t when) { } mHardwareTimestamp = 0; mPrevMscTime = 0; - InputMapper::reset(when); + return InputMapper::reset(when); } SensorInputMapper::Sensor SensorInputMapper::createSensor(InputDeviceSensorType sensorType, @@ -256,7 +258,8 @@ void SensorInputMapper::processHardWareTimestamp(nsecs_t evTime, int32_t mscTime mPrevMscTime = static_cast<uint32_t>(mscTime); } -void SensorInputMapper::process(const RawEvent* rawEvent) { +std::list<NotifyArgs> SensorInputMapper::process(const RawEvent* rawEvent) { + std::list<NotifyArgs> out; switch (rawEvent->type) { case EV_ABS: { auto it = mAxes.find(rawEvent->code); @@ -274,7 +277,7 @@ void SensorInputMapper::process(const RawEvent* rawEvent) { Axis& axis = pair.second; axis.currentValue = axis.newValue; } - sync(rawEvent->when, false /*force*/); + out += sync(rawEvent->when, false /*force*/); break; } break; @@ -287,6 +290,7 @@ void SensorInputMapper::process(const RawEvent* rawEvent) { break; } } + return out; } bool SensorInputMapper::setSensorEnabled(InputDeviceSensorType sensorType, bool enabled) { @@ -375,7 +379,8 @@ void SensorInputMapper::disableSensor(InputDeviceSensorType sensorType) { } } -void SensorInputMapper::sync(nsecs_t when, bool force) { +std::list<NotifyArgs> SensorInputMapper::sync(nsecs_t when, bool force) { + std::list<NotifyArgs> out; for (auto& [sensorType, sensor] : mSensors) { // Skip if sensor not enabled if (!sensor.enabled) { @@ -405,17 +410,17 @@ void SensorInputMapper::sync(nsecs_t when, bool force) { // Convert to Android unit convertFromLinuxToAndroid(values, sensorType); // Notify dispatcher for sensor event - NotifySensorArgs args(getContext()->getNextId(), when, getDeviceId(), - AINPUT_SOURCE_SENSOR, sensorType, sensor.sensorInfo.accuracy, - sensor.accuracy != - sensor.sensorInfo.accuracy /* accuracyChanged */, - timestamp /* hwTimestamp */, values); - - getListener().notifySensor(&args); + out.push_back(NotifySensorArgs(getContext()->getNextId(), when, getDeviceId(), + AINPUT_SOURCE_SENSOR, sensorType, + sensor.sensorInfo.accuracy, + sensor.accuracy != + sensor.sensorInfo.accuracy /* accuracyChanged */, + timestamp /* hwTimestamp */, values)); sensor.lastSampleTimeNs = timestamp; sensor.accuracy = sensor.sensorInfo.accuracy; } } + return out; } } // namespace android diff --git a/services/inputflinger/reader/mapper/SensorInputMapper.h b/services/inputflinger/reader/mapper/SensorInputMapper.h index 38d4c3c935..457567ba7b 100644 --- a/services/inputflinger/reader/mapper/SensorInputMapper.h +++ b/services/inputflinger/reader/mapper/SensorInputMapper.h @@ -30,9 +30,11 @@ public: uint32_t getSources() const override; void populateDeviceInfo(InputDeviceInfo* deviceInfo) override; void dump(std::string& dump) override; - void configure(nsecs_t when, const InputReaderConfiguration* config, uint32_t changes) override; - void reset(nsecs_t when) override; - void process(const RawEvent* rawEvent) override; + [[nodiscard]] std::list<NotifyArgs> configure(nsecs_t when, + const InputReaderConfiguration* config, + uint32_t changes) override; + [[nodiscard]] std::list<NotifyArgs> reset(nsecs_t when) override; + [[nodiscard]] std::list<NotifyArgs> process(const RawEvent* rawEvent) override; bool enableSensor(InputDeviceSensorType sensorType, std::chrono::microseconds samplingPeriod, std::chrono::microseconds maxBatchReportLatency) override; void disableSensor(InputDeviceSensorType sensorType) override; @@ -116,7 +118,7 @@ private: // Sensor list std::unordered_map<InputDeviceSensorType, Sensor> mSensors; - void sync(nsecs_t when, bool force); + [[nodiscard]] std::list<NotifyArgs> sync(nsecs_t when, bool force); template <typename T> bool tryGetProperty(std::string keyName, T& outValue); diff --git a/services/inputflinger/reader/mapper/SingleTouchInputMapper.cpp b/services/inputflinger/reader/mapper/SingleTouchInputMapper.cpp index 4fff9bebb5..13ad224111 100644 --- a/services/inputflinger/reader/mapper/SingleTouchInputMapper.cpp +++ b/services/inputflinger/reader/mapper/SingleTouchInputMapper.cpp @@ -23,16 +23,17 @@ SingleTouchInputMapper::SingleTouchInputMapper(InputDeviceContext& deviceContext SingleTouchInputMapper::~SingleTouchInputMapper() {} -void SingleTouchInputMapper::reset(nsecs_t when) { +std::list<NotifyArgs> SingleTouchInputMapper::reset(nsecs_t when) { mSingleTouchMotionAccumulator.reset(getDeviceContext()); - TouchInputMapper::reset(when); + return TouchInputMapper::reset(when); } -void SingleTouchInputMapper::process(const RawEvent* rawEvent) { - TouchInputMapper::process(rawEvent); +std::list<NotifyArgs> SingleTouchInputMapper::process(const RawEvent* rawEvent) { + std::list<NotifyArgs> out = TouchInputMapper::process(rawEvent); mSingleTouchMotionAccumulator.process(rawEvent); + return out; } void SingleTouchInputMapper::syncTouch(nsecs_t when, RawState* outState) { diff --git a/services/inputflinger/reader/mapper/SingleTouchInputMapper.h b/services/inputflinger/reader/mapper/SingleTouchInputMapper.h index f54c19502e..662e6bca25 100644 --- a/services/inputflinger/reader/mapper/SingleTouchInputMapper.h +++ b/services/inputflinger/reader/mapper/SingleTouchInputMapper.h @@ -26,8 +26,8 @@ public: explicit SingleTouchInputMapper(InputDeviceContext& deviceContext); ~SingleTouchInputMapper() override; - void reset(nsecs_t when) override; - void process(const RawEvent* rawEvent) override; + [[nodiscard]] std::list<NotifyArgs> reset(nsecs_t when) override; + [[nodiscard]] std::list<NotifyArgs> process(const RawEvent* rawEvent) override; protected: void syncTouch(nsecs_t when, RawState* outState) override; diff --git a/services/inputflinger/reader/mapper/SwitchInputMapper.cpp b/services/inputflinger/reader/mapper/SwitchInputMapper.cpp index ebb5de66ed..c9101cadc6 100644 --- a/services/inputflinger/reader/mapper/SwitchInputMapper.cpp +++ b/services/inputflinger/reader/mapper/SwitchInputMapper.cpp @@ -29,7 +29,8 @@ uint32_t SwitchInputMapper::getSources() const { return AINPUT_SOURCE_SWITCH; } -void SwitchInputMapper::process(const RawEvent* rawEvent) { +std::list<NotifyArgs> SwitchInputMapper::process(const RawEvent* rawEvent) { + std::list<NotifyArgs> out; switch (rawEvent->type) { case EV_SW: processSwitch(rawEvent->code, rawEvent->value); @@ -37,9 +38,10 @@ void SwitchInputMapper::process(const RawEvent* rawEvent) { case EV_SYN: if (rawEvent->code == SYN_REPORT) { - sync(rawEvent->when); + out += sync(rawEvent->when); } } + return out; } void SwitchInputMapper::processSwitch(int32_t switchCode, int32_t switchValue) { @@ -53,15 +55,16 @@ void SwitchInputMapper::processSwitch(int32_t switchCode, int32_t switchValue) { } } -void SwitchInputMapper::sync(nsecs_t when) { +std::list<NotifyArgs> SwitchInputMapper::sync(nsecs_t when) { + std::list<NotifyArgs> out; if (mUpdatedSwitchMask) { uint32_t updatedSwitchValues = mSwitchValues & mUpdatedSwitchMask; - NotifySwitchArgs args(getContext()->getNextId(), when, 0 /*policyFlags*/, - updatedSwitchValues, mUpdatedSwitchMask); - getListener().notifySwitch(&args); + out.push_back(NotifySwitchArgs(getContext()->getNextId(), when, 0 /*policyFlags*/, + updatedSwitchValues, mUpdatedSwitchMask)); mUpdatedSwitchMask = 0; } + return out; } int32_t SwitchInputMapper::getSwitchState(uint32_t sourceMask, int32_t switchCode) { diff --git a/services/inputflinger/reader/mapper/SwitchInputMapper.h b/services/inputflinger/reader/mapper/SwitchInputMapper.h index e0c949f012..06d6504684 100644 --- a/services/inputflinger/reader/mapper/SwitchInputMapper.h +++ b/services/inputflinger/reader/mapper/SwitchInputMapper.h @@ -26,7 +26,7 @@ public: virtual ~SwitchInputMapper(); virtual uint32_t getSources() const override; - virtual void process(const RawEvent* rawEvent) override; + [[nodiscard]] std::list<NotifyArgs> process(const RawEvent* rawEvent) override; virtual int32_t getSwitchState(uint32_t sourceMask, int32_t switchCode) override; virtual void dump(std::string& dump) override; @@ -36,7 +36,7 @@ private: uint32_t mUpdatedSwitchMask; void processSwitch(int32_t switchCode, int32_t switchValue); - void sync(nsecs_t when); + [[nodiscard]] std::list<NotifyArgs> sync(nsecs_t when); }; } // namespace android diff --git a/services/inputflinger/reader/mapper/TouchCursorInputMapperCommon.h b/services/inputflinger/reader/mapper/TouchCursorInputMapperCommon.h index 42d819b362..5a7ba9a6ed 100644 --- a/services/inputflinger/reader/mapper/TouchCursorInputMapperCommon.h +++ b/services/inputflinger/reader/mapper/TouchCursorInputMapperCommon.h @@ -71,30 +71,34 @@ static bool isPointerDown(int32_t buttonState) { AMOTION_EVENT_BUTTON_TERTIARY); } -static void synthesizeButtonKey(InputReaderContext* context, int32_t action, nsecs_t when, - nsecs_t readTime, int32_t deviceId, uint32_t source, - int32_t displayId, uint32_t policyFlags, int32_t lastButtonState, - int32_t currentButtonState, int32_t buttonState, int32_t keyCode) { +[[nodiscard]] static std::list<NotifyArgs> synthesizeButtonKey( + InputReaderContext* context, int32_t action, nsecs_t when, nsecs_t readTime, + int32_t deviceId, uint32_t source, int32_t displayId, uint32_t policyFlags, + int32_t lastButtonState, int32_t currentButtonState, int32_t buttonState, int32_t keyCode) { + std::list<NotifyArgs> out; if ((action == AKEY_EVENT_ACTION_DOWN && !(lastButtonState & buttonState) && (currentButtonState & buttonState)) || (action == AKEY_EVENT_ACTION_UP && (lastButtonState & buttonState) && !(currentButtonState & buttonState))) { - NotifyKeyArgs args(context->getNextId(), when, readTime, deviceId, source, displayId, - policyFlags, action, 0, keyCode, 0, context->getGlobalMetaState(), when); - context->getListener().notifyKey(&args); + out.push_back(NotifyKeyArgs(context->getNextId(), when, readTime, deviceId, source, + displayId, policyFlags, action, 0, keyCode, 0, + context->getGlobalMetaState(), when)); } + return out; } -static void synthesizeButtonKeys(InputReaderContext* context, int32_t action, nsecs_t when, - nsecs_t readTime, int32_t deviceId, uint32_t source, - int32_t displayId, uint32_t policyFlags, int32_t lastButtonState, - int32_t currentButtonState) { - synthesizeButtonKey(context, action, when, readTime, deviceId, source, displayId, policyFlags, - lastButtonState, currentButtonState, AMOTION_EVENT_BUTTON_BACK, - AKEYCODE_BACK); - synthesizeButtonKey(context, action, when, readTime, deviceId, source, displayId, policyFlags, - lastButtonState, currentButtonState, AMOTION_EVENT_BUTTON_FORWARD, - AKEYCODE_FORWARD); +[[nodiscard]] static std::list<NotifyArgs> synthesizeButtonKeys( + InputReaderContext* context, int32_t action, nsecs_t when, nsecs_t readTime, + int32_t deviceId, uint32_t source, int32_t displayId, uint32_t policyFlags, + int32_t lastButtonState, int32_t currentButtonState) { + std::list<NotifyArgs> out; + out += synthesizeButtonKey(context, action, when, readTime, deviceId, source, displayId, + policyFlags, lastButtonState, currentButtonState, + AMOTION_EVENT_BUTTON_BACK, AKEYCODE_BACK); + out += synthesizeButtonKey(context, action, when, readTime, deviceId, source, displayId, + policyFlags, lastButtonState, currentButtonState, + AMOTION_EVENT_BUTTON_FORWARD, AKEYCODE_FORWARD); + return out; } } // namespace android diff --git a/services/inputflinger/reader/mapper/TouchInputMapper.cpp b/services/inputflinger/reader/mapper/TouchInputMapper.cpp index 5d0f1888ef..da58efde31 100644 --- a/services/inputflinger/reader/mapper/TouchInputMapper.cpp +++ b/services/inputflinger/reader/mapper/TouchInputMapper.cpp @@ -346,9 +346,10 @@ void TouchInputMapper::dump(std::string& dump) { } } -void TouchInputMapper::configure(nsecs_t when, const InputReaderConfiguration* config, - uint32_t changes) { - InputMapper::configure(when, config, changes); +std::list<NotifyArgs> TouchInputMapper::configure(nsecs_t when, + const InputReaderConfiguration* config, + uint32_t changes) { + std::list<NotifyArgs> out = InputMapper::configure(when, config, changes); mConfig = *config; @@ -395,14 +396,14 @@ void TouchInputMapper::configure(nsecs_t when, const InputReaderConfiguration* c if (changes && resetNeeded) { // If the device needs to be reset, cancel any ongoing gestures and reset the state. - cancelTouch(when, when); - reset(when); + out += cancelTouch(when, when); + out += reset(when); // Send reset, unless this is the first time the device has been configured, // in which case the reader will call reset itself after all mappers are ready. - NotifyDeviceResetArgs args(getContext()->getNextId(), when, getDeviceId()); - getListener().notifyDeviceReset(&args); + out.push_back(NotifyDeviceResetArgs(getContext()->getNextId(), when, getDeviceId())); } + return out; } void TouchInputMapper::resolveExternalStylusPresence() { @@ -1438,7 +1439,7 @@ void TouchInputMapper::updateAffineTransformation() { mInputDeviceOrientation); } -void TouchInputMapper::reset(nsecs_t when) { +std::list<NotifyArgs> TouchInputMapper::reset(nsecs_t when) { mCursorButtonAccumulator.reset(getDeviceContext()); mCursorScrollAccumulator.reset(getDeviceContext()); mTouchButtonAccumulator.reset(getDeviceContext()); @@ -1469,7 +1470,7 @@ void TouchInputMapper::reset(nsecs_t when) { mPointerController->clearSpots(); } - InputMapper::reset(when); + return InputMapper::reset(when); } void TouchInputMapper::resetExternalStylus() { @@ -1484,17 +1485,20 @@ void TouchInputMapper::clearStylusDataPendingFlags() { mExternalStylusFusionTimeout = LLONG_MAX; } -void TouchInputMapper::process(const RawEvent* rawEvent) { +std::list<NotifyArgs> TouchInputMapper::process(const RawEvent* rawEvent) { mCursorButtonAccumulator.process(rawEvent); mCursorScrollAccumulator.process(rawEvent); mTouchButtonAccumulator.process(rawEvent); + std::list<NotifyArgs> out; if (rawEvent->type == EV_SYN && rawEvent->code == SYN_REPORT) { - sync(rawEvent->when, rawEvent->readTime); + out += sync(rawEvent->when, rawEvent->readTime); } + return out; } -void TouchInputMapper::sync(nsecs_t when, nsecs_t readTime) { +std::list<NotifyArgs> TouchInputMapper::sync(nsecs_t when, nsecs_t readTime) { + std::list<NotifyArgs> out; if (mDeviceMode == DeviceMode::DISABLED) { // Only save the last pending state when the device is disabled. mRawStatesPending.clear(); @@ -1543,16 +1547,18 @@ void TouchInputMapper::sync(nsecs_t when, nsecs_t readTime) { next.rawPointerData.hoveringIdBits.value); } - processRawTouches(false /*timeout*/); + out += processRawTouches(false /*timeout*/); + return out; } -void TouchInputMapper::processRawTouches(bool timeout) { +std::list<NotifyArgs> TouchInputMapper::processRawTouches(bool timeout) { + std::list<NotifyArgs> out; if (mDeviceMode == DeviceMode::DISABLED) { // Drop all input if the device is disabled. - cancelTouch(mCurrentRawState.when, mCurrentRawState.readTime); + out += cancelTouch(mCurrentRawState.when, mCurrentRawState.readTime); mCurrentCookedState.clear(); updateTouchSpots(); - return; + return out; } // Drain any pending touch states. The invariant here is that the mCurrentRawState is always @@ -1577,7 +1583,7 @@ void TouchInputMapper::processRawTouches(bool timeout) { mCurrentRawState.when = mLastRawState.when; mCurrentRawState.readTime = mLastRawState.readTime; } - cookAndDispatch(mCurrentRawState.when, mCurrentRawState.readTime); + out += cookAndDispatch(mCurrentRawState.when, mCurrentRawState.readTime); } if (count != 0) { mRawStatesPending.erase(mRawStatesPending.begin(), mRawStatesPending.begin() + count); @@ -1591,15 +1597,17 @@ void TouchInputMapper::processRawTouches(bool timeout) { ALOGD_IF(DEBUG_STYLUS_FUSION, "Timeout expired, synthesizing event with new stylus data"); const nsecs_t readTime = when; // consider this synthetic event to be zero latency - cookAndDispatch(when, readTime); + out += cookAndDispatch(when, readTime); } else if (mExternalStylusFusionTimeout == LLONG_MAX) { mExternalStylusFusionTimeout = mExternalStylusState.when + TOUCH_DATA_TIMEOUT; getContext()->requestTimeoutAtTime(mExternalStylusFusionTimeout); } } + return out; } -void TouchInputMapper::cookAndDispatch(nsecs_t when, nsecs_t readTime) { +std::list<NotifyArgs> TouchInputMapper::cookAndDispatch(nsecs_t when, nsecs_t readTime) { + std::list<NotifyArgs> out; // Always start with a clean state. mCurrentCookedState.clear(); @@ -1625,7 +1633,9 @@ void TouchInputMapper::cookAndDispatch(nsecs_t when, nsecs_t readTime) { // Consume raw off-screen touches before cooking pointer data. // If touches are consumed, subsequent code will not receive any pointer data. - if (consumeRawTouches(when, readTime, policyFlags)) { + bool consumed; + out += consumeRawTouches(when, readTime, policyFlags, consumed /*byref*/); + if (consumed) { mCurrentRawState.rawPointerData.clear(); } @@ -1638,9 +1648,9 @@ void TouchInputMapper::cookAndDispatch(nsecs_t when, nsecs_t readTime) { applyExternalStylusTouchState(when); // Synthesize key down from raw buttons if needed. - synthesizeButtonKeys(getContext(), AKEY_EVENT_ACTION_DOWN, when, readTime, getDeviceId(), - mSource, mViewport.displayId, policyFlags, mLastCookedState.buttonState, - mCurrentCookedState.buttonState); + out += synthesizeButtonKeys(getContext(), AKEY_EVENT_ACTION_DOWN, when, readTime, getDeviceId(), + mSource, mViewport.displayId, policyFlags, + mLastCookedState.buttonState, mCurrentCookedState.buttonState); // Dispatch the touches either directly or by translation through a pointer on screen. if (mDeviceMode == DeviceMode::POINTER) { @@ -1682,15 +1692,15 @@ void TouchInputMapper::cookAndDispatch(nsecs_t when, nsecs_t readTime) { pointerUsage = PointerUsage::GESTURES; } - dispatchPointerUsage(when, readTime, policyFlags, pointerUsage); + out += dispatchPointerUsage(when, readTime, policyFlags, pointerUsage); } else { if (!mCurrentMotionAborted) { updateTouchSpots(); - dispatchButtonRelease(when, readTime, policyFlags); - dispatchHoverExit(when, readTime, policyFlags); - dispatchTouches(when, readTime, policyFlags); - dispatchHoverEnterAndMove(when, readTime, policyFlags); - dispatchButtonPress(when, readTime, policyFlags); + out += dispatchButtonRelease(when, readTime, policyFlags); + out += dispatchHoverExit(when, readTime, policyFlags); + out += dispatchTouches(when, readTime, policyFlags); + out += dispatchHoverEnterAndMove(when, readTime, policyFlags); + out += dispatchButtonPress(when, readTime, policyFlags); } if (mCurrentCookedState.cookedPointerData.pointerCount == 0) { @@ -1699,9 +1709,9 @@ void TouchInputMapper::cookAndDispatch(nsecs_t when, nsecs_t readTime) { } // Synthesize key up from raw buttons if needed. - synthesizeButtonKeys(getContext(), AKEY_EVENT_ACTION_UP, when, readTime, getDeviceId(), mSource, - mViewport.displayId, policyFlags, mLastCookedState.buttonState, - mCurrentCookedState.buttonState); + out += synthesizeButtonKeys(getContext(), AKEY_EVENT_ACTION_UP, when, readTime, getDeviceId(), + mSource, mViewport.displayId, policyFlags, + mLastCookedState.buttonState, mCurrentCookedState.buttonState); // Clear some transient state. mCurrentRawState.rawVScroll = 0; @@ -1710,6 +1720,7 @@ void TouchInputMapper::cookAndDispatch(nsecs_t when, nsecs_t readTime) { // Copy current touch to last touch in preparation for the next cycle. mLastRawState.copyFrom(mCurrentRawState); mLastCookedState.copyFrom(mCurrentCookedState); + return out; } void TouchInputMapper::updateTouchSpots() { @@ -1801,34 +1812,41 @@ bool TouchInputMapper::assignExternalStylusId(const RawState& state, bool timeou return false; } -void TouchInputMapper::timeoutExpired(nsecs_t when) { +std::list<NotifyArgs> TouchInputMapper::timeoutExpired(nsecs_t when) { + std::list<NotifyArgs> out; if (mDeviceMode == DeviceMode::POINTER) { if (mPointerUsage == PointerUsage::GESTURES) { // Since this is a synthetic event, we can consider its latency to be zero const nsecs_t readTime = when; - dispatchPointerGestures(when, readTime, 0 /*policyFlags*/, true /*isTimeout*/); + out += dispatchPointerGestures(when, readTime, 0 /*policyFlags*/, true /*isTimeout*/); } } else if (mDeviceMode == DeviceMode::DIRECT) { if (mExternalStylusFusionTimeout < when) { - processRawTouches(true /*timeout*/); + out += processRawTouches(true /*timeout*/); } else if (mExternalStylusFusionTimeout != LLONG_MAX) { getContext()->requestTimeoutAtTime(mExternalStylusFusionTimeout); } } + return out; } -void TouchInputMapper::updateExternalStylusState(const StylusState& state) { +std::list<NotifyArgs> TouchInputMapper::updateExternalStylusState(const StylusState& state) { + std::list<NotifyArgs> out; mExternalStylusState.copyFrom(state); if (mExternalStylusId != -1 || mExternalStylusFusionTimeout != LLONG_MAX) { // We're either in the middle of a fused stream of data or we're waiting on data before // dispatching the initial down, so go ahead and dispatch now that we have fresh stylus // data. mExternalStylusDataPending = true; - processRawTouches(false /*timeout*/); + out += processRawTouches(false /*timeout*/); } + return out; } -bool TouchInputMapper::consumeRawTouches(nsecs_t when, nsecs_t readTime, uint32_t policyFlags) { +std::list<NotifyArgs> TouchInputMapper::consumeRawTouches(nsecs_t when, nsecs_t readTime, + uint32_t policyFlags, bool& outConsumed) { + outConsumed = false; + std::list<NotifyArgs> out; // Check for release of a virtual key. if (mCurrentVirtualKey.down) { if (mCurrentRawState.rawPointerData.touchingIdBits.isEmpty()) { @@ -1838,10 +1856,12 @@ bool TouchInputMapper::consumeRawTouches(nsecs_t when, nsecs_t readTime, uint32_ ALOGD_IF(DEBUG_VIRTUAL_KEYS, "VirtualKeys: Generating key up: keyCode=%d, scanCode=%d", mCurrentVirtualKey.keyCode, mCurrentVirtualKey.scanCode); - dispatchVirtualKey(when, readTime, policyFlags, AKEY_EVENT_ACTION_UP, - AKEY_EVENT_FLAG_FROM_SYSTEM | AKEY_EVENT_FLAG_VIRTUAL_HARD_KEY); + out.push_back(dispatchVirtualKey(when, readTime, policyFlags, AKEY_EVENT_ACTION_UP, + AKEY_EVENT_FLAG_FROM_SYSTEM | + AKEY_EVENT_FLAG_VIRTUAL_HARD_KEY)); } - return true; + outConsumed = true; + return out; } if (mCurrentRawState.rawPointerData.touchingIdBits.count() == 1) { @@ -1851,7 +1871,8 @@ bool TouchInputMapper::consumeRawTouches(nsecs_t when, nsecs_t readTime, uint32_ const VirtualKey* virtualKey = findVirtualKeyHit(pointer.x, pointer.y); if (virtualKey && virtualKey->keyCode == mCurrentVirtualKey.keyCode) { // Pointer is still within the space of the virtual key. - return true; + outConsumed = true; + return out; } } @@ -1863,9 +1884,10 @@ bool TouchInputMapper::consumeRawTouches(nsecs_t when, nsecs_t readTime, uint32_ if (!mCurrentVirtualKey.ignored) { ALOGD_IF(DEBUG_VIRTUAL_KEYS, "VirtualKeys: Canceling key: keyCode=%d, scanCode=%d", mCurrentVirtualKey.keyCode, mCurrentVirtualKey.scanCode); - dispatchVirtualKey(when, readTime, policyFlags, AKEY_EVENT_ACTION_UP, - AKEY_EVENT_FLAG_FROM_SYSTEM | AKEY_EVENT_FLAG_VIRTUAL_HARD_KEY | - AKEY_EVENT_FLAG_CANCELED); + out.push_back(dispatchVirtualKey(when, readTime, policyFlags, AKEY_EVENT_ACTION_UP, + AKEY_EVENT_FLAG_FROM_SYSTEM | + AKEY_EVENT_FLAG_VIRTUAL_HARD_KEY | + AKEY_EVENT_FLAG_CANCELED)); } } @@ -1895,13 +1917,15 @@ bool TouchInputMapper::consumeRawTouches(nsecs_t when, nsecs_t readTime, uint32_ ALOGD_IF(DEBUG_VIRTUAL_KEYS, "VirtualKeys: Generating key down: keyCode=%d, scanCode=%d", mCurrentVirtualKey.keyCode, mCurrentVirtualKey.scanCode); - dispatchVirtualKey(when, readTime, policyFlags, AKEY_EVENT_ACTION_DOWN, - AKEY_EVENT_FLAG_FROM_SYSTEM | - AKEY_EVENT_FLAG_VIRTUAL_HARD_KEY); + out.push_back(dispatchVirtualKey(when, readTime, policyFlags, + AKEY_EVENT_ACTION_DOWN, + AKEY_EVENT_FLAG_FROM_SYSTEM | + AKEY_EVENT_FLAG_VIRTUAL_HARD_KEY)); } } } - return true; + outConsumed = true; + return out; } } @@ -1923,44 +1947,50 @@ bool TouchInputMapper::consumeRawTouches(nsecs_t when, nsecs_t readTime, uint32_ !mCurrentRawState.rawPointerData.touchingIdBits.isEmpty()) { getContext()->disableVirtualKeysUntil(when + mConfig.virtualKeyQuietTime); } - return false; + return out; } -void TouchInputMapper::dispatchVirtualKey(nsecs_t when, nsecs_t readTime, uint32_t policyFlags, - int32_t keyEventAction, int32_t keyEventFlags) { +NotifyKeyArgs TouchInputMapper::dispatchVirtualKey(nsecs_t when, nsecs_t readTime, + uint32_t policyFlags, int32_t keyEventAction, + int32_t keyEventFlags) { int32_t keyCode = mCurrentVirtualKey.keyCode; int32_t scanCode = mCurrentVirtualKey.scanCode; nsecs_t downTime = mCurrentVirtualKey.downTime; int32_t metaState = getContext()->getGlobalMetaState(); policyFlags |= POLICY_FLAG_VIRTUAL; - NotifyKeyArgs args(getContext()->getNextId(), when, readTime, getDeviceId(), - AINPUT_SOURCE_KEYBOARD, mViewport.displayId, policyFlags, keyEventAction, - keyEventFlags, keyCode, scanCode, metaState, downTime); - getListener().notifyKey(&args); + return NotifyKeyArgs(getContext()->getNextId(), when, readTime, getDeviceId(), + AINPUT_SOURCE_KEYBOARD, mViewport.displayId, policyFlags, keyEventAction, + keyEventFlags, keyCode, scanCode, metaState, downTime); } -void TouchInputMapper::abortTouches(nsecs_t when, nsecs_t readTime, uint32_t policyFlags) { +std::list<NotifyArgs> TouchInputMapper::abortTouches(nsecs_t when, nsecs_t readTime, + uint32_t policyFlags) { + std::list<NotifyArgs> out; if (mCurrentMotionAborted) { // Current motion event was already aborted. - return; + return out; } BitSet32 currentIdBits = mCurrentCookedState.cookedPointerData.touchingIdBits; if (!currentIdBits.isEmpty()) { int32_t metaState = getContext()->getGlobalMetaState(); int32_t buttonState = mCurrentCookedState.buttonState; - dispatchMotion(when, readTime, policyFlags, mSource, AMOTION_EVENT_ACTION_CANCEL, 0, 0, - metaState, buttonState, AMOTION_EVENT_EDGE_FLAG_NONE, - mCurrentCookedState.cookedPointerData.pointerProperties, - mCurrentCookedState.cookedPointerData.pointerCoords, - mCurrentCookedState.cookedPointerData.idToIndex, currentIdBits, -1, - mOrientedXPrecision, mOrientedYPrecision, mDownTime, - MotionClassification::NONE); + out.push_back(dispatchMotion(when, readTime, policyFlags, mSource, + AMOTION_EVENT_ACTION_CANCEL, 0, 0, metaState, buttonState, + AMOTION_EVENT_EDGE_FLAG_NONE, + mCurrentCookedState.cookedPointerData.pointerProperties, + mCurrentCookedState.cookedPointerData.pointerCoords, + mCurrentCookedState.cookedPointerData.idToIndex, currentIdBits, + -1, mOrientedXPrecision, mOrientedYPrecision, mDownTime, + MotionClassification::NONE)); mCurrentMotionAborted = true; } + return out; } -void TouchInputMapper::dispatchTouches(nsecs_t when, nsecs_t readTime, uint32_t policyFlags) { +std::list<NotifyArgs> TouchInputMapper::dispatchTouches(nsecs_t when, nsecs_t readTime, + uint32_t policyFlags) { + std::list<NotifyArgs> out; BitSet32 currentIdBits = mCurrentCookedState.cookedPointerData.touchingIdBits; BitSet32 lastIdBits = mLastCookedState.cookedPointerData.touchingIdBits; int32_t metaState = getContext()->getGlobalMetaState(); @@ -1970,13 +2000,14 @@ void TouchInputMapper::dispatchTouches(nsecs_t when, nsecs_t readTime, uint32_t if (!currentIdBits.isEmpty()) { // No pointer id changes so this is a move event. // The listener takes care of batching moves so we don't have to deal with that here. - dispatchMotion(when, readTime, policyFlags, mSource, AMOTION_EVENT_ACTION_MOVE, 0, 0, - metaState, buttonState, AMOTION_EVENT_EDGE_FLAG_NONE, - mCurrentCookedState.cookedPointerData.pointerProperties, - mCurrentCookedState.cookedPointerData.pointerCoords, - mCurrentCookedState.cookedPointerData.idToIndex, currentIdBits, -1, - mOrientedXPrecision, mOrientedYPrecision, mDownTime, - MotionClassification::NONE); + out.push_back( + dispatchMotion(when, readTime, policyFlags, mSource, AMOTION_EVENT_ACTION_MOVE, + 0, 0, metaState, buttonState, AMOTION_EVENT_EDGE_FLAG_NONE, + mCurrentCookedState.cookedPointerData.pointerProperties, + mCurrentCookedState.cookedPointerData.pointerCoords, + mCurrentCookedState.cookedPointerData.idToIndex, currentIdBits, + -1, mOrientedXPrecision, mOrientedYPrecision, mDownTime, + MotionClassification::NONE)); } } else { // There may be pointers going up and pointers going down and pointers moving @@ -2006,13 +2037,16 @@ void TouchInputMapper::dispatchTouches(nsecs_t when, nsecs_t readTime, uint32_t if (isCanceled) { ALOGI("Canceling pointer %d for the palm event was detected.", upId); } - dispatchMotion(when, readTime, policyFlags, mSource, AMOTION_EVENT_ACTION_POINTER_UP, 0, - isCanceled ? AMOTION_EVENT_FLAG_CANCELED : 0, metaState, buttonState, 0, - mLastCookedState.cookedPointerData.pointerProperties, - mLastCookedState.cookedPointerData.pointerCoords, - mLastCookedState.cookedPointerData.idToIndex, dispatchedIdBits, upId, - mOrientedXPrecision, mOrientedYPrecision, mDownTime, - MotionClassification::NONE); + out.push_back(dispatchMotion(when, readTime, policyFlags, mSource, + AMOTION_EVENT_ACTION_POINTER_UP, 0, + isCanceled ? AMOTION_EVENT_FLAG_CANCELED : 0, metaState, + buttonState, 0, + mLastCookedState.cookedPointerData.pointerProperties, + mLastCookedState.cookedPointerData.pointerCoords, + mLastCookedState.cookedPointerData.idToIndex, + dispatchedIdBits, upId, mOrientedXPrecision, + mOrientedYPrecision, mDownTime, + MotionClassification::NONE)); dispatchedIdBits.clearBit(upId); mCurrentCookedState.cookedPointerData.canceledIdBits.clearBit(upId); } @@ -2022,13 +2056,14 @@ void TouchInputMapper::dispatchTouches(nsecs_t when, nsecs_t readTime, uint32_t // events, they do not generally handle them except when presented in a move event. if (moveNeeded && !moveIdBits.isEmpty()) { ALOG_ASSERT(moveIdBits.value == dispatchedIdBits.value); - dispatchMotion(when, readTime, policyFlags, mSource, AMOTION_EVENT_ACTION_MOVE, 0, 0, - metaState, buttonState, 0, - mCurrentCookedState.cookedPointerData.pointerProperties, - mCurrentCookedState.cookedPointerData.pointerCoords, - mCurrentCookedState.cookedPointerData.idToIndex, dispatchedIdBits, -1, - mOrientedXPrecision, mOrientedYPrecision, mDownTime, - MotionClassification::NONE); + out.push_back(dispatchMotion(when, readTime, policyFlags, mSource, + AMOTION_EVENT_ACTION_MOVE, 0, 0, metaState, buttonState, 0, + mCurrentCookedState.cookedPointerData.pointerProperties, + mCurrentCookedState.cookedPointerData.pointerCoords, + mCurrentCookedState.cookedPointerData.idToIndex, + dispatchedIdBits, -1, mOrientedXPrecision, + mOrientedYPrecision, mDownTime, + MotionClassification::NONE)); } // Dispatch pointer down events using the new pointer locations. @@ -2041,62 +2076,75 @@ void TouchInputMapper::dispatchTouches(nsecs_t when, nsecs_t readTime, uint32_t mDownTime = when; } - dispatchMotion(when, readTime, policyFlags, mSource, AMOTION_EVENT_ACTION_POINTER_DOWN, - 0, 0, metaState, buttonState, 0, - mCurrentCookedState.cookedPointerData.pointerProperties, - mCurrentCookedState.cookedPointerData.pointerCoords, - mCurrentCookedState.cookedPointerData.idToIndex, dispatchedIdBits, - downId, mOrientedXPrecision, mOrientedYPrecision, mDownTime, - MotionClassification::NONE); + out.push_back( + dispatchMotion(when, readTime, policyFlags, mSource, + AMOTION_EVENT_ACTION_POINTER_DOWN, 0, 0, metaState, buttonState, + 0, mCurrentCookedState.cookedPointerData.pointerProperties, + mCurrentCookedState.cookedPointerData.pointerCoords, + mCurrentCookedState.cookedPointerData.idToIndex, + dispatchedIdBits, downId, mOrientedXPrecision, + mOrientedYPrecision, mDownTime, MotionClassification::NONE)); } } + return out; } -void TouchInputMapper::dispatchHoverExit(nsecs_t when, nsecs_t readTime, uint32_t policyFlags) { +std::list<NotifyArgs> TouchInputMapper::dispatchHoverExit(nsecs_t when, nsecs_t readTime, + uint32_t policyFlags) { + std::list<NotifyArgs> out; if (mSentHoverEnter && (mCurrentCookedState.cookedPointerData.hoveringIdBits.isEmpty() || !mCurrentCookedState.cookedPointerData.touchingIdBits.isEmpty())) { int32_t metaState = getContext()->getGlobalMetaState(); - dispatchMotion(when, readTime, policyFlags, mSource, AMOTION_EVENT_ACTION_HOVER_EXIT, 0, 0, - metaState, mLastCookedState.buttonState, 0, - mLastCookedState.cookedPointerData.pointerProperties, - mLastCookedState.cookedPointerData.pointerCoords, - mLastCookedState.cookedPointerData.idToIndex, - mLastCookedState.cookedPointerData.hoveringIdBits, -1, mOrientedXPrecision, - mOrientedYPrecision, mDownTime, MotionClassification::NONE); + out.push_back(dispatchMotion(when, readTime, policyFlags, mSource, + AMOTION_EVENT_ACTION_HOVER_EXIT, 0, 0, metaState, + mLastCookedState.buttonState, 0, + mLastCookedState.cookedPointerData.pointerProperties, + mLastCookedState.cookedPointerData.pointerCoords, + mLastCookedState.cookedPointerData.idToIndex, + mLastCookedState.cookedPointerData.hoveringIdBits, -1, + mOrientedXPrecision, mOrientedYPrecision, mDownTime, + MotionClassification::NONE)); mSentHoverEnter = false; } + return out; } -void TouchInputMapper::dispatchHoverEnterAndMove(nsecs_t when, nsecs_t readTime, - uint32_t policyFlags) { +std::list<NotifyArgs> TouchInputMapper::dispatchHoverEnterAndMove(nsecs_t when, nsecs_t readTime, + uint32_t policyFlags) { + std::list<NotifyArgs> out; if (mCurrentCookedState.cookedPointerData.touchingIdBits.isEmpty() && !mCurrentCookedState.cookedPointerData.hoveringIdBits.isEmpty()) { int32_t metaState = getContext()->getGlobalMetaState(); if (!mSentHoverEnter) { - dispatchMotion(when, readTime, policyFlags, mSource, AMOTION_EVENT_ACTION_HOVER_ENTER, - 0, 0, metaState, mCurrentRawState.buttonState, 0, - mCurrentCookedState.cookedPointerData.pointerProperties, - mCurrentCookedState.cookedPointerData.pointerCoords, - mCurrentCookedState.cookedPointerData.idToIndex, - mCurrentCookedState.cookedPointerData.hoveringIdBits, -1, - mOrientedXPrecision, mOrientedYPrecision, mDownTime, - MotionClassification::NONE); + out.push_back(dispatchMotion(when, readTime, policyFlags, mSource, + AMOTION_EVENT_ACTION_HOVER_ENTER, 0, 0, metaState, + mCurrentRawState.buttonState, 0, + mCurrentCookedState.cookedPointerData.pointerProperties, + mCurrentCookedState.cookedPointerData.pointerCoords, + mCurrentCookedState.cookedPointerData.idToIndex, + mCurrentCookedState.cookedPointerData.hoveringIdBits, -1, + mOrientedXPrecision, mOrientedYPrecision, mDownTime, + MotionClassification::NONE)); mSentHoverEnter = true; } - dispatchMotion(when, readTime, policyFlags, mSource, AMOTION_EVENT_ACTION_HOVER_MOVE, 0, 0, - metaState, mCurrentRawState.buttonState, 0, - mCurrentCookedState.cookedPointerData.pointerProperties, - mCurrentCookedState.cookedPointerData.pointerCoords, - mCurrentCookedState.cookedPointerData.idToIndex, - mCurrentCookedState.cookedPointerData.hoveringIdBits, -1, - mOrientedXPrecision, mOrientedYPrecision, mDownTime, - MotionClassification::NONE); - } + out.push_back(dispatchMotion(when, readTime, policyFlags, mSource, + AMOTION_EVENT_ACTION_HOVER_MOVE, 0, 0, metaState, + mCurrentRawState.buttonState, 0, + mCurrentCookedState.cookedPointerData.pointerProperties, + mCurrentCookedState.cookedPointerData.pointerCoords, + mCurrentCookedState.cookedPointerData.idToIndex, + mCurrentCookedState.cookedPointerData.hoveringIdBits, -1, + mOrientedXPrecision, mOrientedYPrecision, mDownTime, + MotionClassification::NONE)); + } + return out; } -void TouchInputMapper::dispatchButtonRelease(nsecs_t when, nsecs_t readTime, uint32_t policyFlags) { +std::list<NotifyArgs> TouchInputMapper::dispatchButtonRelease(nsecs_t when, nsecs_t readTime, + uint32_t policyFlags) { + std::list<NotifyArgs> out; BitSet32 releasedButtons(mLastCookedState.buttonState & ~mCurrentCookedState.buttonState); const BitSet32& idBits = findActiveIdBits(mLastCookedState.cookedPointerData); const int32_t metaState = getContext()->getGlobalMetaState(); @@ -2104,17 +2152,21 @@ void TouchInputMapper::dispatchButtonRelease(nsecs_t when, nsecs_t readTime, uin while (!releasedButtons.isEmpty()) { int32_t actionButton = BitSet32::valueForBit(releasedButtons.clearFirstMarkedBit()); buttonState &= ~actionButton; - dispatchMotion(when, readTime, policyFlags, mSource, AMOTION_EVENT_ACTION_BUTTON_RELEASE, - actionButton, 0, metaState, buttonState, 0, - mCurrentCookedState.cookedPointerData.pointerProperties, - mCurrentCookedState.cookedPointerData.pointerCoords, - mCurrentCookedState.cookedPointerData.idToIndex, idBits, -1, - mOrientedXPrecision, mOrientedYPrecision, mDownTime, - MotionClassification::NONE); - } + out.push_back(dispatchMotion(when, readTime, policyFlags, mSource, + AMOTION_EVENT_ACTION_BUTTON_RELEASE, actionButton, 0, + metaState, buttonState, 0, + mCurrentCookedState.cookedPointerData.pointerProperties, + mCurrentCookedState.cookedPointerData.pointerCoords, + mCurrentCookedState.cookedPointerData.idToIndex, idBits, -1, + mOrientedXPrecision, mOrientedYPrecision, mDownTime, + MotionClassification::NONE)); + } + return out; } -void TouchInputMapper::dispatchButtonPress(nsecs_t when, nsecs_t readTime, uint32_t policyFlags) { +std::list<NotifyArgs> TouchInputMapper::dispatchButtonPress(nsecs_t when, nsecs_t readTime, + uint32_t policyFlags) { + std::list<NotifyArgs> out; BitSet32 pressedButtons(mCurrentCookedState.buttonState & ~mLastCookedState.buttonState); const BitSet32& idBits = findActiveIdBits(mCurrentCookedState.cookedPointerData); const int32_t metaState = getContext()->getGlobalMetaState(); @@ -2122,14 +2174,16 @@ void TouchInputMapper::dispatchButtonPress(nsecs_t when, nsecs_t readTime, uint3 while (!pressedButtons.isEmpty()) { int32_t actionButton = BitSet32::valueForBit(pressedButtons.clearFirstMarkedBit()); buttonState |= actionButton; - dispatchMotion(when, readTime, policyFlags, mSource, AMOTION_EVENT_ACTION_BUTTON_PRESS, - actionButton, 0, metaState, buttonState, 0, - mCurrentCookedState.cookedPointerData.pointerProperties, - mCurrentCookedState.cookedPointerData.pointerCoords, - mCurrentCookedState.cookedPointerData.idToIndex, idBits, -1, - mOrientedXPrecision, mOrientedYPrecision, mDownTime, - MotionClassification::NONE); - } + out.push_back(dispatchMotion(when, readTime, policyFlags, mSource, + AMOTION_EVENT_ACTION_BUTTON_PRESS, actionButton, 0, metaState, + buttonState, 0, + mCurrentCookedState.cookedPointerData.pointerProperties, + mCurrentCookedState.cookedPointerData.pointerCoords, + mCurrentCookedState.cookedPointerData.idToIndex, idBits, -1, + mOrientedXPrecision, mOrientedYPrecision, mDownTime, + MotionClassification::NONE)); + } + return out; } const BitSet32& TouchInputMapper::findActiveIdBits(const CookedPointerData& cookedPointerData) { @@ -2411,54 +2465,62 @@ void TouchInputMapper::cookPointerData() { } } -void TouchInputMapper::dispatchPointerUsage(nsecs_t when, nsecs_t readTime, uint32_t policyFlags, - PointerUsage pointerUsage) { +std::list<NotifyArgs> TouchInputMapper::dispatchPointerUsage(nsecs_t when, nsecs_t readTime, + uint32_t policyFlags, + PointerUsage pointerUsage) { + std::list<NotifyArgs> out; if (pointerUsage != mPointerUsage) { - abortPointerUsage(when, readTime, policyFlags); + out += abortPointerUsage(when, readTime, policyFlags); mPointerUsage = pointerUsage; } switch (mPointerUsage) { case PointerUsage::GESTURES: - dispatchPointerGestures(when, readTime, policyFlags, false /*isTimeout*/); + out += dispatchPointerGestures(when, readTime, policyFlags, false /*isTimeout*/); break; case PointerUsage::STYLUS: - dispatchPointerStylus(when, readTime, policyFlags); + out += dispatchPointerStylus(when, readTime, policyFlags); break; case PointerUsage::MOUSE: - dispatchPointerMouse(when, readTime, policyFlags); + out += dispatchPointerMouse(when, readTime, policyFlags); break; case PointerUsage::NONE: break; } + return out; } -void TouchInputMapper::abortPointerUsage(nsecs_t when, nsecs_t readTime, uint32_t policyFlags) { +std::list<NotifyArgs> TouchInputMapper::abortPointerUsage(nsecs_t when, nsecs_t readTime, + uint32_t policyFlags) { + std::list<NotifyArgs> out; switch (mPointerUsage) { case PointerUsage::GESTURES: - abortPointerGestures(when, readTime, policyFlags); + out += abortPointerGestures(when, readTime, policyFlags); break; case PointerUsage::STYLUS: - abortPointerStylus(when, readTime, policyFlags); + out += abortPointerStylus(when, readTime, policyFlags); break; case PointerUsage::MOUSE: - abortPointerMouse(when, readTime, policyFlags); + out += abortPointerMouse(when, readTime, policyFlags); break; case PointerUsage::NONE: break; } mPointerUsage = PointerUsage::NONE; + return out; } -void TouchInputMapper::dispatchPointerGestures(nsecs_t when, nsecs_t readTime, uint32_t policyFlags, - bool isTimeout) { +std::list<NotifyArgs> TouchInputMapper::dispatchPointerGestures(nsecs_t when, nsecs_t readTime, + uint32_t policyFlags, + bool isTimeout) { + std::list<NotifyArgs> out; // Update current gesture coordinates. bool cancelPreviousGesture, finishPreviousGesture; bool sendEvents = preparePointerGestures(when, &cancelPreviousGesture, &finishPreviousGesture, isTimeout); if (!sendEvents) { - return; + return {}; } if (finishPreviousGesture) { cancelPreviousGesture = false; @@ -2555,11 +2617,14 @@ void TouchInputMapper::dispatchPointerGestures(nsecs_t when, nsecs_t readTime, u BitSet32 dispatchedGestureIdBits(mPointerGesture.lastGestureIdBits); if (!dispatchedGestureIdBits.isEmpty()) { if (cancelPreviousGesture) { - dispatchMotion(when, readTime, policyFlags, mSource, AMOTION_EVENT_ACTION_CANCEL, 0, - flags, metaState, buttonState, AMOTION_EVENT_EDGE_FLAG_NONE, - mPointerGesture.lastGestureProperties, mPointerGesture.lastGestureCoords, - mPointerGesture.lastGestureIdToIndex, dispatchedGestureIdBits, -1, 0, 0, - mPointerGesture.downTime, classification); + out.push_back(dispatchMotion(when, readTime, policyFlags, mSource, + AMOTION_EVENT_ACTION_CANCEL, 0, flags, metaState, + buttonState, AMOTION_EVENT_EDGE_FLAG_NONE, + mPointerGesture.lastGestureProperties, + mPointerGesture.lastGestureCoords, + mPointerGesture.lastGestureIdToIndex, + dispatchedGestureIdBits, -1, 0, 0, + mPointerGesture.downTime, classification)); dispatchedGestureIdBits.clear(); } else { @@ -2573,12 +2638,14 @@ void TouchInputMapper::dispatchPointerGestures(nsecs_t when, nsecs_t readTime, u while (!upGestureIdBits.isEmpty()) { uint32_t id = upGestureIdBits.clearFirstMarkedBit(); - dispatchMotion(when, readTime, policyFlags, mSource, - AMOTION_EVENT_ACTION_POINTER_UP, 0, flags, metaState, buttonState, - AMOTION_EVENT_EDGE_FLAG_NONE, mPointerGesture.lastGestureProperties, - mPointerGesture.lastGestureCoords, - mPointerGesture.lastGestureIdToIndex, dispatchedGestureIdBits, id, 0, - 0, mPointerGesture.downTime, classification); + out.push_back(dispatchMotion(when, readTime, policyFlags, mSource, + AMOTION_EVENT_ACTION_POINTER_UP, 0, flags, metaState, + buttonState, AMOTION_EVENT_EDGE_FLAG_NONE, + mPointerGesture.lastGestureProperties, + mPointerGesture.lastGestureCoords, + mPointerGesture.lastGestureIdToIndex, + dispatchedGestureIdBits, id, 0, 0, + mPointerGesture.downTime, classification)); dispatchedGestureIdBits.clearBit(id); } @@ -2587,12 +2654,13 @@ void TouchInputMapper::dispatchPointerGestures(nsecs_t when, nsecs_t readTime, u // Send motion events for all pointers that moved. if (moveNeeded) { - dispatchMotion(when, readTime, policyFlags, mSource, AMOTION_EVENT_ACTION_MOVE, 0, flags, - metaState, buttonState, AMOTION_EVENT_EDGE_FLAG_NONE, - mPointerGesture.currentGestureProperties, - mPointerGesture.currentGestureCoords, - mPointerGesture.currentGestureIdToIndex, dispatchedGestureIdBits, -1, 0, 0, - mPointerGesture.downTime, classification); + out.push_back( + dispatchMotion(when, readTime, policyFlags, mSource, AMOTION_EVENT_ACTION_MOVE, 0, + flags, metaState, buttonState, AMOTION_EVENT_EDGE_FLAG_NONE, + mPointerGesture.currentGestureProperties, + mPointerGesture.currentGestureCoords, + mPointerGesture.currentGestureIdToIndex, dispatchedGestureIdBits, -1, + 0, 0, mPointerGesture.downTime, classification)); } // Send motion events for all pointers that went down. @@ -2607,24 +2675,26 @@ void TouchInputMapper::dispatchPointerGestures(nsecs_t when, nsecs_t readTime, u mPointerGesture.downTime = when; } - dispatchMotion(when, readTime, policyFlags, mSource, AMOTION_EVENT_ACTION_POINTER_DOWN, - 0, flags, metaState, buttonState, 0, - mPointerGesture.currentGestureProperties, - mPointerGesture.currentGestureCoords, - mPointerGesture.currentGestureIdToIndex, dispatchedGestureIdBits, id, 0, - 0, mPointerGesture.downTime, classification); + out.push_back(dispatchMotion(when, readTime, policyFlags, mSource, + AMOTION_EVENT_ACTION_POINTER_DOWN, 0, flags, metaState, + buttonState, 0, mPointerGesture.currentGestureProperties, + mPointerGesture.currentGestureCoords, + mPointerGesture.currentGestureIdToIndex, + dispatchedGestureIdBits, id, 0, 0, + mPointerGesture.downTime, classification)); } } // Send motion events for hover. if (mPointerGesture.currentGestureMode == PointerGesture::Mode::HOVER) { - dispatchMotion(when, readTime, policyFlags, mSource, AMOTION_EVENT_ACTION_HOVER_MOVE, 0, - flags, metaState, buttonState, AMOTION_EVENT_EDGE_FLAG_NONE, - mPointerGesture.currentGestureProperties, - mPointerGesture.currentGestureCoords, - mPointerGesture.currentGestureIdToIndex, - mPointerGesture.currentGestureIdBits, -1, 0, 0, mPointerGesture.downTime, - MotionClassification::NONE); + out.push_back(dispatchMotion(when, readTime, policyFlags, mSource, + AMOTION_EVENT_ACTION_HOVER_MOVE, 0, flags, metaState, + buttonState, AMOTION_EVENT_EDGE_FLAG_NONE, + mPointerGesture.currentGestureProperties, + mPointerGesture.currentGestureCoords, + mPointerGesture.currentGestureIdToIndex, + mPointerGesture.currentGestureIdBits, -1, 0, 0, + mPointerGesture.downTime, MotionClassification::NONE)); } else if (dispatchedGestureIdBits.isEmpty() && !mPointerGesture.lastGestureIdBits.isEmpty()) { // Synthesize a hover move event after all pointers go up to indicate that // the pointer is hovering again even if the user is not currently touching @@ -2644,12 +2714,13 @@ void TouchInputMapper::dispatchPointerGestures(nsecs_t when, nsecs_t readTime, u pointerCoords.setAxisValue(AMOTION_EVENT_AXIS_Y, y); const int32_t displayId = mPointerController->getDisplayId(); - NotifyMotionArgs args(getContext()->getNextId(), when, readTime, getDeviceId(), mSource, - displayId, policyFlags, AMOTION_EVENT_ACTION_HOVER_MOVE, 0, flags, - metaState, buttonState, MotionClassification::NONE, - AMOTION_EVENT_EDGE_FLAG_NONE, 1, &pointerProperties, &pointerCoords, - 0, 0, x, y, mPointerGesture.downTime, /* videoFrames */ {}); - getListener().notifyMotion(&args); + out.push_back(NotifyMotionArgs(getContext()->getNextId(), when, readTime, getDeviceId(), + mSource, displayId, policyFlags, + AMOTION_EVENT_ACTION_HOVER_MOVE, 0, flags, metaState, + buttonState, MotionClassification::NONE, + AMOTION_EVENT_EDGE_FLAG_NONE, 1, &pointerProperties, + &pointerCoords, 0, 0, x, y, mPointerGesture.downTime, + /* videoFrames */ {})); } // Update state. @@ -2668,22 +2739,28 @@ void TouchInputMapper::dispatchPointerGestures(nsecs_t when, nsecs_t readTime, u mPointerGesture.lastGestureIdToIndex[id] = index; } } + return out; } -void TouchInputMapper::abortPointerGestures(nsecs_t when, nsecs_t readTime, uint32_t policyFlags) { +std::list<NotifyArgs> TouchInputMapper::abortPointerGestures(nsecs_t when, nsecs_t readTime, + uint32_t policyFlags) { const MotionClassification classification = mPointerGesture.lastGestureMode == PointerGesture::Mode::SWIPE ? MotionClassification::TWO_FINGER_SWIPE : MotionClassification::NONE; + std::list<NotifyArgs> out; // Cancel previously dispatches pointers. if (!mPointerGesture.lastGestureIdBits.isEmpty()) { int32_t metaState = getContext()->getGlobalMetaState(); int32_t buttonState = mCurrentRawState.buttonState; - dispatchMotion(when, readTime, policyFlags, mSource, AMOTION_EVENT_ACTION_CANCEL, 0, 0, - metaState, buttonState, AMOTION_EVENT_EDGE_FLAG_NONE, - mPointerGesture.lastGestureProperties, mPointerGesture.lastGestureCoords, - mPointerGesture.lastGestureIdToIndex, mPointerGesture.lastGestureIdBits, -1, - 0, 0, mPointerGesture.downTime, classification); + out.push_back(dispatchMotion(when, readTime, policyFlags, mSource, + AMOTION_EVENT_ACTION_CANCEL, 0, 0, metaState, buttonState, + AMOTION_EVENT_EDGE_FLAG_NONE, + mPointerGesture.lastGestureProperties, + mPointerGesture.lastGestureCoords, + mPointerGesture.lastGestureIdToIndex, + mPointerGesture.lastGestureIdBits, -1, 0, 0, + mPointerGesture.downTime, classification)); } // Reset the current pointer gesture. @@ -2695,6 +2772,7 @@ void TouchInputMapper::abortPointerGestures(nsecs_t when, nsecs_t readTime, uint mPointerController->fade(PointerControllerInterface::Transition::GRADUAL); mPointerController->clearSpots(); } + return out; } bool TouchInputMapper::preparePointerGestures(nsecs_t when, bool* outCancelPreviousGesture, @@ -3411,7 +3489,8 @@ void TouchInputMapper::moveMousePointerFromPointerDelta(nsecs_t when, uint32_t p mPointerController->move(deltaX, deltaY); } -void TouchInputMapper::dispatchPointerStylus(nsecs_t when, nsecs_t readTime, uint32_t policyFlags) { +std::list<NotifyArgs> TouchInputMapper::dispatchPointerStylus(nsecs_t when, nsecs_t readTime, + uint32_t policyFlags) { mPointerSimple.currentCoords.clear(); mPointerSimple.currentProperties.clear(); @@ -3440,14 +3519,16 @@ void TouchInputMapper::dispatchPointerStylus(nsecs_t when, nsecs_t readTime, uin hovering = false; } - dispatchPointerSimple(when, readTime, policyFlags, down, hovering); + return dispatchPointerSimple(when, readTime, policyFlags, down, hovering); } -void TouchInputMapper::abortPointerStylus(nsecs_t when, nsecs_t readTime, uint32_t policyFlags) { - abortPointerSimple(when, readTime, policyFlags); +std::list<NotifyArgs> TouchInputMapper::abortPointerStylus(nsecs_t when, nsecs_t readTime, + uint32_t policyFlags) { + return abortPointerSimple(when, readTime, policyFlags); } -void TouchInputMapper::dispatchPointerMouse(nsecs_t when, nsecs_t readTime, uint32_t policyFlags) { +std::list<NotifyArgs> TouchInputMapper::dispatchPointerMouse(nsecs_t when, nsecs_t readTime, + uint32_t policyFlags) { mPointerSimple.currentCoords.clear(); mPointerSimple.currentProperties.clear(); @@ -3482,17 +3563,22 @@ void TouchInputMapper::dispatchPointerMouse(nsecs_t when, nsecs_t readTime, uint hovering = false; } - dispatchPointerSimple(when, readTime, policyFlags, down, hovering); + return dispatchPointerSimple(when, readTime, policyFlags, down, hovering); } -void TouchInputMapper::abortPointerMouse(nsecs_t when, nsecs_t readTime, uint32_t policyFlags) { - abortPointerSimple(when, readTime, policyFlags); +std::list<NotifyArgs> TouchInputMapper::abortPointerMouse(nsecs_t when, nsecs_t readTime, + uint32_t policyFlags) { + std::list<NotifyArgs> out = abortPointerSimple(when, readTime, policyFlags); mPointerVelocityControl.reset(); + + return out; } -void TouchInputMapper::dispatchPointerSimple(nsecs_t when, nsecs_t readTime, uint32_t policyFlags, - bool down, bool hovering) { +std::list<NotifyArgs> TouchInputMapper::dispatchPointerSimple(nsecs_t when, nsecs_t readTime, + uint32_t policyFlags, bool down, + bool hovering) { + std::list<NotifyArgs> out; int32_t metaState = getContext()->getGlobalMetaState(); if (down || hovering) { @@ -3512,28 +3598,29 @@ void TouchInputMapper::dispatchPointerSimple(nsecs_t when, nsecs_t readTime, uin mPointerSimple.down = false; // Send up. - NotifyMotionArgs args(getContext()->getNextId(), when, readTime, getDeviceId(), mSource, - displayId, policyFlags, AMOTION_EVENT_ACTION_UP, 0, 0, metaState, - mLastRawState.buttonState, MotionClassification::NONE, - AMOTION_EVENT_EDGE_FLAG_NONE, 1, &mPointerSimple.lastProperties, - &mPointerSimple.lastCoords, mOrientedXPrecision, mOrientedYPrecision, - xCursorPosition, yCursorPosition, mPointerSimple.downTime, - /* videoFrames */ {}); - getListener().notifyMotion(&args); + out.push_back(NotifyMotionArgs(getContext()->getNextId(), when, readTime, getDeviceId(), + mSource, displayId, policyFlags, AMOTION_EVENT_ACTION_UP, 0, + 0, metaState, mLastRawState.buttonState, + MotionClassification::NONE, AMOTION_EVENT_EDGE_FLAG_NONE, 1, + &mPointerSimple.lastProperties, &mPointerSimple.lastCoords, + mOrientedXPrecision, mOrientedYPrecision, xCursorPosition, + yCursorPosition, mPointerSimple.downTime, + /* videoFrames */ {})); } if (mPointerSimple.hovering && !hovering) { mPointerSimple.hovering = false; // Send hover exit. - NotifyMotionArgs args(getContext()->getNextId(), when, readTime, getDeviceId(), mSource, - displayId, policyFlags, AMOTION_EVENT_ACTION_HOVER_EXIT, 0, 0, - metaState, mLastRawState.buttonState, MotionClassification::NONE, - AMOTION_EVENT_EDGE_FLAG_NONE, 1, &mPointerSimple.lastProperties, - &mPointerSimple.lastCoords, mOrientedXPrecision, mOrientedYPrecision, - xCursorPosition, yCursorPosition, mPointerSimple.downTime, - /* videoFrames */ {}); - getListener().notifyMotion(&args); + out.push_back(NotifyMotionArgs(getContext()->getNextId(), when, readTime, getDeviceId(), + mSource, displayId, policyFlags, + AMOTION_EVENT_ACTION_HOVER_EXIT, 0, 0, metaState, + mLastRawState.buttonState, MotionClassification::NONE, + AMOTION_EVENT_EDGE_FLAG_NONE, 1, + &mPointerSimple.lastProperties, &mPointerSimple.lastCoords, + mOrientedXPrecision, mOrientedYPrecision, xCursorPosition, + yCursorPosition, mPointerSimple.downTime, + /* videoFrames */ {})); } if (down) { @@ -3542,25 +3629,26 @@ void TouchInputMapper::dispatchPointerSimple(nsecs_t when, nsecs_t readTime, uin mPointerSimple.downTime = when; // Send down. - NotifyMotionArgs args(getContext()->getNextId(), when, readTime, getDeviceId(), mSource, - displayId, policyFlags, AMOTION_EVENT_ACTION_DOWN, 0, 0, - metaState, mCurrentRawState.buttonState, - MotionClassification::NONE, AMOTION_EVENT_EDGE_FLAG_NONE, 1, - &mPointerSimple.currentProperties, &mPointerSimple.currentCoords, - mOrientedXPrecision, mOrientedYPrecision, xCursorPosition, - yCursorPosition, mPointerSimple.downTime, /* videoFrames */ {}); - getListener().notifyMotion(&args); + out.push_back(NotifyMotionArgs(getContext()->getNextId(), when, readTime, getDeviceId(), + mSource, displayId, policyFlags, + AMOTION_EVENT_ACTION_DOWN, 0, 0, metaState, + mCurrentRawState.buttonState, MotionClassification::NONE, + AMOTION_EVENT_EDGE_FLAG_NONE, 1, + &mPointerSimple.currentProperties, + &mPointerSimple.currentCoords, mOrientedXPrecision, + mOrientedYPrecision, xCursorPosition, yCursorPosition, + mPointerSimple.downTime, /* videoFrames */ {})); } // Send move. - NotifyMotionArgs args(getContext()->getNextId(), when, readTime, getDeviceId(), mSource, - displayId, policyFlags, AMOTION_EVENT_ACTION_MOVE, 0, 0, metaState, - mCurrentRawState.buttonState, MotionClassification::NONE, - AMOTION_EVENT_EDGE_FLAG_NONE, 1, &mPointerSimple.currentProperties, - &mPointerSimple.currentCoords, mOrientedXPrecision, - mOrientedYPrecision, xCursorPosition, yCursorPosition, - mPointerSimple.downTime, /* videoFrames */ {}); - getListener().notifyMotion(&args); + out.push_back(NotifyMotionArgs(getContext()->getNextId(), when, readTime, getDeviceId(), + mSource, displayId, policyFlags, AMOTION_EVENT_ACTION_MOVE, + 0, 0, metaState, mCurrentRawState.buttonState, + MotionClassification::NONE, AMOTION_EVENT_EDGE_FLAG_NONE, 1, + &mPointerSimple.currentProperties, + &mPointerSimple.currentCoords, mOrientedXPrecision, + mOrientedYPrecision, xCursorPosition, yCursorPosition, + mPointerSimple.downTime, /* videoFrames */ {})); } if (hovering) { @@ -3568,25 +3656,26 @@ void TouchInputMapper::dispatchPointerSimple(nsecs_t when, nsecs_t readTime, uin mPointerSimple.hovering = true; // Send hover enter. - NotifyMotionArgs args(getContext()->getNextId(), when, readTime, getDeviceId(), mSource, - displayId, policyFlags, AMOTION_EVENT_ACTION_HOVER_ENTER, 0, 0, - metaState, mCurrentRawState.buttonState, - MotionClassification::NONE, AMOTION_EVENT_EDGE_FLAG_NONE, 1, - &mPointerSimple.currentProperties, &mPointerSimple.currentCoords, - mOrientedXPrecision, mOrientedYPrecision, xCursorPosition, - yCursorPosition, mPointerSimple.downTime, /* videoFrames */ {}); - getListener().notifyMotion(&args); + out.push_back(NotifyMotionArgs(getContext()->getNextId(), when, readTime, getDeviceId(), + mSource, displayId, policyFlags, + AMOTION_EVENT_ACTION_HOVER_ENTER, 0, 0, metaState, + mCurrentRawState.buttonState, MotionClassification::NONE, + AMOTION_EVENT_EDGE_FLAG_NONE, 1, + &mPointerSimple.currentProperties, + &mPointerSimple.currentCoords, mOrientedXPrecision, + mOrientedYPrecision, xCursorPosition, yCursorPosition, + mPointerSimple.downTime, /* videoFrames */ {})); } // Send hover move. - NotifyMotionArgs args(getContext()->getNextId(), when, readTime, getDeviceId(), mSource, - displayId, policyFlags, AMOTION_EVENT_ACTION_HOVER_MOVE, 0, 0, - metaState, mCurrentRawState.buttonState, MotionClassification::NONE, - AMOTION_EVENT_EDGE_FLAG_NONE, 1, &mPointerSimple.currentProperties, - &mPointerSimple.currentCoords, mOrientedXPrecision, - mOrientedYPrecision, xCursorPosition, yCursorPosition, - mPointerSimple.downTime, /* videoFrames */ {}); - getListener().notifyMotion(&args); + out.push_back( + NotifyMotionArgs(getContext()->getNextId(), when, readTime, getDeviceId(), mSource, + displayId, policyFlags, AMOTION_EVENT_ACTION_HOVER_MOVE, 0, 0, + metaState, mCurrentRawState.buttonState, + MotionClassification::NONE, AMOTION_EVENT_EDGE_FLAG_NONE, 1, + &mPointerSimple.currentProperties, &mPointerSimple.currentCoords, + mOrientedXPrecision, mOrientedYPrecision, xCursorPosition, + yCursorPosition, mPointerSimple.downTime, /* videoFrames */ {})); } if (mCurrentRawState.rawVScroll || mCurrentRawState.rawHScroll) { @@ -3601,14 +3690,14 @@ void TouchInputMapper::dispatchPointerSimple(nsecs_t when, nsecs_t readTime, uin pointerCoords.setAxisValue(AMOTION_EVENT_AXIS_VSCROLL, vscroll); pointerCoords.setAxisValue(AMOTION_EVENT_AXIS_HSCROLL, hscroll); - NotifyMotionArgs args(getContext()->getNextId(), when, readTime, getDeviceId(), mSource, - displayId, policyFlags, AMOTION_EVENT_ACTION_SCROLL, 0, 0, metaState, - mCurrentRawState.buttonState, MotionClassification::NONE, - AMOTION_EVENT_EDGE_FLAG_NONE, 1, &mPointerSimple.currentProperties, - &pointerCoords, mOrientedXPrecision, mOrientedYPrecision, - xCursorPosition, yCursorPosition, mPointerSimple.downTime, - /* videoFrames */ {}); - getListener().notifyMotion(&args); + out.push_back(NotifyMotionArgs(getContext()->getNextId(), when, readTime, getDeviceId(), + mSource, displayId, policyFlags, AMOTION_EVENT_ACTION_SCROLL, + 0, 0, metaState, mCurrentRawState.buttonState, + MotionClassification::NONE, AMOTION_EVENT_EDGE_FLAG_NONE, 1, + &mPointerSimple.currentProperties, &pointerCoords, + mOrientedXPrecision, mOrientedYPrecision, xCursorPosition, + yCursorPosition, mPointerSimple.downTime, + /* videoFrames */ {})); } // Save state. @@ -3618,23 +3707,23 @@ void TouchInputMapper::dispatchPointerSimple(nsecs_t when, nsecs_t readTime, uin } else { mPointerSimple.reset(); } + return out; } -void TouchInputMapper::abortPointerSimple(nsecs_t when, nsecs_t readTime, uint32_t policyFlags) { +std::list<NotifyArgs> TouchInputMapper::abortPointerSimple(nsecs_t when, nsecs_t readTime, + uint32_t policyFlags) { mPointerSimple.currentCoords.clear(); mPointerSimple.currentProperties.clear(); - dispatchPointerSimple(when, readTime, policyFlags, false, false); + return dispatchPointerSimple(when, readTime, policyFlags, false, false); } -void TouchInputMapper::dispatchMotion(nsecs_t when, nsecs_t readTime, uint32_t policyFlags, - uint32_t source, int32_t action, int32_t actionButton, - int32_t flags, int32_t metaState, int32_t buttonState, - int32_t edgeFlags, const PointerProperties* properties, - const PointerCoords* coords, const uint32_t* idToIndex, - BitSet32 idBits, int32_t changedId, float xPrecision, - float yPrecision, nsecs_t downTime, - MotionClassification classification) { +NotifyMotionArgs TouchInputMapper::dispatchMotion( + nsecs_t when, nsecs_t readTime, uint32_t policyFlags, uint32_t source, int32_t action, + int32_t actionButton, int32_t flags, int32_t metaState, int32_t buttonState, + int32_t edgeFlags, const PointerProperties* properties, const PointerCoords* coords, + const uint32_t* idToIndex, BitSet32 idBits, int32_t changedId, float xPrecision, + float yPrecision, nsecs_t downTime, MotionClassification classification) { PointerCoords pointerCoords[MAX_POINTERS]; PointerProperties pointerProperties[MAX_POINTERS]; uint32_t pointerCount = 0; @@ -3680,12 +3769,11 @@ void TouchInputMapper::dispatchMotion(nsecs_t when, nsecs_t readTime, uint32_t p std::vector<TouchVideoFrame> frames = getDeviceContext().getVideoFrames(); std::for_each(frames.begin(), frames.end(), [this](TouchVideoFrame& frame) { frame.rotate(this->mInputDeviceOrientation); }); - NotifyMotionArgs args(getContext()->getNextId(), when, readTime, deviceId, source, displayId, - policyFlags, action, actionButton, flags, metaState, buttonState, - classification, edgeFlags, pointerCount, pointerProperties, pointerCoords, - xPrecision, yPrecision, xCursorPosition, yCursorPosition, downTime, - std::move(frames)); - getListener().notifyMotion(&args); + return NotifyMotionArgs(getContext()->getNextId(), when, readTime, deviceId, source, displayId, + policyFlags, action, actionButton, flags, metaState, buttonState, + classification, edgeFlags, pointerCount, pointerProperties, + pointerCoords, xPrecision, yPrecision, xCursorPosition, yCursorPosition, + downTime, std::move(frames)); } bool TouchInputMapper::updateMovedPointers(const PointerProperties* inProperties, @@ -3718,9 +3806,11 @@ bool TouchInputMapper::updateMovedPointers(const PointerProperties* inProperties return changed; } -void TouchInputMapper::cancelTouch(nsecs_t when, nsecs_t readTime) { - abortPointerUsage(when, readTime, 0 /*policyFlags*/); - abortTouches(when, readTime, 0 /* policyFlags*/); +std::list<NotifyArgs> TouchInputMapper::cancelTouch(nsecs_t when, nsecs_t readTime) { + std::list<NotifyArgs> out; + out += abortPointerUsage(when, readTime, 0 /*policyFlags*/); + out += abortTouches(when, readTime, 0 /* policyFlags*/); + return out; } // Transform input device coordinates to display panel coordinates. diff --git a/services/inputflinger/reader/mapper/TouchInputMapper.h b/services/inputflinger/reader/mapper/TouchInputMapper.h index 76fdf5dcee..50f30c824e 100644 --- a/services/inputflinger/reader/mapper/TouchInputMapper.h +++ b/services/inputflinger/reader/mapper/TouchInputMapper.h @@ -140,18 +140,21 @@ public: uint32_t getSources() const override; void populateDeviceInfo(InputDeviceInfo* deviceInfo) override; void dump(std::string& dump) override; - void configure(nsecs_t when, const InputReaderConfiguration* config, uint32_t changes) override; - void reset(nsecs_t when) override; - void process(const RawEvent* rawEvent) override; + [[nodiscard]] std::list<NotifyArgs> configure(nsecs_t when, + const InputReaderConfiguration* config, + uint32_t changes) override; + [[nodiscard]] std::list<NotifyArgs> reset(nsecs_t when) override; + [[nodiscard]] std::list<NotifyArgs> process(const RawEvent* rawEvent) override; int32_t getKeyCodeState(uint32_t sourceMask, int32_t keyCode) override; int32_t getScanCodeState(uint32_t sourceMask, int32_t scanCode) override; bool markSupportedKeyCodes(uint32_t sourceMask, const std::vector<int32_t>& keyCodes, uint8_t* outFlags) override; - void cancelTouch(nsecs_t when, nsecs_t readTime) override; - void timeoutExpired(nsecs_t when) override; - void updateExternalStylusState(const StylusState& state) override; + [[nodiscard]] std::list<NotifyArgs> cancelTouch(nsecs_t when, nsecs_t readTime) override; + [[nodiscard]] std::list<NotifyArgs> timeoutExpired(nsecs_t when) override; + [[nodiscard]] std::list<NotifyArgs> updateExternalStylusState( + const StylusState& state) override; std::optional<int32_t> getAssociatedDisplayId() override; protected: @@ -728,30 +731,42 @@ private: void initializeOrientedRanges(); void initializeSizeRanges(); - void sync(nsecs_t when, nsecs_t readTime); - - bool consumeRawTouches(nsecs_t when, nsecs_t readTime, uint32_t policyFlags); - void processRawTouches(bool timeout); - void cookAndDispatch(nsecs_t when, nsecs_t readTime); - void dispatchVirtualKey(nsecs_t when, nsecs_t readTime, uint32_t policyFlags, - int32_t keyEventAction, int32_t keyEventFlags); - - void dispatchTouches(nsecs_t when, nsecs_t readTime, uint32_t policyFlags); - void dispatchHoverExit(nsecs_t when, nsecs_t readTime, uint32_t policyFlags); - void dispatchHoverEnterAndMove(nsecs_t when, nsecs_t readTime, uint32_t policyFlags); - void dispatchButtonRelease(nsecs_t when, nsecs_t readTime, uint32_t policyFlags); - void dispatchButtonPress(nsecs_t when, nsecs_t readTime, uint32_t policyFlags); + [[nodiscard]] std::list<NotifyArgs> sync(nsecs_t when, nsecs_t readTime); + + [[nodiscard]] std::list<NotifyArgs> consumeRawTouches(nsecs_t when, nsecs_t readTime, + uint32_t policyFlags, bool& outConsumed); + [[nodiscard]] std::list<NotifyArgs> processRawTouches(bool timeout); + [[nodiscard]] std::list<NotifyArgs> cookAndDispatch(nsecs_t when, nsecs_t readTime); + [[nodiscard]] NotifyKeyArgs dispatchVirtualKey(nsecs_t when, nsecs_t readTime, + uint32_t policyFlags, int32_t keyEventAction, + int32_t keyEventFlags); + + [[nodiscard]] std::list<NotifyArgs> dispatchTouches(nsecs_t when, nsecs_t readTime, + uint32_t policyFlags); + [[nodiscard]] std::list<NotifyArgs> dispatchHoverExit(nsecs_t when, nsecs_t readTime, + uint32_t policyFlags); + [[nodiscard]] std::list<NotifyArgs> dispatchHoverEnterAndMove(nsecs_t when, nsecs_t readTime, + uint32_t policyFlags); + [[nodiscard]] std::list<NotifyArgs> dispatchButtonRelease(nsecs_t when, nsecs_t readTime, + uint32_t policyFlags); + [[nodiscard]] std::list<NotifyArgs> dispatchButtonPress(nsecs_t when, nsecs_t readTime, + uint32_t policyFlags); const BitSet32& findActiveIdBits(const CookedPointerData& cookedPointerData); void cookPointerData(); - void abortTouches(nsecs_t when, nsecs_t readTime, uint32_t policyFlags); - - void dispatchPointerUsage(nsecs_t when, nsecs_t readTime, uint32_t policyFlags, - PointerUsage pointerUsage); - void abortPointerUsage(nsecs_t when, nsecs_t readTime, uint32_t policyFlags); - - void dispatchPointerGestures(nsecs_t when, nsecs_t readTime, uint32_t policyFlags, - bool isTimeout); - void abortPointerGestures(nsecs_t when, nsecs_t readTime, uint32_t policyFlags); + [[nodiscard]] std::list<NotifyArgs> abortTouches(nsecs_t when, nsecs_t readTime, + uint32_t policyFlags); + + [[nodiscard]] std::list<NotifyArgs> dispatchPointerUsage(nsecs_t when, nsecs_t readTime, + uint32_t policyFlags, + PointerUsage pointerUsage); + [[nodiscard]] std::list<NotifyArgs> abortPointerUsage(nsecs_t when, nsecs_t readTime, + uint32_t policyFlags); + + [[nodiscard]] std::list<NotifyArgs> dispatchPointerGestures(nsecs_t when, nsecs_t readTime, + uint32_t policyFlags, + bool isTimeout); + [[nodiscard]] std::list<NotifyArgs> abortPointerGestures(nsecs_t when, nsecs_t readTime, + uint32_t policyFlags); bool preparePointerGestures(nsecs_t when, bool* outCancelPreviousGesture, bool* outFinishPreviousGesture, bool isTimeout); @@ -759,15 +774,21 @@ private: // between the last and current events. Uses a relative motion. void moveMousePointerFromPointerDelta(nsecs_t when, uint32_t pointerId); - void dispatchPointerStylus(nsecs_t when, nsecs_t readTime, uint32_t policyFlags); - void abortPointerStylus(nsecs_t when, nsecs_t readTime, uint32_t policyFlags); + [[nodiscard]] std::list<NotifyArgs> dispatchPointerStylus(nsecs_t when, nsecs_t readTime, + uint32_t policyFlags); + [[nodiscard]] std::list<NotifyArgs> abortPointerStylus(nsecs_t when, nsecs_t readTime, + uint32_t policyFlags); - void dispatchPointerMouse(nsecs_t when, nsecs_t readTime, uint32_t policyFlags); - void abortPointerMouse(nsecs_t when, nsecs_t readTime, uint32_t policyFlags); + [[nodiscard]] std::list<NotifyArgs> dispatchPointerMouse(nsecs_t when, nsecs_t readTime, + uint32_t policyFlags); + [[nodiscard]] std::list<NotifyArgs> abortPointerMouse(nsecs_t when, nsecs_t readTime, + uint32_t policyFlags); - void dispatchPointerSimple(nsecs_t when, nsecs_t readTime, uint32_t policyFlags, bool down, - bool hovering); - void abortPointerSimple(nsecs_t when, nsecs_t readTime, uint32_t policyFlags); + [[nodiscard]] std::list<NotifyArgs> dispatchPointerSimple(nsecs_t when, nsecs_t readTime, + uint32_t policyFlags, bool down, + bool hovering); + [[nodiscard]] std::list<NotifyArgs> abortPointerSimple(nsecs_t when, nsecs_t readTime, + uint32_t policyFlags); bool assignExternalStylusId(const RawState& state, bool timeout); void applyExternalStylusButtonState(nsecs_t when); @@ -777,12 +798,12 @@ private: // If the changedId is >= 0 and the action is POINTER_DOWN or POINTER_UP, the // method will take care of setting the index and transmuting the action to DOWN or UP // it is the first / last pointer to go down / up. - void dispatchMotion(nsecs_t when, nsecs_t readTime, uint32_t policyFlags, uint32_t source, - int32_t action, int32_t actionButton, int32_t flags, int32_t metaState, - int32_t buttonState, int32_t edgeFlags, const PointerProperties* properties, - const PointerCoords* coords, const uint32_t* idToIndex, BitSet32 idBits, - int32_t changedId, float xPrecision, float yPrecision, nsecs_t downTime, - MotionClassification classification); + [[nodiscard]] NotifyMotionArgs dispatchMotion( + nsecs_t when, nsecs_t readTime, uint32_t policyFlags, uint32_t source, int32_t action, + int32_t actionButton, int32_t flags, int32_t metaState, int32_t buttonState, + int32_t edgeFlags, const PointerProperties* properties, const PointerCoords* coords, + const uint32_t* idToIndex, BitSet32 idBits, int32_t changedId, float xPrecision, + float yPrecision, nsecs_t downTime, MotionClassification classification); // Updates pointer coords and properties for pointers with specified ids that have moved. // Returns true if any of them changed. diff --git a/services/inputflinger/reader/mapper/VibratorInputMapper.cpp b/services/inputflinger/reader/mapper/VibratorInputMapper.cpp index 33db527db1..7645b12f1b 100644 --- a/services/inputflinger/reader/mapper/VibratorInputMapper.cpp +++ b/services/inputflinger/reader/mapper/VibratorInputMapper.cpp @@ -35,16 +35,18 @@ void VibratorInputMapper::populateDeviceInfo(InputDeviceInfo* info) { info->setVibrator(true); } -void VibratorInputMapper::process(const RawEvent* rawEvent) { +std::list<NotifyArgs> VibratorInputMapper::process(const RawEvent* rawEvent) { // TODO: Handle FF_STATUS, although it does not seem to be widely supported. + return {}; } -void VibratorInputMapper::vibrate(const VibrationSequence& sequence, ssize_t repeat, - int32_t token) { +std::list<NotifyArgs> VibratorInputMapper::vibrate(const VibrationSequence& sequence, + ssize_t repeat, int32_t token) { if (DEBUG_VIBRATOR) { ALOGD("vibrate: deviceId=%d, pattern=[%s], repeat=%zd, token=%d", getDeviceId(), sequence.toString().c_str(), repeat, token); } + std::list<NotifyArgs> out; mVibrating = true; mSequence = sequence; @@ -53,19 +55,22 @@ void VibratorInputMapper::vibrate(const VibrationSequence& sequence, ssize_t rep mIndex = -1; // Request InputReader to notify InputManagerService for vibration started. - NotifyVibratorStateArgs args(getContext()->getNextId(), systemTime(), getDeviceId(), true); - getListener().notifyVibratorState(&args); - nextStep(); + out.push_back( + NotifyVibratorStateArgs(getContext()->getNextId(), systemTime(), getDeviceId(), true)); + out += nextStep(); + return out; } -void VibratorInputMapper::cancelVibrate(int32_t token) { +std::list<NotifyArgs> VibratorInputMapper::cancelVibrate(int32_t token) { if (DEBUG_VIBRATOR) { ALOGD("cancelVibrate: deviceId=%d, token=%d", getDeviceId(), token); } + std::list<NotifyArgs> out; if (mVibrating && mToken == token) { - stopVibrating(); + out.push_back(stopVibrating()); } + return out; } bool VibratorInputMapper::isVibrating() { @@ -76,26 +81,29 @@ std::vector<int32_t> VibratorInputMapper::getVibratorIds() { return getDeviceContext().getVibratorIds(); } -void VibratorInputMapper::timeoutExpired(nsecs_t when) { +std::list<NotifyArgs> VibratorInputMapper::timeoutExpired(nsecs_t when) { + std::list<NotifyArgs> out; if (mVibrating) { if (when >= mNextStepTime) { - nextStep(); + out += nextStep(); } else { getContext()->requestTimeoutAtTime(mNextStepTime); } } + return out; } -void VibratorInputMapper::nextStep() { +std::list<NotifyArgs> VibratorInputMapper::nextStep() { if (DEBUG_VIBRATOR) { ALOGD("nextStep: index=%d, vibrate deviceId=%d", (int)mIndex, getDeviceId()); } + std::list<NotifyArgs> out; mIndex += 1; if (size_t(mIndex) >= mSequence.pattern.size()) { if (mRepeat < 0) { // We are done. - stopVibrating(); - return; + out.push_back(stopVibrating()); + return out; } mIndex = mRepeat; } @@ -122,9 +130,10 @@ void VibratorInputMapper::nextStep() { if (DEBUG_VIBRATOR) { ALOGD("nextStep: scheduled timeout in %lldms", element.duration.count()); } + return out; } -void VibratorInputMapper::stopVibrating() { +NotifyVibratorStateArgs VibratorInputMapper::stopVibrating() { mVibrating = false; if (DEBUG_VIBRATOR) { ALOGD("stopVibrating: sending cancel vibrate deviceId=%d", getDeviceId()); @@ -132,8 +141,7 @@ void VibratorInputMapper::stopVibrating() { getDeviceContext().cancelVibrate(); // Request InputReader to notify InputManagerService for vibration complete. - NotifyVibratorStateArgs args(getContext()->getNextId(), systemTime(), getDeviceId(), false); - getListener().notifyVibratorState(&args); + return NotifyVibratorStateArgs(getContext()->getNextId(), systemTime(), getDeviceId(), false); } void VibratorInputMapper::dump(std::string& dump) { diff --git a/services/inputflinger/reader/mapper/VibratorInputMapper.h b/services/inputflinger/reader/mapper/VibratorInputMapper.h index 894c5739e4..e98f63a8b4 100644 --- a/services/inputflinger/reader/mapper/VibratorInputMapper.h +++ b/services/inputflinger/reader/mapper/VibratorInputMapper.h @@ -27,13 +27,14 @@ public: virtual uint32_t getSources() const override; virtual void populateDeviceInfo(InputDeviceInfo* deviceInfo) override; - virtual void process(const RawEvent* rawEvent) override; + [[nodiscard]] std::list<NotifyArgs> process(const RawEvent* rawEvent) override; - virtual void vibrate(const VibrationSequence& sequence, ssize_t repeat, int32_t token) override; - virtual void cancelVibrate(int32_t token) override; + [[nodiscard]] std::list<NotifyArgs> vibrate(const VibrationSequence& sequence, ssize_t repeat, + int32_t token) override; + [[nodiscard]] std::list<NotifyArgs> cancelVibrate(int32_t token) override; virtual bool isVibrating() override; virtual std::vector<int32_t> getVibratorIds() override; - virtual void timeoutExpired(nsecs_t when) override; + [[nodiscard]] std::list<NotifyArgs> timeoutExpired(nsecs_t when) override; virtual void dump(std::string& dump) override; private: @@ -44,8 +45,8 @@ private: ssize_t mIndex; nsecs_t mNextStepTime; - void nextStep(); - void stopVibrating(); + [[nodiscard]] std::list<NotifyArgs> nextStep(); + [[nodiscard]] NotifyVibratorStateArgs stopVibrating(); }; } // namespace android diff --git a/services/inputflinger/tests/InputReader_test.cpp b/services/inputflinger/tests/InputReader_test.cpp index 8972e9fcdf..dded6a13e0 100644 --- a/services/inputflinger/tests/InputReader_test.cpp +++ b/services/inputflinger/tests/InputReader_test.cpp @@ -1190,7 +1190,8 @@ private: } } - void configure(nsecs_t, const InputReaderConfiguration* config, uint32_t changes) override { + std::list<NotifyArgs> configure(nsecs_t, const InputReaderConfiguration* config, + uint32_t changes) override { std::scoped_lock<std::mutex> lock(mLock); mConfigureWasCalled = true; @@ -1201,19 +1202,22 @@ private: } mStateChangedCondition.notify_all(); + return {}; } - void reset(nsecs_t) override { + std::list<NotifyArgs> reset(nsecs_t) override { std::scoped_lock<std::mutex> lock(mLock); mResetWasCalled = true; mStateChangedCondition.notify_all(); + return {}; } - void process(const RawEvent* rawEvent) override { + std::list<NotifyArgs> process(const RawEvent* rawEvent) override { std::scoped_lock<std::mutex> lock(mLock); mLastEvent = *rawEvent; mProcessWasCalled = true; mStateChangedCondition.notify_all(); + return {}; } int32_t getKeyCodeState(uint32_t, int32_t keyCode) override { @@ -2736,7 +2740,7 @@ TEST_F(InputDeviceTest, CountryCodeCorrectlyMapped) { // Configuration mDevice->addMapper<FakeInputMapper>(EVENTHUB_ID, AINPUT_SOURCE_KEYBOARD); InputReaderConfiguration config; - mDevice->configure(ARBITRARY_TIME, &config, 0); + std::list<NotifyArgs> unused = mDevice->configure(ARBITRARY_TIME, &config, 0); ASSERT_EQ(InputDeviceCountryCode::INTERNATIONAL, mDevice->getDeviceInfo().getCountryCode()); } @@ -2748,10 +2752,10 @@ TEST_F(InputDeviceTest, WhenDeviceCreated_EnabledIsFalse) { TEST_F(InputDeviceTest, WhenNoMappersAreRegistered_DeviceIsIgnored) { // Configuration. InputReaderConfiguration config; - mDevice->configure(ARBITRARY_TIME, &config, 0); + std::list<NotifyArgs> unused = mDevice->configure(ARBITRARY_TIME, &config, 0); // Reset. - mDevice->reset(ARBITRARY_TIME); + unused += mDevice->reset(ARBITRARY_TIME); NotifyDeviceResetArgs resetArgs; ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyDeviceResetWasCalled(&resetArgs)); @@ -2807,7 +2811,7 @@ TEST_F(InputDeviceTest, WhenMappersAreRegistered_DeviceIsNotIgnoredAndForwardsRe mapper2.setMetaState(AMETA_SHIFT_ON); InputReaderConfiguration config; - mDevice->configure(ARBITRARY_TIME, &config, 0); + std::list<NotifyArgs> unused = mDevice->configure(ARBITRARY_TIME, &config, 0); std::string propertyValue; ASSERT_TRUE(mDevice->getConfiguration().tryGetProperty("key", propertyValue)) @@ -2818,7 +2822,7 @@ TEST_F(InputDeviceTest, WhenMappersAreRegistered_DeviceIsNotIgnoredAndForwardsRe ASSERT_NO_FATAL_FAILURE(mapper2.assertConfigureWasCalled()); // Reset - mDevice->reset(ARBITRARY_TIME); + unused += mDevice->reset(ARBITRARY_TIME); ASSERT_NO_FATAL_FAILURE(mapper1.assertResetWasCalled()); ASSERT_NO_FATAL_FAILURE(mapper2.assertResetWasCalled()); @@ -2874,7 +2878,7 @@ TEST_F(InputDeviceTest, WhenMappersAreRegistered_DeviceIsNotIgnoredAndForwardsRe // Event handling. RawEvent event; event.deviceId = EVENTHUB_ID; - mDevice->process(&event, 1); + unused += mDevice->process(&event, 1); ASSERT_NO_FATAL_FAILURE(mapper1.assertProcessWasCalled()); ASSERT_NO_FATAL_FAILURE(mapper2.assertProcessWasCalled()); @@ -2887,7 +2891,8 @@ TEST_F(InputDeviceTest, Configure_AssignsDisplayPort) { mDevice->addMapper<FakeInputMapper>(EVENTHUB_ID, AINPUT_SOURCE_TOUCHSCREEN); // First Configuration. - mDevice->configure(ARBITRARY_TIME, mFakePolicy->getReaderConfiguration(), 0); + std::list<NotifyArgs> unused = + mDevice->configure(ARBITRARY_TIME, mFakePolicy->getReaderConfiguration(), 0); // Device should be enabled by default. ASSERT_TRUE(mDevice->isEnabled()); @@ -2897,8 +2902,8 @@ TEST_F(InputDeviceTest, Configure_AssignsDisplayPort) { const std::string UNIQUE_ID = "local:1"; mFakePolicy->addInputPortAssociation(DEVICE_LOCATION, hdmi); - mDevice->configure(ARBITRARY_TIME, mFakePolicy->getReaderConfiguration(), - InputReaderConfiguration::CHANGE_DISPLAY_INFO); + unused += mDevice->configure(ARBITRARY_TIME, mFakePolicy->getReaderConfiguration(), + InputReaderConfiguration::CHANGE_DISPLAY_INFO); // Device should be disabled because it is associated with a specific display via // input port <-> display port association, but the corresponding display is not found ASSERT_FALSE(mDevice->isEnabled()); @@ -2907,19 +2912,19 @@ TEST_F(InputDeviceTest, Configure_AssignsDisplayPort) { mFakePolicy->addDisplayViewport(SECONDARY_DISPLAY_ID, DISPLAY_WIDTH, DISPLAY_HEIGHT, DISPLAY_ORIENTATION_0, true /*isActive*/, UNIQUE_ID, hdmi, ViewportType::INTERNAL); - mDevice->configure(ARBITRARY_TIME, mFakePolicy->getReaderConfiguration(), - InputReaderConfiguration::CHANGE_DISPLAY_INFO); + unused += mDevice->configure(ARBITRARY_TIME, mFakePolicy->getReaderConfiguration(), + InputReaderConfiguration::CHANGE_DISPLAY_INFO); ASSERT_TRUE(mDevice->isEnabled()); // Device should be disabled after set disable. mFakePolicy->addDisabledDevice(mDevice->getId()); - mDevice->configure(ARBITRARY_TIME, mFakePolicy->getReaderConfiguration(), - InputReaderConfiguration::CHANGE_ENABLED_STATE); + unused += mDevice->configure(ARBITRARY_TIME, mFakePolicy->getReaderConfiguration(), + InputReaderConfiguration::CHANGE_ENABLED_STATE); ASSERT_FALSE(mDevice->isEnabled()); // Device should still be disabled even found the associated display. - mDevice->configure(ARBITRARY_TIME, mFakePolicy->getReaderConfiguration(), - InputReaderConfiguration::CHANGE_DISPLAY_INFO); + unused += mDevice->configure(ARBITRARY_TIME, mFakePolicy->getReaderConfiguration(), + InputReaderConfiguration::CHANGE_DISPLAY_INFO); ASSERT_FALSE(mDevice->isEnabled()); } @@ -2927,47 +2932,49 @@ TEST_F(InputDeviceTest, Configure_AssignsDisplayUniqueId) { // Device should be enabled by default. mFakePolicy->clearViewports(); mDevice->addMapper<FakeInputMapper>(EVENTHUB_ID, AINPUT_SOURCE_KEYBOARD); - mDevice->configure(ARBITRARY_TIME, mFakePolicy->getReaderConfiguration(), 0); + std::list<NotifyArgs> unused = + mDevice->configure(ARBITRARY_TIME, mFakePolicy->getReaderConfiguration(), 0); ASSERT_TRUE(mDevice->isEnabled()); // Device should be disabled because it is associated with a specific display, but the // corresponding display is not found. mFakePolicy->addInputUniqueIdAssociation(DEVICE_LOCATION, DISPLAY_UNIQUE_ID); - mDevice->configure(ARBITRARY_TIME, mFakePolicy->getReaderConfiguration(), - InputReaderConfiguration::CHANGE_DISPLAY_INFO); + unused += mDevice->configure(ARBITRARY_TIME, mFakePolicy->getReaderConfiguration(), + InputReaderConfiguration::CHANGE_DISPLAY_INFO); ASSERT_FALSE(mDevice->isEnabled()); // Device should be enabled when a display is found. mFakePolicy->addDisplayViewport(SECONDARY_DISPLAY_ID, DISPLAY_WIDTH, DISPLAY_HEIGHT, DISPLAY_ORIENTATION_0, /* isActive= */ true, DISPLAY_UNIQUE_ID, NO_PORT, ViewportType::INTERNAL); - mDevice->configure(ARBITRARY_TIME, mFakePolicy->getReaderConfiguration(), - InputReaderConfiguration::CHANGE_DISPLAY_INFO); + unused += mDevice->configure(ARBITRARY_TIME, mFakePolicy->getReaderConfiguration(), + InputReaderConfiguration::CHANGE_DISPLAY_INFO); ASSERT_TRUE(mDevice->isEnabled()); // Device should be disabled after set disable. mFakePolicy->addDisabledDevice(mDevice->getId()); - mDevice->configure(ARBITRARY_TIME, mFakePolicy->getReaderConfiguration(), - InputReaderConfiguration::CHANGE_ENABLED_STATE); + unused += mDevice->configure(ARBITRARY_TIME, mFakePolicy->getReaderConfiguration(), + InputReaderConfiguration::CHANGE_ENABLED_STATE); ASSERT_FALSE(mDevice->isEnabled()); // Device should still be disabled even found the associated display. - mDevice->configure(ARBITRARY_TIME, mFakePolicy->getReaderConfiguration(), - InputReaderConfiguration::CHANGE_DISPLAY_INFO); + unused += mDevice->configure(ARBITRARY_TIME, mFakePolicy->getReaderConfiguration(), + InputReaderConfiguration::CHANGE_DISPLAY_INFO); ASSERT_FALSE(mDevice->isEnabled()); } TEST_F(InputDeviceTest, Configure_UniqueId_CorrectlyMatches) { mFakePolicy->clearViewports(); mDevice->addMapper<FakeInputMapper>(EVENTHUB_ID, AINPUT_SOURCE_KEYBOARD); - mDevice->configure(ARBITRARY_TIME, mFakePolicy->getReaderConfiguration(), 0); + std::list<NotifyArgs> unused = + mDevice->configure(ARBITRARY_TIME, mFakePolicy->getReaderConfiguration(), 0); mFakePolicy->addInputUniqueIdAssociation(DEVICE_LOCATION, DISPLAY_UNIQUE_ID); mFakePolicy->addDisplayViewport(SECONDARY_DISPLAY_ID, DISPLAY_WIDTH, DISPLAY_HEIGHT, DISPLAY_ORIENTATION_0, /* isActive= */ true, DISPLAY_UNIQUE_ID, NO_PORT, ViewportType::INTERNAL); - mDevice->configure(ARBITRARY_TIME, mFakePolicy->getReaderConfiguration(), - InputReaderConfiguration::CHANGE_DISPLAY_INFO); + unused += mDevice->configure(ARBITRARY_TIME, mFakePolicy->getReaderConfiguration(), + InputReaderConfiguration::CHANGE_DISPLAY_INFO); ASSERT_EQ(DISPLAY_UNIQUE_ID, mDevice->getAssociatedDisplayUniqueId()); } @@ -3028,7 +3035,7 @@ protected: mFakeEventHub->addConfigurationProperty(EVENTHUB_ID, key, value); } - void configureDevice(uint32_t changes) { + std::list<NotifyArgs> configureDevice(uint32_t changes) { if (!changes || (changes & (InputReaderConfiguration::CHANGE_DISPLAY_INFO | @@ -3036,9 +3043,14 @@ protected: mReader->requestRefreshConfiguration(changes); mReader->loopOnce(); } - mDevice->configure(ARBITRARY_TIME, mFakePolicy->getReaderConfiguration(), changes); + std::list<NotifyArgs> out = + mDevice->configure(ARBITRARY_TIME, mFakePolicy->getReaderConfiguration(), changes); // Loop the reader to flush the input listener queue. + for (const NotifyArgs& args : out) { + mFakeListener->notify(args); + } mReader->loopOnce(); + return out; } std::shared_ptr<InputDevice> newDevice(int32_t deviceId, const std::string& name, @@ -3060,9 +3072,12 @@ protected: T& addMapperAndConfigure(Args... args) { T& mapper = mDevice->addMapper<T>(EVENTHUB_ID, args...); configureDevice(0); - mDevice->reset(ARBITRARY_TIME); - mapper.reset(ARBITRARY_TIME); + std::list<NotifyArgs> resetArgList = mDevice->reset(ARBITRARY_TIME); + resetArgList += mapper.reset(ARBITRARY_TIME); // Loop the reader to flush the input listener queue. + for (const NotifyArgs& loopArgs : resetArgList) { + mFakeListener->notify(loopArgs); + } mReader->loopOnce(); return mapper; } @@ -3079,8 +3094,8 @@ protected: mFakePolicy->clearViewports(); } - void process(InputMapper& mapper, nsecs_t when, nsecs_t readTime, int32_t type, int32_t code, - int32_t value) { + std::list<NotifyArgs> process(InputMapper& mapper, nsecs_t when, nsecs_t readTime, int32_t type, + int32_t code, int32_t value) { RawEvent event; event.when = when; event.readTime = readTime; @@ -3088,9 +3103,13 @@ protected: event.type = type; event.code = code; event.value = value; - mapper.process(&event); + std::list<NotifyArgs> processArgList = mapper.process(&event); + for (const NotifyArgs& args : processArgList) { + mFakeListener->notify(args); + } // Loop the reader to flush the input listener queue. mReader->loopOnce(); + return processArgList; } static void assertMotionRange(const InputDeviceInfo& info, @@ -3166,14 +3185,17 @@ TEST_F(SwitchInputMapperTest, GetSwitchState) { TEST_F(SwitchInputMapperTest, Process) { SwitchInputMapper& mapper = addMapperAndConfigure<SwitchInputMapper>(); - - process(mapper, ARBITRARY_TIME, READ_TIME, EV_SW, SW_LID, 1); - process(mapper, ARBITRARY_TIME, READ_TIME, EV_SW, SW_JACK_PHYSICAL_INSERT, 1); - process(mapper, ARBITRARY_TIME, READ_TIME, EV_SW, SW_HEADPHONE_INSERT, 0); - process(mapper, ARBITRARY_TIME, READ_TIME, EV_SYN, SYN_REPORT, 0); - - NotifySwitchArgs args; - ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifySwitchWasCalled(&args)); + std::list<NotifyArgs> out; + out = process(mapper, ARBITRARY_TIME, READ_TIME, EV_SW, SW_LID, 1); + ASSERT_TRUE(out.empty()); + out = process(mapper, ARBITRARY_TIME, READ_TIME, EV_SW, SW_JACK_PHYSICAL_INSERT, 1); + ASSERT_TRUE(out.empty()); + out = process(mapper, ARBITRARY_TIME, READ_TIME, EV_SW, SW_HEADPHONE_INSERT, 0); + ASSERT_TRUE(out.empty()); + out = process(mapper, ARBITRARY_TIME, READ_TIME, EV_SYN, SYN_REPORT, 0); + + ASSERT_EQ(1u, out.size()); + const NotifySwitchArgs& args = std::get<NotifySwitchArgs>(*out.begin()); ASSERT_EQ(ARBITRARY_TIME, args.eventTime); ASSERT_EQ((1U << SW_LID) | (1U << SW_JACK_PHYSICAL_INSERT), args.switchValues); ASSERT_EQ((1U << SW_LID) | (1U << SW_JACK_PHYSICAL_INSERT) | (1 << SW_HEADPHONE_INSERT), @@ -3220,22 +3242,23 @@ TEST_F(VibratorInputMapperTest, Vibrate) { ASSERT_FALSE(mapper.isVibrating()); // Start vibrating - mapper.vibrate(sequence, -1 /* repeat */, VIBRATION_TOKEN); + std::list<NotifyArgs> out = mapper.vibrate(sequence, -1 /* repeat */, VIBRATION_TOKEN); ASSERT_TRUE(mapper.isVibrating()); // Verify vibrator state listener was notified. mReader->loopOnce(); - NotifyVibratorStateArgs args; - ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyVibratorStateWasCalled(&args)); - ASSERT_EQ(DEVICE_ID, args.deviceId); - ASSERT_TRUE(args.isOn); + ASSERT_EQ(1u, out.size()); + const NotifyVibratorStateArgs& vibrateArgs = std::get<NotifyVibratorStateArgs>(*out.begin()); + ASSERT_EQ(DEVICE_ID, vibrateArgs.deviceId); + ASSERT_TRUE(vibrateArgs.isOn); // Stop vibrating - mapper.cancelVibrate(VIBRATION_TOKEN); + out = mapper.cancelVibrate(VIBRATION_TOKEN); ASSERT_FALSE(mapper.isVibrating()); // Verify vibrator state listener was notified. mReader->loopOnce(); - ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyVibratorStateWasCalled(&args)); - ASSERT_EQ(DEVICE_ID, args.deviceId); - ASSERT_FALSE(args.isOn); + ASSERT_EQ(1u, out.size()); + const NotifyVibratorStateArgs& cancelArgs = std::get<NotifyVibratorStateArgs>(*out.begin()); + ASSERT_EQ(DEVICE_ID, cancelArgs.deviceId); + ASSERT_FALSE(cancelArgs.isOn); } // --- SensorInputMapperTest --- @@ -3891,7 +3914,7 @@ TEST_F(KeyboardInputMapperTest, NoMetaStateWhenMetaKeysNotPresent) { AINPUT_KEYBOARD_TYPE_NON_ALPHABETIC); // Meta state should be AMETA_NONE after reset - mapper.reset(ARBITRARY_TIME); + std::list<NotifyArgs> unused = mapper.reset(ARBITRARY_TIME); ASSERT_EQ(AMETA_NONE, mapper.getMetaState()); // Meta state should be AMETA_NONE with update, as device doesn't have the keys. mapper.updateMetaState(AKEYCODE_NUM_LOCK); @@ -3943,8 +3966,10 @@ TEST_F(KeyboardInputMapperTest, Configure_AssignsDisplayPort) { KeyboardInputMapper& mapper2 = device2->addMapper<KeyboardInputMapper>(SECOND_EVENTHUB_ID, AINPUT_SOURCE_KEYBOARD, AINPUT_KEYBOARD_TYPE_ALPHABETIC); - device2->configure(ARBITRARY_TIME, mFakePolicy->getReaderConfiguration(), 0 /*changes*/); - device2->reset(ARBITRARY_TIME); + std::list<NotifyArgs> unused = + device2->configure(ARBITRARY_TIME, mFakePolicy->getReaderConfiguration(), + 0 /*changes*/); + unused += device2->reset(ARBITRARY_TIME); // Prepared displays and associated info. constexpr uint8_t hdmi1 = 0; @@ -3955,8 +3980,8 @@ TEST_F(KeyboardInputMapperTest, Configure_AssignsDisplayPort) { mFakePolicy->addInputPortAssociation(USB2, hdmi2); // No associated display viewport found, should disable the device. - device2->configure(ARBITRARY_TIME, mFakePolicy->getReaderConfiguration(), - InputReaderConfiguration::CHANGE_DISPLAY_INFO); + unused += device2->configure(ARBITRARY_TIME, mFakePolicy->getReaderConfiguration(), + InputReaderConfiguration::CHANGE_DISPLAY_INFO); ASSERT_FALSE(device2->isEnabled()); // Prepare second display. @@ -3966,8 +3991,8 @@ TEST_F(KeyboardInputMapperTest, Configure_AssignsDisplayPort) { setDisplayInfoAndReconfigure(newDisplayId, DISPLAY_WIDTH, DISPLAY_HEIGHT, DISPLAY_ORIENTATION_0, SECONDARY_UNIQUE_ID, hdmi2, ViewportType::EXTERNAL); // Default device will reconfigure above, need additional reconfiguration for another device. - device2->configure(ARBITRARY_TIME, mFakePolicy->getReaderConfiguration(), - InputReaderConfiguration::CHANGE_DISPLAY_INFO); + unused += device2->configure(ARBITRARY_TIME, mFakePolicy->getReaderConfiguration(), + InputReaderConfiguration::CHANGE_DISPLAY_INFO); // Device should be enabled after the associated display is found. ASSERT_TRUE(mDevice->isEnabled()); @@ -4051,8 +4076,10 @@ TEST_F(KeyboardInputMapperTest, Process_LockedKeysShouldToggleAfterReattach) { KeyboardInputMapper& mapper2 = device2->addMapper<KeyboardInputMapper>(SECOND_EVENTHUB_ID, AINPUT_SOURCE_KEYBOARD, AINPUT_KEYBOARD_TYPE_ALPHABETIC); - device2->configure(ARBITRARY_TIME, mFakePolicy->getReaderConfiguration(), 0 /*changes*/); - device2->reset(ARBITRARY_TIME); + std::list<NotifyArgs> unused = + device2->configure(ARBITRARY_TIME, mFakePolicy->getReaderConfiguration(), + 0 /*changes*/); + unused += device2->reset(ARBITRARY_TIME); ASSERT_TRUE(mFakeEventHub->getLedState(SECOND_EVENTHUB_ID, LED_CAPSL)); ASSERT_TRUE(mFakeEventHub->getLedState(SECOND_EVENTHUB_ID, LED_NUML)); @@ -4110,8 +4137,10 @@ TEST_F(KeyboardInputMapperTest, Process_LockedKeysShouldToggleInMultiDevices) { KeyboardInputMapper& mapper2 = device2->addMapper<KeyboardInputMapper>(SECOND_EVENTHUB_ID, AINPUT_SOURCE_KEYBOARD, AINPUT_KEYBOARD_TYPE_ALPHABETIC); - device2->configure(ARBITRARY_TIME, mFakePolicy->getReaderConfiguration(), 0 /*changes*/); - device2->reset(ARBITRARY_TIME); + std::list<NotifyArgs> unused = + device2->configure(ARBITRARY_TIME, mFakePolicy->getReaderConfiguration(), + 0 /*changes*/); + unused += device2->reset(ARBITRARY_TIME); // Initial metastate is AMETA_NONE. ASSERT_EQ(AMETA_NONE, mapper1.getMetaState()); @@ -6850,7 +6879,7 @@ TEST_F(SingleTouchInputMapperTest, Reset_RecreatesTouchState) { // Reset the mapper. When the mapper is reset, we expect it to attempt to recreate the touch // state by reading the current axis values. - mapper.reset(ARBITRARY_TIME); + std::list<NotifyArgs> unused = mapper.reset(ARBITRARY_TIME); // Send a sync to simulate an empty touch frame where nothing changes. The mapper should use // the recreated touch state to generate a down event. @@ -8859,8 +8888,10 @@ TEST_F(MultiTouchInputMapperTest, Process_Pointer_ShowTouches) { // Setup the second touch screen device. MultiTouchInputMapper& mapper2 = device2->addMapper<MultiTouchInputMapper>(SECOND_EVENTHUB_ID); - device2->configure(ARBITRARY_TIME, mFakePolicy->getReaderConfiguration(), 0 /*changes*/); - device2->reset(ARBITRARY_TIME); + std::list<NotifyArgs> unused = + device2->configure(ARBITRARY_TIME, mFakePolicy->getReaderConfiguration(), + 0 /*changes*/); + unused += device2->reset(ARBITRARY_TIME); // Setup PointerController. std::shared_ptr<FakePointerController> fakePointerController = @@ -8879,9 +8910,9 @@ TEST_F(MultiTouchInputMapperTest, Process_Pointer_ShowTouches) { prepareSecondaryDisplay(ViewportType::EXTERNAL, hdmi2); // Default device will reconfigure above, need additional reconfiguration for another device. - device2->configure(ARBITRARY_TIME, mFakePolicy->getReaderConfiguration(), - InputReaderConfiguration::CHANGE_DISPLAY_INFO | - InputReaderConfiguration::CHANGE_SHOW_TOUCHES); + unused += device2->configure(ARBITRARY_TIME, mFakePolicy->getReaderConfiguration(), + InputReaderConfiguration::CHANGE_DISPLAY_INFO | + InputReaderConfiguration::CHANGE_SHOW_TOUCHES); // Two fingers down at default display. int32_t x1 = 100, y1 = 125, x2 = 300, y2 = 500; @@ -8911,8 +8942,8 @@ TEST_F(MultiTouchInputMapperTest, Process_Pointer_ShowTouches) { // Disable the show touches configuration and ensure the spots are cleared. mFakePolicy->setShowTouches(false); - device2->configure(ARBITRARY_TIME, mFakePolicy->getReaderConfiguration(), - InputReaderConfiguration::CHANGE_SHOW_TOUCHES); + unused += device2->configure(ARBITRARY_TIME, mFakePolicy->getReaderConfiguration(), + InputReaderConfiguration::CHANGE_SHOW_TOUCHES); ASSERT_TRUE(fakePointerController->getSpots().empty()); } @@ -9500,7 +9531,7 @@ TEST_F(MultiTouchInputMapperTest, Reset_PreservesLastTouchState) { // Reset the mapper. When the mapper is reset, we expect the current multi-touch state to be // preserved. Resetting should not generate any events. - mapper.reset(ARBITRARY_TIME); + std::list<NotifyArgs> unused = mapper.reset(ARBITRARY_TIME); ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasNotCalled()); // Send a sync to simulate an empty touch frame where nothing changes. The mapper should use @@ -9535,7 +9566,7 @@ TEST_F(MultiTouchInputMapperTest, Reset_PreservesLastTouchState_NoPointersDown) // Reset the mapper. When the mapper is reset, we expect it to restore the latest // raw state where no pointers are down. - mapper.reset(ARBITRARY_TIME); + std::list<NotifyArgs> unused = mapper.reset(ARBITRARY_TIME); ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasNotCalled()); // Send an empty sync frame. Since there are no pointers, no events are generated. @@ -10149,12 +10180,12 @@ protected: mFakePolicy.clear(); } - void configureDevice(uint32_t changes) { + std::list<NotifyArgs> configureDevice(uint32_t changes) { if (!changes || (changes & InputReaderConfiguration::CHANGE_DISPLAY_INFO)) { mReader->requestRefreshConfiguration(changes); mReader->loopOnce(); } - mDevice->configure(ARBITRARY_TIME, mFakePolicy->getReaderConfiguration(), changes); + return mDevice->configure(ARBITRARY_TIME, mFakePolicy->getReaderConfiguration(), changes); } std::shared_ptr<InputDevice> newDevice(int32_t deviceId, const std::string& name, diff --git a/services/inputflinger/tests/TestInputListener.cpp b/services/inputflinger/tests/TestInputListener.cpp index 57b382c718..29093efc67 100644 --- a/services/inputflinger/tests/TestInputListener.cpp +++ b/services/inputflinger/tests/TestInputListener.cpp @@ -147,7 +147,7 @@ void TestInputListener::assertNotCalled(std::string message) { } template <class NotifyArgsType> -void TestInputListener::notify(const NotifyArgsType* args) { +void TestInputListener::addToQueue(const NotifyArgsType* args) { std::scoped_lock<std::mutex> lock(mLock); std::vector<NotifyArgsType>& queue = std::get<std::vector<NotifyArgsType>>(mQueues); @@ -156,35 +156,35 @@ void TestInputListener::notify(const NotifyArgsType* args) { } void TestInputListener::notifyConfigurationChanged(const NotifyConfigurationChangedArgs* args) { - notify<NotifyConfigurationChangedArgs>(args); + addToQueue<NotifyConfigurationChangedArgs>(args); } void TestInputListener::notifyDeviceReset(const NotifyDeviceResetArgs* args) { - notify<NotifyDeviceResetArgs>(args); + addToQueue<NotifyDeviceResetArgs>(args); } void TestInputListener::notifyKey(const NotifyKeyArgs* args) { - notify<NotifyKeyArgs>(args); + addToQueue<NotifyKeyArgs>(args); } void TestInputListener::notifyMotion(const NotifyMotionArgs* args) { - notify<NotifyMotionArgs>(args); + addToQueue<NotifyMotionArgs>(args); } void TestInputListener::notifySwitch(const NotifySwitchArgs* args) { - notify<NotifySwitchArgs>(args); + addToQueue<NotifySwitchArgs>(args); } void TestInputListener::notifyPointerCaptureChanged(const NotifyPointerCaptureChangedArgs* args) { - notify<NotifyPointerCaptureChangedArgs>(args); + addToQueue<NotifyPointerCaptureChangedArgs>(args); } void TestInputListener::notifySensor(const NotifySensorArgs* args) { - notify<NotifySensorArgs>(args); + addToQueue<NotifySensorArgs>(args); } void TestInputListener::notifyVibratorState(const NotifyVibratorStateArgs* args) { - notify<NotifyVibratorStateArgs>(args); + addToQueue<NotifyVibratorStateArgs>(args); } } // namespace android diff --git a/services/inputflinger/tests/TestInputListener.h b/services/inputflinger/tests/TestInputListener.h index cad698fd36..4ad1c4264d 100644 --- a/services/inputflinger/tests/TestInputListener.h +++ b/services/inputflinger/tests/TestInputListener.h @@ -67,7 +67,7 @@ private: void assertNotCalled(std::string message); template <class NotifyArgsType> - void notify(const NotifyArgsType* args); + void addToQueue(const NotifyArgsType* args); virtual void notifyConfigurationChanged(const NotifyConfigurationChangedArgs* args) override; diff --git a/services/inputflinger/tests/fuzzers/CursorInputFuzzer.cpp b/services/inputflinger/tests/fuzzers/CursorInputFuzzer.cpp index 4b542aab19..cc523e12cd 100644 --- a/services/inputflinger/tests/fuzzers/CursorInputFuzzer.cpp +++ b/services/inputflinger/tests/fuzzers/CursorInputFuzzer.cpp @@ -51,12 +51,14 @@ extern "C" int LLVMFuzzerTestOneInput(uint8_t* data, size_t size) { }, [&]() -> void { mapper.getSources(); }, [&]() -> void { - mapper.configure(fdp->ConsumeIntegral<nsecs_t>(), &policyConfig, - fdp->ConsumeIntegral<int32_t>()); + std::list<NotifyArgs> unused = + mapper.configure(fdp->ConsumeIntegral<nsecs_t>(), &policyConfig, + fdp->ConsumeIntegral<int32_t>()); }, [&]() -> void { // Need to reconfigure with 0 or you risk a NPE. - mapper.configure(fdp->ConsumeIntegral<nsecs_t>(), &policyConfig, 0); + std::list<NotifyArgs> unused = + mapper.configure(fdp->ConsumeIntegral<nsecs_t>(), &policyConfig, 0); InputDeviceInfo info; mapper.populateDeviceInfo(&info); }, @@ -68,23 +70,27 @@ extern "C" int LLVMFuzzerTestOneInput(uint8_t* data, size_t size) { : fdp->ConsumeIntegral<int32_t>(); // Need to reconfigure with 0 or you risk a NPE. - mapper.configure(fdp->ConsumeIntegral<nsecs_t>(), &policyConfig, 0); + std::list<NotifyArgs> unused = + mapper.configure(fdp->ConsumeIntegral<nsecs_t>(), &policyConfig, 0); RawEvent rawEvent{fdp->ConsumeIntegral<nsecs_t>(), fdp->ConsumeIntegral<nsecs_t>(), fdp->ConsumeIntegral<int32_t>(), type, code, fdp->ConsumeIntegral<int32_t>()}; - mapper.process(&rawEvent); + unused += mapper.process(&rawEvent); + }, + [&]() -> void { + std::list<NotifyArgs> unused = mapper.reset(fdp->ConsumeIntegral<nsecs_t>()); }, - [&]() -> void { mapper.reset(fdp->ConsumeIntegral<nsecs_t>()); }, [&]() -> void { mapper.getScanCodeState(fdp->ConsumeIntegral<uint32_t>(), fdp->ConsumeIntegral<int32_t>()); }, [&]() -> void { // Need to reconfigure with 0 or you risk a NPE. - mapper.configure(fdp->ConsumeIntegral<nsecs_t>(), &policyConfig, 0); + std::list<NotifyArgs> unused = + mapper.configure(fdp->ConsumeIntegral<nsecs_t>(), &policyConfig, 0); mapper.getAssociatedDisplayId(); }, })(); diff --git a/services/inputflinger/tests/fuzzers/FuzzContainer.h b/services/inputflinger/tests/fuzzers/FuzzContainer.h index 62615d0116..1e0764f10f 100644 --- a/services/inputflinger/tests/fuzzers/FuzzContainer.h +++ b/services/inputflinger/tests/fuzzers/FuzzContainer.h @@ -27,7 +27,7 @@ namespace android { class FuzzContainer { std::shared_ptr<FuzzEventHub> mFuzzEventHub; sp<FuzzInputReaderPolicy> mFuzzPolicy; - std::unique_ptr<FuzzInputListener> mFuzzListener; + FuzzInputListener mFuzzListener; std::unique_ptr<FuzzInputReaderContext> mFuzzContext; std::unique_ptr<InputDevice> mFuzzDevice; InputReaderConfiguration mPolicyConfig; @@ -44,9 +44,8 @@ public: // Create mocked objects. mFuzzEventHub = std::make_shared<FuzzEventHub>(mFdp); mFuzzPolicy = sp<FuzzInputReaderPolicy>::make(mFdp); - mFuzzListener = std::make_unique<FuzzInputListener>(); mFuzzContext = std::make_unique<FuzzInputReaderContext>(mFuzzEventHub, mFuzzPolicy, - *mFuzzListener, mFdp); + mFuzzListener, mFdp); InputDeviceIdentifier identifier; identifier.name = deviceName; @@ -60,8 +59,12 @@ public: void configureDevice() { nsecs_t arbitraryTime = mFdp->ConsumeIntegral<nsecs_t>(); - mFuzzDevice->configure(arbitraryTime, &mPolicyConfig, 0); - mFuzzDevice->reset(arbitraryTime); + std::list<NotifyArgs> out; + out += mFuzzDevice->configure(arbitraryTime, &mPolicyConfig, 0); + out += mFuzzDevice->reset(arbitraryTime); + for (const NotifyArgs& args : out) { + mFuzzListener.notify(args); + } } void addProperty(std::string key, std::string value) { diff --git a/services/inputflinger/tests/fuzzers/KeyboardInputFuzzer.cpp b/services/inputflinger/tests/fuzzers/KeyboardInputFuzzer.cpp index c48a099bca..e880f55891 100644 --- a/services/inputflinger/tests/fuzzers/KeyboardInputFuzzer.cpp +++ b/services/inputflinger/tests/fuzzers/KeyboardInputFuzzer.cpp @@ -63,10 +63,13 @@ extern "C" int LLVMFuzzerTestOneInput(uint8_t* data, size_t size) { }, [&]() -> void { mapper.getSources(); }, [&]() -> void { - mapper.configure(fdp->ConsumeIntegral<nsecs_t>(), &policyConfig, - fdp->ConsumeIntegral<uint32_t>()); + std::list<NotifyArgs> unused = + mapper.configure(fdp->ConsumeIntegral<nsecs_t>(), &policyConfig, + fdp->ConsumeIntegral<uint32_t>()); + }, + [&]() -> void { + std::list<NotifyArgs> unused = mapper.reset(fdp->ConsumeIntegral<nsecs_t>()); }, - [&]() -> void { mapper.reset(fdp->ConsumeIntegral<nsecs_t>()); }, [&]() -> void { int32_t type, code; type = fdp->ConsumeBool() ? fdp->PickValueInArray(kValidTypes) @@ -79,7 +82,7 @@ extern "C" int LLVMFuzzerTestOneInput(uint8_t* data, size_t size) { type, code, fdp->ConsumeIntegral<int32_t>()}; - mapper.process(&rawEvent); + std::list<NotifyArgs> unused = mapper.process(&rawEvent); }, [&]() -> void { mapper.getKeyCodeState(fdp->ConsumeIntegral<uint32_t>(), diff --git a/services/inputflinger/tests/fuzzers/MapperHelpers.h b/services/inputflinger/tests/fuzzers/MapperHelpers.h index 03c226600e..bd81761981 100644 --- a/services/inputflinger/tests/fuzzers/MapperHelpers.h +++ b/services/inputflinger/tests/fuzzers/MapperHelpers.h @@ -332,7 +332,6 @@ public: class FuzzInputReaderContext : public InputReaderContext { std::shared_ptr<EventHubInterface> mEventHub; sp<InputReaderPolicyInterface> mPolicy; - InputListenerInterface& mListener; std::shared_ptr<FuzzedDataProvider> mFdp; public: @@ -340,7 +339,7 @@ public: const sp<InputReaderPolicyInterface>& policy, InputListenerInterface& listener, std::shared_ptr<FuzzedDataProvider> mFdp) - : mEventHub(eventHub), mPolicy(policy), mListener(listener), mFdp(mFdp) {} + : mEventHub(eventHub), mPolicy(policy), mFdp(mFdp) {} ~FuzzInputReaderContext() {} void updateGlobalMetaState() override {} int32_t getGlobalMetaState() { return mFdp->ConsumeIntegral<int32_t>(); } @@ -355,9 +354,10 @@ public: void requestTimeoutAtTime(nsecs_t when) override {} int32_t bumpGeneration() override { return mFdp->ConsumeIntegral<int32_t>(); } void getExternalStylusDevices(std::vector<InputDeviceInfo>& outDevices) override {} - void dispatchExternalStylusState(const StylusState& outState) override {} + std::list<NotifyArgs> dispatchExternalStylusState(const StylusState& outState) override { + return {}; + } InputReaderPolicyInterface* getPolicy() override { return mPolicy.get(); } - InputListenerInterface& getListener() override { return mListener; } EventHubInterface* getEventHub() override { return mEventHub.get(); } int32_t getNextId() override { return mFdp->ConsumeIntegral<int32_t>(); } diff --git a/services/inputflinger/tests/fuzzers/MultiTouchInputFuzzer.cpp b/services/inputflinger/tests/fuzzers/MultiTouchInputFuzzer.cpp index 59b064249a..99fd0831a9 100644 --- a/services/inputflinger/tests/fuzzers/MultiTouchInputFuzzer.cpp +++ b/services/inputflinger/tests/fuzzers/MultiTouchInputFuzzer.cpp @@ -78,10 +78,13 @@ extern "C" int LLVMFuzzerTestOneInput(uint8_t* data, size_t size) { }, [&]() -> void { mapper.getSources(); }, [&]() -> void { - mapper.configure(fdp->ConsumeIntegral<nsecs_t>(), &policyConfig, - fdp->ConsumeIntegral<uint32_t>()); + std::list<NotifyArgs> unused = + mapper.configure(fdp->ConsumeIntegral<nsecs_t>(), &policyConfig, + fdp->ConsumeIntegral<uint32_t>()); + }, + [&]() -> void { + std::list<NotifyArgs> unused = mapper.reset(fdp->ConsumeIntegral<nsecs_t>()); }, - [&]() -> void { mapper.reset(fdp->ConsumeIntegral<nsecs_t>()); }, [&]() -> void { int32_t type = fdp->ConsumeBool() ? fdp->PickValueInArray(kValidTypes) : fdp->ConsumeIntegral<int32_t>(); @@ -93,7 +96,7 @@ extern "C" int LLVMFuzzerTestOneInput(uint8_t* data, size_t size) { type, code, fdp->ConsumeIntegral<int32_t>()}; - mapper.process(&rawEvent); + std::list<NotifyArgs> unused = mapper.process(&rawEvent); }, [&]() -> void { mapper.getKeyCodeState(fdp->ConsumeIntegral<uint32_t>(), @@ -113,16 +116,20 @@ extern "C" int LLVMFuzzerTestOneInput(uint8_t* data, size_t size) { nullptr); }, [&]() -> void { - mapper.cancelTouch(fdp->ConsumeIntegral<nsecs_t>(), - fdp->ConsumeIntegral<nsecs_t>()); + std::list<NotifyArgs> unused = + mapper.cancelTouch(fdp->ConsumeIntegral<nsecs_t>(), + fdp->ConsumeIntegral<nsecs_t>()); + }, + [&]() -> void { + std::list<NotifyArgs> unused = + mapper.timeoutExpired(fdp->ConsumeIntegral<nsecs_t>()); }, - [&]() -> void { mapper.timeoutExpired(fdp->ConsumeIntegral<nsecs_t>()); }, [&]() -> void { StylusState state{fdp->ConsumeIntegral<nsecs_t>(), fdp->ConsumeFloatingPoint<float>(), fdp->ConsumeIntegral<uint32_t>(), fdp->ConsumeIntegral<int32_t>()}; - mapper.updateExternalStylusState(state); + std::list<NotifyArgs> unused = mapper.updateExternalStylusState(state); }, [&]() -> void { mapper.getAssociatedDisplayId(); }, })(); diff --git a/services/inputflinger/tests/fuzzers/SwitchInputFuzzer.cpp b/services/inputflinger/tests/fuzzers/SwitchInputFuzzer.cpp index e76bd728b8..7416ce9d47 100644 --- a/services/inputflinger/tests/fuzzers/SwitchInputFuzzer.cpp +++ b/services/inputflinger/tests/fuzzers/SwitchInputFuzzer.cpp @@ -46,7 +46,7 @@ extern "C" int LLVMFuzzerTestOneInput(uint8_t* data, size_t size) { type, code, fdp->ConsumeIntegral<int32_t>()}; - mapper.process(&rawEvent); + std::list<NotifyArgs> unused = mapper.process(&rawEvent); }, [&]() -> void { mapper.getSwitchState(fdp->ConsumeIntegral<uint32_t>(), |