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

Commit 06aeb41c authored by Mark Salyzyn's avatar Mark Salyzyn
Browse files

init: turn keychords into a standalone class 

Test: init_tests
Bug: 64114943
Change-Id: Ie760e4a3a661260ed2aabb8a92fe65fc93521cb5
parent eca25076

init/init.cpp

+4 −3
Original line number Diff line number Diff line
@@ -749,12 +749,13 @@ int main(int argc, char** argv) { 
    am.QueueBuiltinAction(MixHwrngIntoLinuxRngAction, "MixHwrngIntoLinuxRng");

    am.QueueBuiltinAction(SetMmapRndBitsAction, "SetMmapRndBits");

    am.QueueBuiltinAction(SetKptrRestrictAction, "SetKptrRestrict");

    Keychords keychords;

    am.QueueBuiltinAction(

        [&epoll](const BuiltinArguments& args) -> Result<Success> {

        [&epoll, &keychords](const BuiltinArguments& args) -> Result<Success> {

            for (const auto& svc : ServiceList::GetInstance()) {

                svc->set_keychord_id(GetKeychordId(svc->keycodes()));

                svc->set_keychord_id(keychords.GetId(svc->keycodes()));

            }

            KeychordInit(&epoll, HandleKeychord);

            keychords.Start(&epoll, HandleKeychord);

            return Success();

        },

        "KeychordInit");

init/keychords.cpp

+109 −120
Original line number Diff line number Diff line
@@ -37,95 +37,85 @@ 
namespace android {

namespace init {



namespace {

Keychords::Keychords() : epoll_(nullptr), count_(0), inotify_fd_(-1) {}



int keychords_count;

Epoll* epoll;

std::function<void(int)> handle_keychord;



struct KeychordEntry {

    const std::vector<int> keycodes;

    bool notified;

    int id;



    KeychordEntry(const std::vector<int>& keycodes, int id)

        : keycodes(keycodes), notified(false), id(id) {}

};



std::vector<KeychordEntry> keychord_entries;



// Bit management

class KeychordMask {

  private:

    typedef unsigned int mask_t;

    std::vector<mask_t> bits;

    static constexpr size_t bits_per_byte = 8;

Keychords::~Keychords() noexcept {

    if (inotify_fd_ >= 0) {

        epoll_->UnregisterHandler(inotify_fd_);

        ::close(inotify_fd_);

    }

    while (!registration_.empty()) GeteventCloseDevice(registration_.begin()->first);

}



  public:

    explicit KeychordMask(size_t bit = 0) : bits((bit + sizeof(mask_t) - 1) / sizeof(mask_t), 0) {}

Keychords::Mask::Mask(size_t bit) : bits_((bit + sizeof(mask_t) - 1) / sizeof(mask_t), 0) {}



    void SetBit(size_t bit, bool value = true) {

        auto idx = bit / (bits_per_byte * sizeof(mask_t));

        if (idx >= bits.size()) return;

void Keychords::Mask::SetBit(size_t bit, bool value) {

    auto idx = bit / (kBitsPerByte * sizeof(mask_t));

    if (idx >= bits_.size()) return;

    if (value) {

            bits[idx] |= mask_t(1) << (bit % (bits_per_byte * sizeof(mask_t)));

        bits_[idx] |= mask_t(1) << (bit % (kBitsPerByte * sizeof(mask_t)));

    } else {

            bits[idx] &= ~(mask_t(1) << (bit % (bits_per_byte * sizeof(mask_t))));

        bits_[idx] &= ~(mask_t(1) << (bit % (kBitsPerByte * sizeof(mask_t))));

    }

}



bool Keychords::Mask::GetBit(size_t bit) const {

    auto idx = bit / (kBitsPerByte * sizeof(mask_t));

    return bits_[idx] & (mask_t(1) << (bit % (kBitsPerByte * sizeof(mask_t))));

}



    bool GetBit(size_t bit) const {

        auto idx = bit / (bits_per_byte * sizeof(mask_t));

        return bits[idx] & (mask_t(1) << (bit % (bits_per_byte * sizeof(mask_t))));

size_t Keychords::Mask::bytesize() const {

    return bits_.size() * sizeof(mask_t);

}



    size_t bytesize() const { return bits.size() * sizeof(mask_t); }

    void* data() { return bits.data(); }

    size_t size() const { return bits.size() * sizeof(mask_t) * bits_per_byte; }

    void resize(size_t bit) {

        auto idx = bit / (bits_per_byte * sizeof(mask_t));

        if (idx >= bits.size()) {

            bits.resize(idx + 1, 0);

void* Keychords::Mask::data() {

    return bits_.data();

}



size_t Keychords::Mask::size() const {

    return bits_.size() * sizeof(mask_t) * kBitsPerByte;

}



    operator bool() const {

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

            if (bits[i]) return true;

void Keychords::Mask::resize(size_t bit) {

    auto idx = bit / (kBitsPerByte * sizeof(mask_t));

    if (idx >= bits_.size()) {

        bits_.resize(idx + 1, 0);

    }

}



Keychords::Mask::operator bool() const {

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

        if (bits_[i]) return true;

    }

    return false;

}



    KeychordMask operator&(const KeychordMask& rval) const {

        auto len = std::min(bits.size(), rval.bits.size());

        KeychordMask ret;

        ret.bits.resize(len);

Keychords::Mask Keychords::Mask::operator&(const Keychords::Mask& rval) const {

    auto len = std::min(bits_.size(), rval.bits_.size());

    Keychords::Mask ret;

    ret.bits_.resize(len);

    for (size_t i = 0; i < len; ++i) {

            ret.bits[i] = bits[i] & rval.bits[i];

        ret.bits_[i] = bits_[i] & rval.bits_[i];

    }

    return ret;

}



    void operator|=(const KeychordMask& rval) {

        size_t len = rval.bits.size();

        bits.resize(len);

void Keychords::Mask::operator|=(const Keychords::Mask& rval) {

    auto len = rval.bits_.size();

    bits_.resize(len);

    for (size_t i = 0; i < len; ++i) {

            bits[i] |= rval.bits[i];

        bits_[i] |= rval.bits_[i];

    }

}

};



KeychordMask keychord_current;



constexpr char kDevicePath[] = "/dev/input";

Keychords::Entry::Entry(const std::vector<int>& keycodes, int id)

    : keycodes(keycodes), id(id), notified(false) {}



std::map<std::string, int> keychord_registration;



void KeychordLambdaCheck() {

    for (auto& e : keychord_entries) {

        bool found = true;

void Keychords::LambdaCheck() {

    for (auto& e : entries_) {

        auto found = true;

        for (auto& code : e.keycodes) {

            if (!keychord_current.GetBit(code)) {

            if (!current_.GetBit(code)) {

                e.notified = false;

                found = false;

                break;
@@ -134,19 +124,19 @@ void KeychordLambdaCheck() { 
        if (!found) continue;

        if (e.notified) continue;

        e.notified = true;

        handle_keychord(e.id);

        handler_(e.id);

    }

}



void KeychordLambdaHandler(int fd) {

void Keychords::LambdaHandler(int fd) {

    input_event event;

    auto res = TEMP_FAILURE_RETRY(::read(fd, &event, sizeof(event)));

    if ((res != sizeof(event)) || (event.type != EV_KEY)) return;

    keychord_current.SetBit(event.code, event.value);

    KeychordLambdaCheck();

    current_.SetBit(event.code, event.value);

    LambdaCheck();

}



bool KeychordGeteventEnable(int fd) {

bool Keychords::GeteventEnable(int fd) {

    // Make sure it is an event channel, should pass this ioctl call

    int version;

    if (::ioctl(fd, EVIOCGVERSION, &version)) return false;
@@ -154,7 +144,7 @@ bool KeychordGeteventEnable(int fd) { 
#ifdef EVIOCSMASK

    static auto EviocsmaskSupported = true;

    if (EviocsmaskSupported) {

        KeychordMask mask(EV_KEY);

        Keychords::Mask mask(EV_KEY);

        mask.SetBit(EV_KEY);

        input_mask msg = {};

        msg.type = EV_SYN;
@@ -167,16 +157,16 @@ bool KeychordGeteventEnable(int fd) { 
    }

#endif



    KeychordMask mask;

    for (auto& e : keychord_entries) {

    Keychords::Mask mask;

    for (auto& e : entries_) {

        for (auto& code : e.keycodes) {

            mask.resize(code);

            mask.SetBit(code);

        }

    }



    keychord_current.resize(mask.size());

    KeychordMask available(mask.size());

    current_.resize(mask.size());

    Keychords::Mask available(mask.size());

    auto res = ::ioctl(fd, EVIOCGBIT(EV_KEY, available.bytesize()), available.data());

    if (res == -1) return false;

    if (!(available & mask)) return false;
@@ -191,45 +181,43 @@ bool KeychordGeteventEnable(int fd) { 
    }

#endif



    KeychordMask set(mask.size());

    Keychords::Mask set(mask.size());

    res = ::ioctl(fd, EVIOCGKEY(res), set.data());

    if (res > 0) {

        keychord_current |= mask & available & set;

        KeychordLambdaCheck();

        current_ |= mask & available & set;

        LambdaCheck();

    }

    epoll->RegisterHandler(fd, [fd]() { KeychordLambdaHandler(fd); });

    epoll_->RegisterHandler(fd, [this, fd]() { this->LambdaHandler(fd); });

    return true;

}



void GeteventOpenDevice(const std::string& device) {

    if (keychord_registration.count(device)) return;

void Keychords::GeteventOpenDevice(const std::string& device) {

    if (registration_.count(device)) return;

    auto fd = TEMP_FAILURE_RETRY(::open(device.c_str(), O_RDWR | O_CLOEXEC));

    if (fd == -1) {

        PLOG(ERROR) << "Can not open " << device;

        return;

    }

    if (!KeychordGeteventEnable(fd)) {

    if (!GeteventEnable(fd)) {

        ::close(fd);

    } else {

        keychord_registration.emplace(device, fd);

        registration_.emplace(device, fd);

    }

}



void GeteventCloseDevice(const std::string& device) {

    auto it = keychord_registration.find(device);

    if (it == keychord_registration.end()) return;

void Keychords::GeteventCloseDevice(const std::string& device) {

    auto it = registration_.find(device);

    if (it == registration_.end()) return;

    auto fd = (*it).second;

    epoll->UnregisterHandler(fd);

    keychord_registration.erase(it);

    epoll_->UnregisterHandler(fd);

    registration_.erase(it);

    ::close(fd);

}



int inotify_fd = -1;



void InotifyHandler() {

    unsigned char buf[512];

void Keychords::InotifyHandler() {

    unsigned char buf[512];  // History shows 32-64 bytes typical



    auto res = TEMP_FAILURE_RETRY(::read(inotify_fd, buf, sizeof(buf)));

    auto res = TEMP_FAILURE_RETRY(::read(inotify_fd_, buf, sizeof(buf)));

    if (res < 0) {

        PLOG(WARNING) << "could not get event";

        return;
@@ -255,14 +243,15 @@ void InotifyHandler() { 
    }

}



void GeteventOpenDevice() {

    inotify_fd = ::inotify_init1(IN_NONBLOCK | IN_CLOEXEC);

    if (inotify_fd < 0) {

void Keychords::GeteventOpenDevice() {

    inotify_fd_ = ::inotify_init1(IN_NONBLOCK | IN_CLOEXEC);

    if (inotify_fd_ < 0) {

        PLOG(WARNING) << "Could not instantiate inotify for " << kDevicePath;

    } else if (::inotify_add_watch(inotify_fd, kDevicePath, IN_DELETE | IN_CREATE | IN_ONLYDIR) < 0) {

    } else if (::inotify_add_watch(inotify_fd_, kDevicePath, IN_DELETE | IN_CREATE | IN_ONLYDIR) <

               0) {

        PLOG(WARNING) << "Could not add watch for " << kDevicePath;

        ::close(inotify_fd);

        inotify_fd = -1;

        ::close(inotify_fd_);

        inotify_fd_ = -1;

    }



    std::unique_ptr<DIR, decltype(&closedir)> device(opendir(kDevicePath), closedir);
@@ -277,22 +266,22 @@ void GeteventOpenDevice() { 
        }

    }



    if (inotify_fd >= 0) epoll->RegisterHandler(inotify_fd, InotifyHandler);

    if (inotify_fd_ >= 0) {

        epoll_->RegisterHandler(inotify_fd_, [this]() { this->InotifyHandler(); });

    }

}



}  // namespace



int GetKeychordId(const std::vector<int>& keycodes) {

int Keychords::GetId(const std::vector<int>& keycodes) {

    if (keycodes.empty()) return 0;

    ++keychords_count;

    keychord_entries.emplace_back(KeychordEntry(keycodes, keychords_count));

    return keychords_count;

    ++count_;

    entries_.emplace_back(Entry(keycodes, count_));

    return count_;

}



void KeychordInit(Epoll* init_epoll, std::function<void(int)> handler) {

    epoll = init_epoll;

    handle_keychord = handler;

    if (keychords_count) GeteventOpenDevice();

void Keychords::Start(Epoll* epoll, std::function<void(int)> handler) {

    epoll_ = epoll;

    handler_ = handler;

    if (count_) GeteventOpenDevice();

}



}  // namespace init

init/keychords.h

+70 −2
Original line number Diff line number Diff line
@@ -18,6 +18,8 @@ 
#define _INIT_KEYCHORDS_H_



#include <functional>

#include <map>

#include <string>

#include <vector>



#include "epoll.h"
@@ -25,8 +27,74 @@ 
namespace android {

namespace init {



void KeychordInit(Epoll* init_epoll, std::function<void(int)> handler);

int GetKeychordId(const std::vector<int>& keycodes);

class Keychords {

  public:

    Keychords();

    Keychords(const Keychords&) = delete;

    Keychords(Keychords&&) = delete;

    Keychords& operator=(const Keychords&) = delete;

    Keychords& operator=(Keychords&&) = delete;

    ~Keychords() noexcept;



    int GetId(const std::vector<int>& keycodes);

    void Start(Epoll* epoll, std::function<void(int)> handler);



  private:

    // Bit management

    class Mask {

      public:

        explicit Mask(size_t bit = 0);



        void SetBit(size_t bit, bool value = true);

        bool GetBit(size_t bit) const;



        size_t bytesize() const;

        void* data();

        size_t size() const;

        void resize(size_t bit);



        operator bool() const;

        Mask operator&(const Mask& rval) const;

        void operator|=(const Mask& rval);



      private:

        typedef unsigned int mask_t;

        static constexpr size_t kBitsPerByte = 8;



        std::vector<mask_t> bits_;

    };



    struct Entry {

        Entry(const std::vector<int>& keycodes, int id);



        const std::vector<int> keycodes;

        const int id;

        bool notified;

    };



    static constexpr char kDevicePath[] = "/dev/input";



    void LambdaCheck();

    void LambdaHandler(int fd);

    void InotifyHandler();



    bool GeteventEnable(int fd);

    void GeteventOpenDevice(const std::string& device);

    void GeteventOpenDevice();

    void GeteventCloseDevice(const std::string& device);



    Epoll* epoll_;

    std::function<void(int)> handler_;



    std::map<std::string, int> registration_;



    int count_;

    std::vector<Entry> entries_;



    Mask current_;



    int inotify_fd_;

};



}  // namespace init

}  // namespace android