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

Commit b70a4325 authored by Treehugger Robot's avatar Treehugger Robot Committed by Gerrit Code Review
Browse files

Merge "Use std::filesystem for input event devices scan."

parents d40d76a7 db924707

services/inputflinger/reader/Android.bp

+3 −0
Original line number Diff line number Diff line
@@ -90,4 +90,7 @@ cc_library_shared { 
    export_header_lib_headers: [

        "libinputreader_headers",

    ],

    static_libs: [

        "libc++fs"

    ],

}

services/inputflinger/reader/EventHub.cpp

+33 −57
Original line number Diff line number Diff line
@@ -34,20 +34,20 @@ 
#define LOG_TAG "EventHub"



// #define LOG_NDEBUG 0



#include "EventHub.h"



#include <android-base/stringprintf.h>

#include <cutils/properties.h>

#include <input/KeyCharacterMap.h>

#include <input/KeyLayoutMap.h>

#include <input/VirtualKeyMap.h>

#include <openssl/sha.h>

#include <utils/Errors.h>

#include <utils/Log.h>

#include <utils/Timers.h>

#include <utils/threads.h>



#include <input/KeyCharacterMap.h>

#include <input/KeyLayoutMap.h>

#include <input/VirtualKeyMap.h>

#include <filesystem>



#include "EventHub.h"



/* this macro is used to tell if "bit" is set in "array"

 * it selects a byte from the array, and does a boolean AND
@@ -94,8 +94,8 @@ static std::string sha1(const std::string& in) { 
/**

 * Return true if name matches "v4l-touch*"

 */

