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

Commit 18050095 authored by Siarhei Vishniakou's avatar Siarhei Vishniakou
Browse files

Remove RefBase from InputListener interface 

We don't need refbase for inputlisteners. Remove it, and switch to
references, which cannot be null. This way, we can avoid dereferencing
the pointers without checking for nullness.

Bug: 198472780
Test: atest inputflinger_tests
Change-Id: I2f469fd268472c7e78d36812353cff5c52a90163
parent 91773046

services/inputflinger/InputClassifier.cpp

+10 −10
Original line number Diff line number Diff line
@@ -345,7 +345,7 @@ void InputClassifier::HalDeathRecipient::serviceDied( 


// --- InputClassifier ---



InputClassifier::InputClassifier(const sp<InputListenerInterface>& listener)

InputClassifier::InputClassifier(InputListenerInterface& listener)

      : mListener(listener), mHalDeathRecipient(new HalDeathRecipient(*this)) {}



void InputClassifier::setMotionClassifierEnabled(bool enabled) {
@@ -369,12 +369,12 @@ void InputClassifier::setMotionClassifierEnabled(bool enabled) { 


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

    // pass through

    mListener->notifyConfigurationChanged(args);

    mListener.notifyConfigurationChanged(args);

}



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

    // pass through

    mListener->notifyKey(args);

    mListener.notifyKey(args);

}



void InputClassifier::notifyMotion(const NotifyMotionArgs* args) {
@@ -382,28 +382,28 @@ void InputClassifier::notifyMotion(const NotifyMotionArgs* args) { 
    // MotionClassifier is only used for touch events, for now

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

    if (!sendToMotionClassifier) {

        mListener->notifyMotion(args);

        mListener.notifyMotion(args);

        return;

    }



    NotifyMotionArgs newArgs(*args);

    newArgs.classification = mMotionClassifier->classify(newArgs);

    mListener->notifyMotion(&newArgs);

    mListener.notifyMotion(&newArgs);

}



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

    // pass through

    mListener->notifySensor(args);

    mListener.notifySensor(args);

}



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

    // pass through

    mListener->notifyVibratorState(args);

    mListener.notifyVibratorState(args);

}



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

    // pass through

    mListener->notifySwitch(args);

    mListener.notifySwitch(args);

}



void InputClassifier::notifyDeviceReset(const NotifyDeviceResetArgs* args) {
@@ -412,12 +412,12 @@ void InputClassifier::notifyDeviceReset(const NotifyDeviceResetArgs* args) { 
        mMotionClassifier->reset(*args);

    }

    // continue to next stage

    mListener->notifyDeviceReset(args);

    mListener.notifyDeviceReset(args);

}



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

    // pass through

    mListener->notifyPointerCaptureChanged(args);

    mListener.notifyPointerCaptureChanged(args);

}



