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

Commit ae4ff289 authored by Prabir Pradhan's avatar Prabir Pradhan
Browse files

Improve EventHub const-correctness 

Ensure that all methods that "get" state from event hub are
const-correct. While some "set" methods can also be const in event hub
because they write to the system (side effect) instead of changing
state, we leave these as non-const to make it easier for testing.

Bug: None
Test: atest inputflinger_tests
Change-Id: I086b50458203a2395b1960e2bc1102610a3c0801
parent cb42b471

include/input/KeyLayoutMap.h

+1 −1
Original line number Diff line number Diff line
@@ -78,7 +78,7 @@ public: 
    std::optional<AxisInfo> mapAxis(int32_t scanCode) const;

    const std::string getLoadFileName() const;

    // Return pair of sensor type and sensor data index, for the input device abs code

    base::Result<std::pair<InputDeviceSensorType, int32_t>> mapSensor(int32_t absCode);

    base::Result<std::pair<InputDeviceSensorType, int32_t>> mapSensor(int32_t absCode) const;



    virtual ~KeyLayoutMap();

libs/input/KeyLayoutMap.cpp

+2 −1
Original line number Diff line number Diff line
@@ -185,7 +185,8 @@ status_t KeyLayoutMap::mapKey(int32_t scanCode, int32_t usageCode, 
}



// Return pair of sensor type and sensor data index, for the input device abs code

