MuditaOS/module-gui/gui/input/Translator.cpp

#include "Translator.hpp"
#include "log/log.hpp"
#include "vfs.hpp"
#include <algorithm>

namespace gui
{

    void recon_long_press(InputEvent &evt, const RawKey &key, const RawKey &prev_key_press, uint32_t time)
    {
        if (key.state == RawKey::State::Released && prev_key_press.key_code == key.key_code) {
            // determine long press
            if (key.time_release - prev_key_press.time_press >= key_time_longpress_ms) {
                evt.state = InputEvent::State::keyReleasedLong;
            }
        }
    }

    InputEvent KeyBaseTranslation::set(RawKey key)
    {
        gui::InputEvent evt(key);
        if (key.state == RawKey::State::Pressed) {
            evt.state = InputEvent::State::keyPressed;
        }
        else if (key.state == RawKey::State::Released) {
            evt.state = InputEvent::State::keyReleasedShort;
        }
        recon_long_press(evt, key, prev_key_press, key_time_longpress_ms);
        // store last key press/release
        if (key.state == RawKey::State::Pressed) {
            prev_key_press = key;
        }
        if (key.state != RawKey::State::Released) {
            prev_key_released = false;
        }
        else {
            prev_key_released = true;
        }
        return evt;
    }

    bool KeyBaseTranslation::timeout(uint32_t time)
    {
        if (!prev_key_released && (prev_key_press.time_press != 0) &&
            (time - prev_key_press.time_press >= key_time_longpress_ms)) {
            prev_key_timedout = true;
            return true;
        }
        return false;
    }

    gui::KeyCode getKeyCode(bsp::KeyCodes code)
    {
        switch (code) {
        case bsp::KeyCodes::NumericKey1:
            return gui::KeyCode::KEY_1;
            break;
        case bsp::KeyCodes::NumericKey2:
            return gui::KeyCode::KEY_2;
            break;
        case bsp::KeyCodes::NumericKey3:
            return gui::KeyCode::KEY_3;
            break;
        case bsp::KeyCodes::NumericKey4:
            return gui::KeyCode::KEY_4;
            break;
        case bsp::KeyCodes::NumericKey5:
            return gui::KeyCode::KEY_5;
            break;
        case bsp::KeyCodes::NumericKey6:
            return gui::KeyCode::KEY_6;
            break;
        case bsp::KeyCodes::NumericKey7:
            return gui::KeyCode::KEY_7;
            break;
        case bsp::KeyCodes::NumericKey8:
            return gui::KeyCode::KEY_8;
            break;
        case bsp::KeyCodes::NumericKey9:
            return gui::KeyCode::KEY_9;
            break;
        case bsp::KeyCodes::NumericKey0:
            return gui::KeyCode::KEY_0;
            break;
        case bsp::KeyCodes::NumericKeyAst:
            return gui::KeyCode::KEY_AST;
            break;
        case bsp::KeyCodes::NumericKeyPnd:
            return gui::KeyCode::KEY_PND;
            break;
        case bsp::KeyCodes::JoystickLeft:
            return gui::KeyCode::KEY_LEFT;
            break;
        case bsp::KeyCodes::JoystickRight:
            return gui::KeyCode::KEY_RIGHT;
            break;
        case bsp::KeyCodes::JoystickUp:
            return gui::KeyCode::KEY_UP;
            break;
        case bsp::KeyCodes::JoystickDown:
            return gui::KeyCode::KEY_DOWN;
            break;
        case bsp::KeyCodes::JoystickEnter:
            return gui::KeyCode::KEY_ENTER;
            break;
        case bsp::KeyCodes::FnLeft:
            return gui::KeyCode::KEY_LF;
            break;
        case bsp::KeyCodes::FnRight:
            return gui::KeyCode::KEY_RF;
            break;
        case bsp::KeyCodes::VolUp:
            return gui::KeyCode::KEY_VOLUP;
            break;
        case bsp::KeyCodes::VolDown:
            return gui::KeyCode::KEY_VOLDN;
            break;
        case bsp::KeyCodes::Torch:
            return gui::KeyCode::KEY_TORCH;
            break;
        case bsp::KeyCodes::SSwitchUp:
            return gui::KeyCode::SWITCH_UP;
            break;
        case bsp::KeyCodes::SSwitchDown:
            return gui::KeyCode::SWITCH_DN;
            break;
        case bsp::KeyCodes::SSwitchMid:
            return gui::KeyCode::SWITCH_MID;
            break;
        default:
            LOG_ERROR("Unhandled bsp key!");
            return gui::KeyCode::KEY_UNDEFINED;
        }
    }