static bool isV4lTouchNode(const char* name) {

    return strstr(name, "v4l-touch") == name;

static bool isV4lTouchNode(std::string name) {

    return name.find("v4l-touch") != std::string::npos;

}



/**
@@ -810,7 +810,7 @@ EventHub::Device* EventHub::getDeviceLocked(int32_t deviceId) const { 
    return index >= 0 ? mDevices.valueAt(index) : NULL;

}



EventHub::Device* EventHub::getDeviceByPathLocked(const char* devicePath) const {

EventHub::Device* EventHub::getDeviceByPathLocked(const std::string& devicePath) const {

    for (size_t i = 0; i < mDevices.size(); i++) {

        Device* device = mDevices.valueAt(i);

        if (device->path == devicePath) {
@@ -1215,14 +1215,14 @@ void EventHub::unregisterVideoDeviceFromEpollLocked(const TouchVideoDevice& vide 
    }

}



status_t EventHub::openDeviceLocked(const char* devicePath) {

status_t EventHub::openDeviceLocked(const std::string& devicePath) {

    char buffer[80];



    ALOGV("Opening device: %s", devicePath);

    ALOGV("Opening device: %s", devicePath.c_str());



    int fd = open(devicePath, O_RDWR | O_CLOEXEC | O_NONBLOCK);

    int fd = open(devicePath.c_str(), O_RDWR | O_CLOEXEC | O_NONBLOCK);

    if (fd < 0) {

        ALOGE("could not open %s, %s\n", devicePath, strerror(errno));

        ALOGE("could not open %s, %s\n", devicePath.c_str(), strerror(errno));

        return -1;

    }
@@ -1230,7 +1230,7 @@ status_t EventHub::openDeviceLocked(const char* devicePath) { 


    // Get device name.

    if (ioctl(fd, EVIOCGNAME(sizeof(buffer) - 1), &buffer) < 1) {

        ALOGE("Could not get device name for %s: %s", devicePath, strerror(errno));

        ALOGE("Could not get device name for %s: %s", devicePath.c_str(), strerror(errno));

    } else {

        buffer[sizeof(buffer) - 1] = '\0';

        identifier.name = buffer;
@@ -1240,7 +1240,7 @@ status_t EventHub::openDeviceLocked(const char* devicePath) { 
    for (size_t i = 0; i < mExcludedDevices.size(); i++) {

        const std::string& item = mExcludedDevices[i];

        if (identifier.name == item) {

            ALOGI("ignoring event id %s driver %s\n", devicePath, item.c_str());

            ALOGI("ignoring event id %s driver %s\n", devicePath.c_str(), item.c_str());

            close(fd);

            return -1;

        }
@@ -1249,7 +1249,7 @@ status_t EventHub::openDeviceLocked(const char* devicePath) { 
    // Get device driver version.

    int driverVersion;

    if (ioctl(fd, EVIOCGVERSION, &driverVersion)) {

        ALOGE("could not get driver version for %s, %s\n", devicePath, strerror(errno));

        ALOGE("could not get driver version for %s, %s\n", devicePath.c_str(), strerror(errno));

        close(fd);

        return -1;

    }
@@ -1257,7 +1257,7 @@ status_t EventHub::openDeviceLocked(const char* devicePath) { 
    // Get device identifier.

    struct input_id inputId;

    if (ioctl(fd, EVIOCGID, &inputId)) {

        ALOGE("could not get device input id for %s, %s\n", devicePath, strerror(errno));

        ALOGE("could not get device input id for %s, %s\n", devicePath.c_str(), strerror(errno));

        close(fd);

        return -1;

    }
@@ -1289,7 +1289,7 @@ status_t EventHub::openDeviceLocked(const char* devicePath) { 
    int32_t deviceId = mNextDeviceId++;

    Device* device = new Device(fd, deviceId, devicePath, identifier);



    ALOGV("add device %d: %s\n", deviceId, devicePath);

    ALOGV("add device %d: %s\n", deviceId, devicePath.c_str());

    ALOGV("  bus:        %04x\n"

          "  vendor      %04x\n"

          "  product     %04x\n"
@@ -1446,7 +1446,7 @@ status_t EventHub::openDeviceLocked(const char* devicePath) { 


    // If the device isn't recognized as something we handle, don't monitor it.

    if (device->classes == 0) {

        ALOGV("Dropping device: id=%d, path='%s', name='%s'", deviceId, devicePath,

        ALOGV("Dropping device: id=%d, path='%s', name='%s'", deviceId, devicePath.c_str(),

              device->identifier.name.c_str());

        delete device;

        return -1;
@@ -1492,7 +1492,7 @@ status_t EventHub::openDeviceLocked(const char* devicePath) { 


    ALOGI("New device: id=%d, fd=%d, path='%s', name='%s', classes=0x%x, "

          "configuration='%s', keyLayout='%s', keyCharacterMap='%s', builtinKeyboard=%s, ",

          deviceId, fd, devicePath, device->identifier.name.c_str(), device->classes,

          deviceId, fd, devicePath.c_str(), device->identifier.name.c_str(), device->classes,

          device->configurationFile.c_str(), device->keyMap.keyLayoutFile.c_str(),

          device->keyMap.keyCharacterMapFile.c_str(), toString(mBuiltInKeyboardId == deviceId));
@@ -1724,13 +1724,13 @@ status_t EventHub::mapLed(Device* device, int32_t led, int32_t* outScanCode) con 
    return NAME_NOT_FOUND;

}



void EventHub::closeDeviceByPathLocked(const char* devicePath) {

void EventHub::closeDeviceByPathLocked(const std::string& devicePath) {

    Device* device = getDeviceByPathLocked(devicePath);

    if (device) {

        closeDeviceLocked(device);

        return;

    }

    ALOGV("Remove device: %s not found, device may already have been removed.", devicePath);

    ALOGV("Remove device: %s not found, device may already have been removed.", devicePath.c_str());

}



/**
@@ -1835,16 +1835,16 @@ status_t EventHub::readNotifyLocked() { 
        event = (struct inotify_event*)(event_buf + event_pos);

        if (event->len) {

            if (event->wd == mInputWd) {

                std::string filename = StringPrintf("%s/%s", DEVICE_PATH, event->name);

                std::string filename = std::string(DEVICE_PATH) + "/" + event->name;

                if (event->mask & IN_CREATE) {

                    openDeviceLocked(filename.c_str());

                    openDeviceLocked(filename);

                } else {

                    ALOGI("Removing device '%s' due to inotify event\n", filename.c_str());

                    closeDeviceByPathLocked(filename.c_str());

                    closeDeviceByPathLocked(filename);

                }

            } else if (event->wd == mVideoWd) {

                if (isV4lTouchNode(event->name)) {

                    std::string filename = StringPrintf("%s/%s", VIDEO_DEVICE_PATH, event->name);

                    std::string filename = std::string(VIDEO_DEVICE_PATH) + "/" + event->name;

                    if (event->mask & IN_CREATE) {

                        openVideoDeviceLocked(filename);

                    } else {
@@ -1863,24 +1863,10 @@ status_t EventHub::readNotifyLocked() { 
    return 0;

}



status_t EventHub::scanDirLocked(const char* dirname) {

    char devname[PATH_MAX];

    char* filename;

    DIR* dir;

    struct dirent* de;

    dir = opendir(dirname);

    if (dir == nullptr) return -1;

    strcpy(devname, dirname);

    filename = devname + strlen(devname);

    *filename++ = '/';

    while ((de = readdir(dir))) {

        if (de->d_name[0] == '.' &&

            (de->d_name[1] == '\0' || (de->d_name[1] == '.' && de->d_name[2] == '\0')))

            continue;

        strcpy(filename, de->d_name);

        openDeviceLocked(devname);

status_t EventHub::scanDirLocked(const std::string& dirname) {

    for (const auto& entry : std::filesystem::directory_iterator(dirname)) {

        openDeviceLocked(entry.path());

    }

    closedir(dir);

    return 0;

}
@@ -1888,22 +1874,12 @@ status_t EventHub::scanDirLocked(const char* dirname) { 
 * Look for all dirname/v4l-touch* devices, and open them.

 */

status_t EventHub::scanVideoDirLocked(const std::string& dirname) {

    DIR* dir;

    struct dirent* de;

    dir = opendir(dirname.c_str());

    if (!dir) {

        ALOGE("Could not open video directory %s", dirname.c_str());

        return BAD_VALUE;

    }



    while ((de = readdir(dir))) {

        const char* name = de->d_name;

        if (isV4lTouchNode(name)) {

            ALOGI("Found touch video device %s", name);

            openVideoDeviceLocked(dirname + "/" + name);

    for (const auto& entry : std::filesystem::directory_iterator(dirname)) {

        if (isV4lTouchNode(entry.path())) {

            ALOGI("Found touch video device %s", entry.path().c_str());

            openVideoDeviceLocked(entry.path());

        }

    }

    closedir(dir);

    return OK;

}

services/inputflinger/reader/include/EventHub.h

+4 −4
Original line number Diff line number Diff line
@@ -373,13 +373,13 @@ private: 
        }

    };



    status_t openDeviceLocked(const char* devicePath);

    status_t openDeviceLocked(const std::string& devicePath);

    void openVideoDeviceLocked(const std::string& devicePath);

    void createVirtualKeyboardLocked();

    void addDeviceLocked(Device* device);

    void assignDescriptorLocked(InputDeviceIdentifier& identifier);



    void closeDeviceByPathLocked(const char* devicePath);

    void closeDeviceByPathLocked(const std::string& devicePath);

    void closeVideoDeviceByPathLocked(const std::string& devicePath);

    void closeDeviceLocked(Device* device);

    void closeAllDevicesLocked();
@@ -396,14 +396,14 @@ private: 
    status_t unregisterDeviceFromEpollLocked(Device* device);

    void unregisterVideoDeviceFromEpollLocked(const TouchVideoDevice& videoDevice);



    status_t scanDirLocked(const char* dirname);

    status_t scanDirLocked(const std::string& dirname);

    status_t scanVideoDirLocked(const std::string& dirname);

    void scanDevicesLocked();

    status_t readNotifyLocked();



    Device* getDeviceByDescriptorLocked(const std::string& descriptor) const;

    Device* getDeviceLocked(int32_t deviceId) const;

    Device* getDeviceByPathLocked(const char* devicePath) const;

    Device* getDeviceByPathLocked(const std::string& devicePath) const;

    /**

     * Look through all available fd's (both for input devices and for video devices),

     * and return the device pointer.

services/inputflinger/tests/Android.bp

+3 −0
Original line number Diff line number Diff line
@@ -46,5 +46,8 @@ cc_test { 
        "InputReader_test.cpp",

        "UinputDevice.cpp",

    ],

    static_libs: [

        "libc++fs"

    ],

    require_root: true,

}