base::Result<std::pair<InputDeviceSensorType, int32_t>> KeyLayoutMap::mapSensor(int32_t absCode) {

base::Result<std::pair<InputDeviceSensorType, int32_t>> KeyLayoutMap::mapSensor(

        int32_t absCode) const {

    auto it = mSensorsByAbsCode.find(absCode);

    if (it == mSensorsByAbsCode.end()) {

        ALOGD_IF(DEBUG_MAPPING, "mapSensor: absCode=%d, ~ Failed.", absCode);

services/inputflinger/reader/EventHub.cpp

+13 −12
Original line number Diff line number Diff line
@@ -1042,7 +1042,7 @@ status_t EventHub::mapAxis(int32_t deviceId, int32_t scanCode, AxisInfo* outAxis 
}



base::Result<std::pair<InputDeviceSensorType, int32_t>> EventHub::mapSensor(int32_t deviceId,

                                                                            int32_t absCode) {

                                                                            int32_t absCode) const {

    std::scoped_lock _l(mLock);

    Device* device = getDeviceLocked(deviceId);
@@ -1064,7 +1064,7 @@ const std::unordered_map<int32_t, RawBatteryInfo>& EventHub::getBatteryInfoLocke 
    return device->associatedDevice->batteryInfos;

}



const std::vector<int32_t> EventHub::getRawBatteryIds(int32_t deviceId) {

std::vector<int32_t> EventHub::getRawBatteryIds(int32_t deviceId) const {

    std::scoped_lock _l(mLock);

    std::vector<int32_t> batteryIds;
@@ -1075,7 +1075,8 @@ const std::vector<int32_t> EventHub::getRawBatteryIds(int32_t deviceId) { 
    return batteryIds;

}



std::optional<RawBatteryInfo> EventHub::getRawBatteryInfo(int32_t deviceId, int32_t batteryId) {

std::optional<RawBatteryInfo> EventHub::getRawBatteryInfo(int32_t deviceId,

                                                          int32_t batteryId) const {

    std::scoped_lock _l(mLock);



    const auto infos = getBatteryInfoLocked(deviceId);
@@ -1100,7 +1101,7 @@ const std::unordered_map<int32_t, RawLightInfo>& EventHub::getLightInfoLocked( 
    return device->associatedDevice->lightInfos;

}



const std::vector<int32_t> EventHub::getRawLightIds(int32_t deviceId) {

std::vector<int32_t> EventHub::getRawLightIds(int32_t deviceId) const {

    std::scoped_lock _l(mLock);

    std::vector<int32_t> lightIds;
@@ -1111,7 +1112,7 @@ const std::vector<int32_t> EventHub::getRawLightIds(int32_t deviceId) { 
    return lightIds;

}



std::optional<RawLightInfo> EventHub::getRawLightInfo(int32_t deviceId, int32_t lightId) {

std::optional<RawLightInfo> EventHub::getRawLightInfo(int32_t deviceId, int32_t lightId) const {

    std::scoped_lock _l(mLock);



    const auto infos = getLightInfoLocked(deviceId);
@@ -1124,7 +1125,7 @@ std::optional<RawLightInfo> EventHub::getRawLightInfo(int32_t deviceId, int32_t 
    return std::nullopt;

}



std::optional<int32_t> EventHub::getLightBrightness(int32_t deviceId, int32_t lightId) {

std::optional<int32_t> EventHub::getLightBrightness(int32_t deviceId, int32_t lightId) const {

    std::scoped_lock _l(mLock);



    const auto infos = getLightInfoLocked(deviceId);
@@ -1141,7 +1142,7 @@ std::optional<int32_t> EventHub::getLightBrightness(int32_t deviceId, int32_t li 
}



std::optional<std::unordered_map<LightColor, int32_t>> EventHub::getLightIntensities(

        int32_t deviceId, int32_t lightId) {

        int32_t deviceId, int32_t lightId) const {

    std::scoped_lock _l(mLock);



    const auto infos = getLightInfoLocked(deviceId);
@@ -1444,7 +1445,7 @@ void EventHub::cancelVibrate(int32_t deviceId) { 
    }

}



std::vector<int32_t> EventHub::getVibratorIds(int32_t deviceId) {

std::vector<int32_t> EventHub::getVibratorIds(int32_t deviceId) const {

    std::scoped_lock _l(mLock);

    std::vector<int32_t> vibrators;

    Device* device = getDeviceLocked(deviceId);
@@ -2295,7 +2296,7 @@ bool EventHub::tryAddVideoDeviceLocked(EventHub::Device& device, 
    return true;

}



bool EventHub::isDeviceEnabled(int32_t deviceId) {

bool EventHub::isDeviceEnabled(int32_t deviceId) const {

    std::scoped_lock _l(mLock);

    Device* device = getDeviceLocked(deviceId);

    if (device == nullptr) {
@@ -2519,7 +2520,7 @@ void EventHub::requestReopenDevices() { 
    mNeedToReopenDevices = true;

}



void EventHub::dump(std::string& dump) {

void EventHub::dump(std::string& dump) const {

    dump += "Event Hub State:\n";



    { // acquire lock
@@ -2573,9 +2574,9 @@ void EventHub::dump(std::string& dump) { 
    } // release lock

}



void EventHub::monitor() {

void EventHub::monitor() const {

    // Acquire and release the lock to ensure that the event hub has not deadlocked.

    std::unique_lock<std::mutex> lock(mLock);

}



}; // namespace android
 
} // namespace android

services/inputflinger/reader/include/EventHub.h

+26 −23
Original line number Diff line number Diff line
@@ -282,22 +282,23 @@ public: 
     */

    virtual size_t getEvents(int timeoutMillis, RawEvent* buffer, size_t bufferSize) = 0;

    virtual std::vector<TouchVideoFrame> getVideoFrames(int32_t deviceId) = 0;

    virtual base::Result<std::pair<InputDeviceSensorType, int32_t>> mapSensor(int32_t deviceId,

                                                                              int32_t absCode) = 0;

    virtual base::Result<std::pair<InputDeviceSensorType, int32_t>> mapSensor(

            int32_t deviceId, int32_t absCode) const = 0;

    // Raw batteries are sysfs power_supply nodes we found from the EventHub device sysfs node,

    // containing the raw info of the sysfs node structure.

    virtual const std::vector<int32_t> getRawBatteryIds(int32_t deviceId) = 0;

    virtual std::vector<int32_t> getRawBatteryIds(int32_t deviceId) const = 0;

    virtual std::optional<RawBatteryInfo> getRawBatteryInfo(int32_t deviceId,

                                                            int32_t BatteryId) = 0;

                                                            int32_t BatteryId) const = 0;



    // Raw lights are sysfs led light nodes we found from the EventHub device sysfs node,

    // containing the raw info of the sysfs node structure.

    virtual const std::vector<int32_t> getRawLightIds(int32_t deviceId) = 0;

    virtual std::optional<RawLightInfo> getRawLightInfo(int32_t deviceId, int32_t lightId) = 0;

    virtual std::optional<int32_t> getLightBrightness(int32_t deviceId, int32_t lightId) = 0;

    virtual std::vector<int32_t> getRawLightIds(int32_t deviceId) const = 0;

    virtual std::optional<RawLightInfo> getRawLightInfo(int32_t deviceId,

                                                        int32_t lightId) const = 0;

    virtual std::optional<int32_t> getLightBrightness(int32_t deviceId, int32_t lightId) const = 0;

    virtual void setLightBrightness(int32_t deviceId, int32_t lightId, int32_t brightness) = 0;

    virtual std::optional<std::unordered_map<LightColor, int32_t>> getLightIntensities(

            int32_t deviceId, int32_t lightId) = 0;

            int32_t deviceId, int32_t lightId) const = 0;

    virtual void setLightIntensities(int32_t deviceId, int32_t lightId,

                                     std::unordered_map<LightColor, int32_t> intensities) = 0;

    /*
@@ -333,7 +334,7 @@ public: 
    /* Control the vibrator. */

    virtual void vibrate(int32_t deviceId, const VibrationElement& effect) = 0;

    virtual void cancelVibrate(int32_t deviceId) = 0;

    virtual std::vector<int32_t> getVibratorIds(int32_t deviceId) = 0;

    virtual std::vector<int32_t> getVibratorIds(int32_t deviceId) const = 0;



    /* Query battery level. */

    virtual std::optional<int32_t> getBatteryCapacity(int32_t deviceId,
@@ -349,13 +350,13 @@ public: 
    virtual void wake() = 0;



    /* Dump EventHub state to a string. */

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

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



    /* Called by the heatbeat to ensures that the reader has not deadlocked. */

    virtual void monitor() = 0;

    virtual void monitor() const = 0;



    /* Return true if the device is enabled. */

    virtual bool isDeviceEnabled(int32_t deviceId) = 0;

    virtual bool isDeviceEnabled(int32_t deviceId) const = 0;



    /* Enable an input device */

    virtual status_t enableDevice(int32_t deviceId) = 0;
@@ -463,20 +464,22 @@ public: 
                     AxisInfo* outAxisInfo) const override final;



    base::Result<std::pair<InputDeviceSensorType, int32_t>> mapSensor(

            int32_t deviceId, int32_t absCode) override final;

            int32_t deviceId, int32_t absCode) const override final;



    const std::vector<int32_t> getRawBatteryIds(int32_t deviceId) override final;

    std::vector<int32_t> getRawBatteryIds(int32_t deviceId) const override final;

    std::optional<RawBatteryInfo> getRawBatteryInfo(int32_t deviceId,

                                                    int32_t BatteryId) override final;

                                                    int32_t BatteryId) const override final;



    const std::vector<int32_t> getRawLightIds(int32_t deviceId) override final;

    std::vector<int32_t> getRawLightIds(int32_t deviceId) const override final;



    std::optional<RawLightInfo> getRawLightInfo(int32_t deviceId, int32_t lightId) override final;

    std::optional<RawLightInfo> getRawLightInfo(int32_t deviceId,

                                                int32_t lightId) const override final;



    std::optional<int32_t> getLightBrightness(int32_t deviceId, int32_t lightId) override final;

    std::optional<int32_t> getLightBrightness(int32_t deviceId,

                                              int32_t lightId) const override final;

    void setLightBrightness(int32_t deviceId, int32_t lightId, int32_t brightness) override final;

    std::optional<std::unordered_map<LightColor, int32_t>> getLightIntensities(

            int32_t deviceId, int32_t lightId) override final;

            int32_t deviceId, int32_t lightId) const override final;

    void setLightIntensities(int32_t deviceId, int32_t lightId,

                             std::unordered_map<LightColor, int32_t> intensities) override final;
@@ -512,15 +515,15 @@ public: 


    void vibrate(int32_t deviceId, const VibrationElement& effect) override final;

    void cancelVibrate(int32_t deviceId) override final;

    std::vector<int32_t> getVibratorIds(int32_t deviceId) override final;

    std::vector<int32_t> getVibratorIds(int32_t deviceId) const override final;



    void requestReopenDevices() override final;



    void wake() override final;



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

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



    void monitor() override final;

    void monitor() const override final;



    std::optional<int32_t> getBatteryCapacity(int32_t deviceId,

                                              int32_t batteryId) const override final;
@@ -528,7 +531,7 @@ public: 
    std::optional<int32_t> getBatteryStatus(int32_t deviceId,

                                            int32_t batteryId) const override final;



    bool isDeviceEnabled(int32_t deviceId) override final;

    bool isDeviceEnabled(int32_t deviceId) const override final;



    status_t enableDevice(int32_t deviceId) override final;

services/inputflinger/tests/InputReader_test.cpp

+15 −18
Original line number Diff line number Diff line
@@ -509,7 +509,7 @@ public: 
        enqueueEvent(ARBITRARY_TIME, READ_TIME, deviceId, EventHubInterface::DEVICE_REMOVED, 0, 0);

    }



    bool isDeviceEnabled(int32_t deviceId) {

    bool isDeviceEnabled(int32_t deviceId) const override {

        Device* device = getDevice(deviceId);

        if (device == nullptr) {

            ALOGE("Incorrect device id=%" PRId32 " provided to %s", deviceId, __func__);
@@ -518,7 +518,7 @@ public: 
        return device->enabled;

    }



    status_t enableDevice(int32_t deviceId) {

    status_t enableDevice(int32_t deviceId) override {

        status_t result;

        Device* device = getDevice(deviceId);

        if (device == nullptr) {
@@ -533,7 +533,7 @@ public: 
        return result;

    }



    status_t disableDevice(int32_t deviceId) {

    status_t disableDevice(int32_t deviceId) override {

        Device* device = getDevice(deviceId);

        if (device == nullptr) {

            ALOGE("Incorrect device id=%" PRId32 " provided to %s", deviceId, __func__);
@@ -795,8 +795,8 @@ private: 


    status_t mapAxis(int32_t, int32_t, AxisInfo*) const override { return NAME_NOT_FOUND; }



    base::Result<std::pair<InputDeviceSensorType, int32_t>> mapSensor(int32_t deviceId,

                                                                      int32_t absCode) {

    base::Result<std::pair<InputDeviceSensorType, int32_t>> mapSensor(

            int32_t deviceId, int32_t absCode) const override {

        Device* device = getDevice(deviceId);

        if (!device) {

            return Errorf("Sensor device not found.");
@@ -981,7 +981,7 @@ private: 


    void cancelVibrate(int32_t) override {}



    std::vector<int32_t> getVibratorIds(int32_t deviceId) override { return mVibrators; };

    std::vector<int32_t> getVibratorIds(int32_t deviceId) const override { return mVibrators; };



    std::optional<int32_t> getBatteryCapacity(int32_t, int32_t) const override {

        return BATTERY_CAPACITY;
@@ -991,13 +991,14 @@ private: 
        return BATTERY_STATUS;

    }



    const std::vector<int32_t> getRawBatteryIds(int32_t deviceId) { return {}; }

    std::vector<int32_t> getRawBatteryIds(int32_t deviceId) const override { return {}; }



    std::optional<RawBatteryInfo> getRawBatteryInfo(int32_t deviceId, int32_t batteryId) {

    std::optional<RawBatteryInfo> getRawBatteryInfo(int32_t deviceId,

                                                    int32_t batteryId) const override {

        return std::nullopt;

    }



    const std::vector<int32_t> getRawLightIds(int32_t deviceId) override {

    std::vector<int32_t> getRawLightIds(int32_t deviceId) const override {

        std::vector<int32_t> ids;

        for (const auto& [rawId, info] : mRawLightInfos) {

            ids.push_back(rawId);
@@ -1005,7 +1006,7 @@ private: 
        return ids;

    }



    std::optional<RawLightInfo> getRawLightInfo(int32_t deviceId, int32_t lightId) override {

    std::optional<RawLightInfo> getRawLightInfo(int32_t deviceId, int32_t lightId) const override {

        auto it = mRawLightInfos.find(lightId);

        if (it == mRawLightInfos.end()) {

            return std::nullopt;
@@ -1022,7 +1023,7 @@ private: 
        mLightIntensities.emplace(lightId, intensities);

    };



    std::optional<int32_t> getLightBrightness(int32_t deviceId, int32_t lightId) override {

    std::optional<int32_t> getLightBrightness(int32_t deviceId, int32_t lightId) const override {

        auto lightIt = mLightBrightness.find(lightId);

        if (lightIt == mLightBrightness.end()) {

            return std::nullopt;
@@ -1031,7 +1032,7 @@ private: 
    }



    std::optional<std::unordered_map<LightColor, int32_t>> getLightIntensities(

            int32_t deviceId, int32_t lightId) override {

            int32_t deviceId, int32_t lightId) const override {

        auto lightIt = mLightIntensities.find(lightId);

        if (lightIt == mLightIntensities.end()) {

            return std::nullopt;
@@ -1039,13 +1040,9 @@ private: 
        return lightIt->second;

    };



    virtual bool isExternal(int32_t) const {

        return false;

    }



    void dump(std::string&) override {}

    void dump(std::string&) const override {}



    void monitor() override {}

    void monitor() const override {}



    void requestReopenDevices() override {}