    InputEvent KeyInputSimpleTranslation::translate(RawKey key)
    {
        auto evt = KeyBaseTranslation::set(key);
        // when last action timed out we don't want to handle key release
        if (prev_key_timedout && key.state == RawKey::State::Released) {
            evt.state         = InputEvent::State::Undefined;
            prev_key_timedout = false;
        }
        evt.keyCode = getKeyCode(key.key_code);
        return evt;
    }

    InputEvent KeyInputSimpleTranslation::translate(uint32_t timeout)
    {
        RawKey key;
        key.state        = RawKey::State::Released;
        key.key_code     = prev_key_press.key_code;
        key.time_press   = 0;
        key.time_release = timeout;
        InputEvent evt(key);
        evt.state   = InputEvent::State::keyReleasedLong;
        evt.keyCode = getKeyCode(key.key_code);
        return evt;
    }

    /// profiles cache - load once for all
    class Profiles
    {
      private:
        const char *profilesFolder                   = "sys/assets/profiles";
        std::map<std::string, gui::Profile> profiles = {};

        void loadProfile(const std::string &filepath)
        {
            LOG_INFO("Load profile: %s", filepath.c_str());
            auto p = Profile(filepath);
            if (p.getName() != std::string()) {
                profiles.insert({p.getName(), std::move(p)});
            }
        }

        std::vector<std::string> getProfilesList(std::string ext)
        {
            std::vector<std::string> profileFiles;
            LOG_INFO("Scanning %s profiles folder: %s", ext.c_str(), profilesFolder);
            auto dirList = vfs.listdir(profilesFolder, ext);

            for (vfs::DirectoryEntry ent : dirList) {
                if (ent.attributes != vfs::FileAttributes::Directory) {
                    profileFiles.push_back(std::string(profilesFolder) + "/" + ent.fileName);
                }
            }

            LOG_INFO("Total number of profiles: %d", profileFiles.size());
            return profileFiles;
        }

        void init()
        {
            std::vector<std::string> profileFiles = getProfilesList(".kprof");
            for (std::string mapName : profileFiles) {
                if (std::size(mapName)) {
                    loadProfile(mapName);
                }
            }
            if (std::size(profiles) == 0) {
                LOG_ERROR("No keyboard profiles loaded");
            }
        }
        Profile empty;

      public:
        static Profiles &get()
        {
            static Profiles *p;
            if (p == nullptr) {
                p = new Profiles();
                p->init();
            }
            return *p;
        }

        static Profile &get(const std::string &name)
        {
            // if profile not in profile map -> load
            if (std::size(name) == 0) {
                LOG_ERROR("Request for non existend profile: %s", name.c_str());
                return get().empty;
            }
            if (get().profiles.find(name) == get().profiles.end()) {
                get().loadProfile(name);
            }
            return get().profiles[name];
        }
    };

    uint32_t KeyInputMappedTranslation::handle(RawKey key, const std::string &keymap)
    {
        // get shortpress
        if (prev_key_press.key_code != key.key_code) {
            times = 0;
        }
        else if (key.state == RawKey::State::Released) {
            /// TODO use key_time_cycle_ms from keymap (if exists in keymap...)
            if (key.time_release - prev_key_press.time_release < key_time_cycle_ms) {
                ++times;
            }
            else {
                times = 0;
            }
        }
        if (key.state == RawKey::State::Released) {
            prev_key_press = key;
        }

        return Profiles::get(keymap).get(key.key_code, times);
    }

} /* namespace gui */