void InputClassifier::setMotionClassifier(

services/inputflinger/InputClassifier.h

+4 −5
Original line number Diff line number Diff line
@@ -18,7 +18,6 @@ 
#define _UI_INPUT_CLASSIFIER_H



#include <android-base/thread_annotations.h>

#include <utils/RefBase.h>

#include <thread>

#include <unordered_map>
@@ -88,7 +87,7 @@ public: 
 * Base interface for an InputListener stage.

 * Provides classification to events.

 */

class InputClassifierInterface : public virtual RefBase, public InputListenerInterface {

class InputClassifierInterface : public InputListenerInterface {

public:

    virtual void setMotionClassifierEnabled(bool enabled) = 0;

    /**
@@ -96,7 +95,7 @@ public: 
     * This method may be called on any thread (usually by the input manager).

     */

    virtual void dump(std::string& dump) = 0;

protected:



    InputClassifierInterface() { }

    virtual ~InputClassifierInterface() { }

};
@@ -223,7 +222,7 @@ private: 
 */

class InputClassifier : public InputClassifierInterface {

public:

    explicit InputClassifier(const sp<InputListenerInterface>& listener);

    explicit InputClassifier(InputListenerInterface& listener);



    virtual void notifyConfigurationChanged(const NotifyConfigurationChangedArgs* args) override;

    virtual void notifyKey(const NotifyKeyArgs* args) override;
@@ -245,7 +244,7 @@ private: 
    // Protect access to mMotionClassifier, since it may become null via a hidl callback

    std::mutex mLock;

    // The next stage to pass input events to

    sp<InputListenerInterface> mListener;

    InputListenerInterface& mListener;



    std::unique_ptr<MotionClassifierInterface> mMotionClassifier GUARDED_BY(mLock);

    std::thread mInitializeMotionClassifierThread;

services/inputflinger/InputListener.cpp

+18 −19
Original line number Diff line number Diff line
@@ -44,8 +44,8 @@ bool NotifyConfigurationChangedArgs::operator==(const NotifyConfigurationChanged 
    return id == rhs.id && eventTime == rhs.eventTime;

}



void NotifyConfigurationChangedArgs::notify(const sp<InputListenerInterface>& listener) const {

    listener->notifyConfigurationChanged(this);

void NotifyConfigurationChangedArgs::notify(InputListenerInterface& listener) const {

    listener.notifyConfigurationChanged(this);

}



// --- NotifyKeyArgs ---
@@ -89,8 +89,8 @@ bool NotifyKeyArgs::operator==(const NotifyKeyArgs& rhs) const { 
            downTime == rhs.downTime;

}



void NotifyKeyArgs::notify(const sp<InputListenerInterface>& listener) const {

    listener->notifyKey(this);

void NotifyKeyArgs::notify(InputListenerInterface& listener) const {

    listener.notifyKey(this);

}



// --- NotifyMotionArgs ---
@@ -188,8 +188,8 @@ bool NotifyMotionArgs::operator==(const NotifyMotionArgs& rhs) const { 
    return true;

}



void NotifyMotionArgs::notify(const sp<InputListenerInterface>& listener) const {

    listener->notifyMotion(this);

void NotifyMotionArgs::notify(InputListenerInterface& listener) const {

    listener.notifyMotion(this);

}



// --- NotifySwitchArgs ---
@@ -212,8 +212,8 @@ bool NotifySwitchArgs::operator==(const NotifySwitchArgs rhs) const { 
            switchValues == rhs.switchValues && switchMask == rhs.switchMask;

}



void NotifySwitchArgs::notify(const sp<InputListenerInterface>& listener) const {

    listener->notifySwitch(this);

void NotifySwitchArgs::notify(InputListenerInterface& listener) const {

    listener.notifySwitch(this);

}



// --- NotifySensorArgs ---
@@ -247,8 +247,8 @@ bool NotifySensorArgs::operator==(const NotifySensorArgs rhs) const { 
            hwTimestamp == rhs.hwTimestamp && values == rhs.values;

}



void NotifySensorArgs::notify(const sp<InputListenerInterface>& listener) const {

    listener->notifySensor(this);

void NotifySensorArgs::notify(InputListenerInterface& listener) const {

    listener.notifySensor(this);

}



// --- NotifyVibratorStateArgs ---
@@ -265,8 +265,8 @@ bool NotifyVibratorStateArgs::operator==(const NotifyVibratorStateArgs rhs) cons 
            isOn == rhs.isOn;

}



void NotifyVibratorStateArgs::notify(const sp<InputListenerInterface>& listener) const {

    listener->notifyVibratorState(this);

void NotifyVibratorStateArgs::notify(InputListenerInterface& listener) const {

    listener.notifyVibratorState(this);

}



// --- NotifyDeviceResetArgs ---
@@ -281,8 +281,8 @@ bool NotifyDeviceResetArgs::operator==(const NotifyDeviceResetArgs& rhs) const { 
    return id == rhs.id && eventTime == rhs.eventTime && deviceId == rhs.deviceId;

}



void NotifyDeviceResetArgs::notify(const sp<InputListenerInterface>& listener) const {

    listener->notifyDeviceReset(this);

void NotifyDeviceResetArgs::notify(InputListenerInterface& listener) const {

    listener.notifyDeviceReset(this);

}



// --- NotifyPointerCaptureChangedArgs ---
@@ -299,8 +299,8 @@ bool NotifyPointerCaptureChangedArgs::operator==(const NotifyPointerCaptureChang 
    return id == rhs.id && eventTime == rhs.eventTime && request == rhs.request;

}



void NotifyPointerCaptureChangedArgs::notify(const sp<InputListenerInterface>& listener) const {

    listener->notifyPointerCaptureChanged(this);

void NotifyPointerCaptureChangedArgs::notify(InputListenerInterface& listener) const {

    listener.notifyPointerCaptureChanged(this);

}



// --- QueuedInputListener ---
@@ -312,9 +312,8 @@ static inline void traceEvent(const char* functionName, int32_t id) { 
    }

}



QueuedInputListener::QueuedInputListener(const sp<InputListenerInterface>& innerListener) :

        mInnerListener(innerListener) {

}

QueuedInputListener::QueuedInputListener(InputListenerInterface& innerListener)

      : mInnerListener(innerListener) {}



QueuedInputListener::~QueuedInputListener() {

    size_t count = mArgsQueue.size();

services/inputflinger/InputManager.cpp

+8 −8
Original line number Diff line number Diff line
@@ -58,8 +58,8 @@ InputManager::InputManager( 
        const sp<InputReaderPolicyInterface>& readerPolicy,

        const sp<InputDispatcherPolicyInterface>& dispatcherPolicy) {

    mDispatcher = createInputDispatcher(dispatcherPolicy);

    mClassifier = new InputClassifier(mDispatcher);

    mReader = createInputReader(readerPolicy, mClassifier);

    mClassifier = std::make_unique<InputClassifier>(*mDispatcher);

    mReader = createInputReader(readerPolicy, *mClassifier);

}



InputManager::~InputManager() {
@@ -102,16 +102,16 @@ status_t InputManager::stop() { 
    return status;

}



sp<InputReaderInterface> InputManager::getReader() {

    return mReader;

InputReaderInterface& InputManager::getReader() {

    return *mReader;

}



sp<InputClassifierInterface> InputManager::getClassifier() {

    return mClassifier;

InputClassifierInterface& InputManager::getClassifier() {

    return *mClassifier;

}



sp<InputDispatcherInterface> InputManager::getDispatcher() {

    return mDispatcher;

InputDispatcherInterface& InputManager::getDispatcher() {

    return *mDispatcher;

}



// Used by tests only.

services/inputflinger/InputManager.h

+9 −9
Original line number Diff line number Diff line
@@ -75,13 +75,13 @@ public: 
    virtual status_t stop() = 0;



    /* Gets the input reader. */

    virtual sp<InputReaderInterface> getReader() = 0;

    virtual InputReaderInterface& getReader() = 0;



    /* Gets the input classifier */

    virtual sp<InputClassifierInterface> getClassifier() = 0;

    virtual InputClassifierInterface& getClassifier() = 0;



    /* Gets the input dispatcher. */

    virtual sp<InputDispatcherInterface> getDispatcher() = 0;

    virtual InputDispatcherInterface& getDispatcher() = 0;

};



class InputManager : public InputManagerInterface, public BnInputFlinger {
@@ -96,9 +96,9 @@ public: 
    status_t start() override;

    status_t stop() override;



    sp<InputReaderInterface> getReader() override;

    sp<InputClassifierInterface> getClassifier() override;

    sp<InputDispatcherInterface> getDispatcher() override;

    InputReaderInterface& getReader() override;

    InputClassifierInterface& getClassifier() override;

    InputDispatcherInterface& getDispatcher() override;



    status_t dump(int fd, const Vector<String16>& args) override;

    binder::Status createInputChannel(const std::string& name, InputChannel* outChannel) override;
@@ -106,11 +106,11 @@ public: 
    binder::Status setFocusedWindow(const gui::FocusRequest&) override;



private:

    sp<InputReaderInterface> mReader;

    std::unique_ptr<InputReaderInterface> mReader;



    sp<InputClassifierInterface> mClassifier;

    std::unique_ptr<InputClassifierInterface> mClassifier;



    sp<InputDispatcherInterface> mDispatcher;

    std::unique_ptr<InputDispatcherInterface> mDispatcher;

};



} // namespace android