Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit edd337e4 authored by Treehugger Robot's avatar Treehugger Robot Committed by Automerger Merge Worker
Browse files

Merge "InputListener: Pass NotifyArgs by reference" into udc-dev am: f8538d60 

Original change: https://googleplex-android-review.googlesource.com/c/platform/frameworks/native/+/22629836



Change-Id: I81dbfdd1f3a95c4f21045d2c5ffb07083d2f371b
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents 9c62c4c7 f8538d60

services/inputflinger/InputListener.cpp

+32 −35
Original line number Diff line number Diff line
@@ -47,16 +47,14 @@ Visitor(V...) -> Visitor<V...>; 
void InputListenerInterface::notify(const NotifyArgs& generalArgs) {

    Visitor v{

            [&](const NotifyInputDevicesChangedArgs& args) { notifyInputDevicesChanged(args); },

            [&](const NotifyConfigurationChangedArgs& args) { notifyConfigurationChanged(&args); },

            [&](const NotifyKeyArgs& args) { notifyKey(&args); },

            [&](const NotifyMotionArgs& args) { notifyMotion(&args); },

            [&](const NotifySwitchArgs& args) { notifySwitch(&args); },

            [&](const NotifySensorArgs& args) { notifySensor(&args); },

            [&](const NotifyVibratorStateArgs& args) { notifyVibratorState(&args); },

            [&](const NotifyDeviceResetArgs& args) { notifyDeviceReset(&args); },

            [&](const NotifyPointerCaptureChangedArgs& args) {

                notifyPointerCaptureChanged(&args);

            },

            [&](const NotifyConfigurationChangedArgs& args) { notifyConfigurationChanged(args); },

            [&](const NotifyKeyArgs& args) { notifyKey(args); },

            [&](const NotifyMotionArgs& args) { notifyMotion(args); },

            [&](const NotifySwitchArgs& args) { notifySwitch(args); },

            [&](const NotifySensorArgs& args) { notifySensor(args); },

            [&](const NotifyVibratorStateArgs& args) { notifyVibratorState(args); },

            [&](const NotifyDeviceResetArgs& args) { notifyDeviceReset(args); },

            [&](const NotifyPointerCaptureChangedArgs& args) { notifyPointerCaptureChanged(args); },

    };

    std::visit(v, generalArgs);

}
@@ -78,45 +76,44 @@ void QueuedInputListener::notifyInputDevicesChanged(const NotifyInputDevicesChan 
    mArgsQueue.emplace_back(args);

}



void QueuedInputListener::notifyConfigurationChanged(

        const NotifyConfigurationChangedArgs* args) {

    traceEvent(__func__, args->id);

    mArgsQueue.emplace_back(*args);

void QueuedInputListener::notifyConfigurationChanged(const NotifyConfigurationChangedArgs& args) {

    traceEvent(__func__, args.id);

    mArgsQueue.emplace_back(args);

}



void QueuedInputListener::notifyKey(const NotifyKeyArgs* args) {

    traceEvent(__func__, args->id);

    mArgsQueue.emplace_back(*args);

void QueuedInputListener::notifyKey(const NotifyKeyArgs& args) {

    traceEvent(__func__, args.id);

    mArgsQueue.emplace_back(args);

}



void QueuedInputListener::notifyMotion(const NotifyMotionArgs* args) {

    traceEvent(__func__, args->id);

    mArgsQueue.emplace_back(*args);

void QueuedInputListener::notifyMotion(const NotifyMotionArgs& args) {

    traceEvent(__func__, args.id);

    mArgsQueue.emplace_back(args);

}



void QueuedInputListener::notifySwitch(const NotifySwitchArgs* args) {

    traceEvent(__func__, args->id);

    mArgsQueue.emplace_back(*args);

void QueuedInputListener::notifySwitch(const NotifySwitchArgs& args) {

    traceEvent(__func__, args.id);

    mArgsQueue.emplace_back(args);

}



void QueuedInputListener::notifySensor(const NotifySensorArgs* args) {

    traceEvent(__func__, args->id);

    mArgsQueue.emplace_back(*args);

void QueuedInputListener::notifySensor(const NotifySensorArgs& args) {

    traceEvent(__func__, args.id);

    mArgsQueue.emplace_back(args);

}



void QueuedInputListener::notifyVibratorState(const NotifyVibratorStateArgs* args) {

    traceEvent(__func__, args->id);

    mArgsQueue.emplace_back(*args);

void QueuedInputListener::notifyVibratorState(const NotifyVibratorStateArgs& args) {

    traceEvent(__func__, args.id);

    mArgsQueue.emplace_back(args);

}



void QueuedInputListener::notifyDeviceReset(const NotifyDeviceResetArgs* args) {

    traceEvent(__func__, args->id);

    mArgsQueue.emplace_back(*args);

void QueuedInputListener::notifyDeviceReset(const NotifyDeviceResetArgs& args) {

    traceEvent(__func__, args.id);

    mArgsQueue.emplace_back(args);

}



void QueuedInputListener::notifyPointerCaptureChanged(const NotifyPointerCaptureChangedArgs* args) {

    traceEvent(__func__, args->id);

    mArgsQueue.emplace_back(*args);

void QueuedInputListener::notifyPointerCaptureChanged(const NotifyPointerCaptureChangedArgs& args) {

    traceEvent(__func__, args.id);

    mArgsQueue.emplace_back(args);

}



void QueuedInputListener::flush() {

services/inputflinger/InputProcessor.cpp

+14 −14
Original line number Diff line number Diff line
@@ -419,63 +419,63 @@ void InputProcessor::notifyInputDevicesChanged(const NotifyInputDevicesChangedAr 
    mQueuedListener.flush();

}



void InputProcessor::notifyConfigurationChanged(const NotifyConfigurationChangedArgs* args) {

void InputProcessor::notifyConfigurationChanged(const NotifyConfigurationChangedArgs& args) {

    // pass through

    mQueuedListener.notifyConfigurationChanged(args);

    mQueuedListener.flush();

}



void InputProcessor::notifyKey(const NotifyKeyArgs* args) {

void InputProcessor::notifyKey(const NotifyKeyArgs& args) {

    // pass through

    mQueuedListener.notifyKey(args);

    mQueuedListener.flush();

}



void InputProcessor::notifyMotion(const NotifyMotionArgs* args) {

void InputProcessor::notifyMotion(const NotifyMotionArgs& args) {

    { // acquire lock

        std::scoped_lock lock(mLock);

        // MotionClassifier is only used for touch events, for now

        const bool sendToMotionClassifier = mMotionClassifier && isTouchEvent(*args);

        const bool sendToMotionClassifier = mMotionClassifier && isTouchEvent(args);

        if (!sendToMotionClassifier) {

            mQueuedListener.notifyMotion(args);

        } else {

            NotifyMotionArgs newArgs(*args);

            NotifyMotionArgs newArgs(args);

            const MotionClassification newClassification = mMotionClassifier->classify(newArgs);

            LOG_ALWAYS_FATAL_IF(args->classification != MotionClassification::NONE &&

            LOG_ALWAYS_FATAL_IF(args.classification != MotionClassification::NONE &&

                                        newClassification != MotionClassification::NONE,

                                "Conflicting classifications %s (new) and %s (old)!",

                                motionClassificationToString(newClassification),

                                motionClassificationToString(args->classification));

                                motionClassificationToString(args.classification));

            newArgs.classification = newClassification;

            mQueuedListener.notifyMotion(&newArgs);

            mQueuedListener.notifyMotion(newArgs);

        }

    } // release lock

    mQueuedListener.flush();

}



void InputProcessor::notifySensor(const NotifySensorArgs* args) {

void InputProcessor::notifySensor(const NotifySensorArgs& args) {

    // pass through

    mQueuedListener.notifySensor(args);

    mQueuedListener.flush();

}



void InputProcessor::notifyVibratorState(const NotifyVibratorStateArgs* args) {

void InputProcessor::notifyVibratorState(const NotifyVibratorStateArgs& args) {

    // pass through

    mQueuedListener.notifyVibratorState(args);

    mQueuedListener.flush();

}



void InputProcessor::notifySwitch(const NotifySwitchArgs* args) {

void InputProcessor::notifySwitch(const NotifySwitchArgs& args) {

    // pass through

    mQueuedListener.notifySwitch(args);

    mQueuedListener.flush();

}



void InputProcessor::notifyDeviceReset(const NotifyDeviceResetArgs* args) {

void InputProcessor::notifyDeviceReset(const NotifyDeviceResetArgs& args) {

    { // acquire lock

        std::scoped_lock lock(mLock);

        if (mMotionClassifier) {

            mMotionClassifier->reset(*args);

            mMotionClassifier->reset(args);

        }

    } // release lock
@@ -484,7 +484,7 @@ void InputProcessor::notifyDeviceReset(const NotifyDeviceResetArgs* args) { 
    mQueuedListener.flush();

}



void InputProcessor::notifyPointerCaptureChanged(const NotifyPointerCaptureChangedArgs* args) {

void InputProcessor::notifyPointerCaptureChanged(const NotifyPointerCaptureChangedArgs& args) {

    // pass through

    mQueuedListener.notifyPointerCaptureChanged(args);

    mQueuedListener.flush();

services/inputflinger/InputProcessor.h

+8 −8
Original line number Diff line number Diff line
@@ -246,14 +246,14 @@ public: 
    explicit InputProcessor(InputListenerInterface& listener);



    void notifyInputDevicesChanged(const NotifyInputDevicesChangedArgs& args) override;

    void notifyConfigurationChanged(const NotifyConfigurationChangedArgs* args) override;

    void notifyKey(const NotifyKeyArgs* args) override;

    void notifyMotion(const NotifyMotionArgs* args) override;

    void notifySwitch(const NotifySwitchArgs* args) override;

    void notifySensor(const NotifySensorArgs* args) override;

    void notifyVibratorState(const NotifyVibratorStateArgs* args) override;

    void notifyDeviceReset(const NotifyDeviceResetArgs* args) override;

    void notifyPointerCaptureChanged(const NotifyPointerCaptureChangedArgs* args) override;

    void notifyConfigurationChanged(const NotifyConfigurationChangedArgs& args) override;

    void notifyKey(const NotifyKeyArgs& args) override;

    void notifyMotion(const NotifyMotionArgs& args) override;

    void notifySwitch(const NotifySwitchArgs& args) override;

    void notifySensor(const NotifySensorArgs& args) override;

    void notifyVibratorState(const NotifyVibratorStateArgs& args) override;

    void notifyDeviceReset(const NotifyDeviceResetArgs& args) override;

    void notifyPointerCaptureChanged(const NotifyPointerCaptureChangedArgs& args) override;



    void dump(std::string& dump) override;

    void monitor() override;

services/inputflinger/UnwantedInteractionBlocker.cpp

+20 −20
Original line number Diff line number Diff line
@@ -329,24 +329,24 @@ UnwantedInteractionBlocker::UnwantedInteractionBlocker(InputListenerInterface& l 
      : mQueuedListener(listener), mEnablePalmRejection(enablePalmRejection) {}



void UnwantedInteractionBlocker::notifyConfigurationChanged(

        const NotifyConfigurationChangedArgs* args) {

        const NotifyConfigurationChangedArgs& args) {

    mQueuedListener.notifyConfigurationChanged(args);

    mQueuedListener.flush();

}



void UnwantedInteractionBlocker::notifyKey(const NotifyKeyArgs* args) {

void UnwantedInteractionBlocker::notifyKey(const NotifyKeyArgs& args) {

    mQueuedListener.notifyKey(args);

    mQueuedListener.flush();

}



void UnwantedInteractionBlocker::notifyMotion(const NotifyMotionArgs* args) {

    ALOGD_IF(DEBUG_INBOUND_MOTION, "%s: %s", __func__, args->dump().c_str());

void UnwantedInteractionBlocker::notifyMotion(const NotifyMotionArgs& args) {

    ALOGD_IF(DEBUG_INBOUND_MOTION, "%s: %s", __func__, args.dump().c_str());

    { // acquire lock

        std::scoped_lock lock(mLock);

        const std::vector<NotifyMotionArgs> processedArgs =

                mPreferStylusOverTouchBlocker.processMotion(*args);

                mPreferStylusOverTouchBlocker.processMotion(args);

        for (const NotifyMotionArgs& loopArgs : processedArgs) {

            notifyMotionLocked(&loopArgs);

            notifyMotionLocked(loopArgs);

        }

    } // release lock
@@ -356,56 +356,56 @@ void UnwantedInteractionBlocker::notifyMotion(const NotifyMotionArgs* args) { 


void UnwantedInteractionBlocker::enqueueOutboundMotionLocked(const NotifyMotionArgs& args) {

    ALOGD_IF(DEBUG_OUTBOUND_MOTION, "%s: %s", __func__, args.dump().c_str());

    mQueuedListener.notifyMotion(&args);

    mQueuedListener.notifyMotion(args);

}



void UnwantedInteractionBlocker::notifyMotionLocked(const NotifyMotionArgs* args) {

    auto it = mPalmRejectors.find(args->deviceId);

    const bool sendToPalmRejector = it != mPalmRejectors.end() && isFromTouchscreen(args->source);

void UnwantedInteractionBlocker::notifyMotionLocked(const NotifyMotionArgs& args) {

    auto it = mPalmRejectors.find(args.deviceId);

    const bool sendToPalmRejector = it != mPalmRejectors.end() && isFromTouchscreen(args.source);

    if (!sendToPalmRejector) {

        enqueueOutboundMotionLocked(*args);

        enqueueOutboundMotionLocked(args);

        return;

    }



    std::vector<NotifyMotionArgs> processedArgs = it->second.processMotion(*args);

    std::vector<NotifyMotionArgs> processedArgs = it->second.processMotion(args);

    for (const NotifyMotionArgs& loopArgs : processedArgs) {

        enqueueOutboundMotionLocked(loopArgs);

    }

}



void UnwantedInteractionBlocker::notifySwitch(const NotifySwitchArgs* args) {

void UnwantedInteractionBlocker::notifySwitch(const NotifySwitchArgs& args) {

    mQueuedListener.notifySwitch(args);

    mQueuedListener.flush();

}



void UnwantedInteractionBlocker::notifySensor(const NotifySensorArgs* args) {

void UnwantedInteractionBlocker::notifySensor(const NotifySensorArgs& args) {

    mQueuedListener.notifySensor(args);

    mQueuedListener.flush();

}



void UnwantedInteractionBlocker::notifyVibratorState(const NotifyVibratorStateArgs* args) {

void UnwantedInteractionBlocker::notifyVibratorState(const NotifyVibratorStateArgs& args) {

    mQueuedListener.notifyVibratorState(args);

    mQueuedListener.flush();

}

void UnwantedInteractionBlocker::notifyDeviceReset(const NotifyDeviceResetArgs* args) {

void UnwantedInteractionBlocker::notifyDeviceReset(const NotifyDeviceResetArgs& args) {

    { // acquire lock

        std::scoped_lock lock(mLock);

        auto it = mPalmRejectors.find(args->deviceId);

        auto it = mPalmRejectors.find(args.deviceId);

        if (it != mPalmRejectors.end()) {

            AndroidPalmFilterDeviceInfo info = it->second.getPalmFilterDeviceInfo();

            // Re-create the object instead of resetting it

            mPalmRejectors.erase(it);

            mPalmRejectors.emplace(args->deviceId, info);

            mPalmRejectors.emplace(args.deviceId, info);

        }

        mQueuedListener.notifyDeviceReset(args);

        mPreferStylusOverTouchBlocker.notifyDeviceReset(*args);

        mPreferStylusOverTouchBlocker.notifyDeviceReset(args);

    } // release lock

    // Send events to the next stage without holding the lock

    mQueuedListener.flush();

}



void UnwantedInteractionBlocker::notifyPointerCaptureChanged(

        const NotifyPointerCaptureChangedArgs* args) {

        const NotifyPointerCaptureChangedArgs& args) {

    mQueuedListener.notifyPointerCaptureChanged(args);

    mQueuedListener.flush();

}

services/inputflinger/UnwantedInteractionBlocker.h

+9 −9
Original line number Diff line number Diff line
@@ -91,14 +91,14 @@ public: 
    explicit UnwantedInteractionBlocker(InputListenerInterface& listener, bool enablePalmRejection);



    void notifyInputDevicesChanged(const NotifyInputDevicesChangedArgs& args) override;

    void notifyConfigurationChanged(const NotifyConfigurationChangedArgs* args) override;

    void notifyKey(const NotifyKeyArgs* args) override;

    void notifyMotion(const NotifyMotionArgs* args) override;

    void notifySwitch(const NotifySwitchArgs* args) override;

    void notifySensor(const NotifySensorArgs* args) override;

    void notifyVibratorState(const NotifyVibratorStateArgs* args) override;

    void notifyDeviceReset(const NotifyDeviceResetArgs* args) override;

    void notifyPointerCaptureChanged(const NotifyPointerCaptureChangedArgs* args) override;

    void notifyConfigurationChanged(const NotifyConfigurationChangedArgs& args) override;

    void notifyKey(const NotifyKeyArgs& args) override;

    void notifyMotion(const NotifyMotionArgs& args) override;

    void notifySwitch(const NotifySwitchArgs& args) override;

    void notifySensor(const NotifySensorArgs& args) override;

    void notifyVibratorState(const NotifyVibratorStateArgs& args) override;

    void notifyDeviceReset(const NotifyDeviceResetArgs& args) override;

    void notifyPointerCaptureChanged(const NotifyPointerCaptureChangedArgs& args) override;



    void dump(std::string& dump) override;

    void monitor() override;
@@ -119,7 +119,7 @@ private: 
    // Use a separate palm rejector for every touch device.

    std::map<int32_t /*deviceId*/, PalmRejector> mPalmRejectors GUARDED_BY(mLock);

    // TODO(b/210159205): delete this when simultaneous stylus and touch is supported

    void notifyMotionLocked(const NotifyMotionArgs* args) REQUIRES(mLock);

    void notifyMotionLocked(const NotifyMotionArgs& args) REQUIRES(mLock);



    // Call this function for outbound events so that they can be logged when logging is enabled.

    void enqueueOutboundMotionLocked(const NotifyMotionArgs& args) REQUIRES(mLock);