Device.hpp

Go to the documentation of this file.

/*
 * libevdevxx - a C++ wrapper for libevdev
 *
 * Copyright (C) 2025  Daniel K. O.
 * SPDX-License-Identifier: MIT
 */
 
#ifndef LIBEVDEVXX_DEVICE_HPP
#define LIBEVDEVXX_DEVICE_HPP
 
#include <cstddef>
#include <cstdarg>
#include <cstddef>
#include <cstdint>
#include <filesystem>
#include <memory>
#include <optional>
#include <string>
#include <tuple>
#include <vector>
 
#include <fcntl.h>
 
#include <libevdev/libevdev.h>
 
#include "AbsInfo.hpp"
#include "basic_wrapper.hpp"
#include "Event.hpp"
#include "Property.hpp"
#include "ReadFlag.hpp"
#include "ReadStatus.hpp"
#include "TypeCode.hpp"
 

namespace evdev {

    class Device :
        public detail::basic_wrapper<libevdev*> {
 
 
        using BaseType = detail::basic_wrapper<libevdev*>;
 
        int owned_fd = -1;
 
        using state_type = std::tuple<BaseType::state_type, int>;
 
 
        static
        void
        log_helper(const libevdev* dev,
                   libevdev_log_priority priority,
                   void* data,
                   const char* file,
                   int line,
                   const char* func,
                   const char* format,
                   std::va_list args)
            noexcept;
 
    protected:
 
 
        // ------------------------- //
        // Initialization and setup. //
        // ------------------------- //

        enum class LogLevel {
            none  = -1,                 
            error = LIBEVDEV_LOG_ERROR, 
            info  = LIBEVDEV_LOG_INFO,  
            debug = LIBEVDEV_LOG_DEBUG  
        };

        Device(LogLevel priority);

        Device(LogLevel priority,
               int fd);

        Device(LogLevel priority,
               const std::filesystem::path& filename,
               int flags = O_RDONLY | O_NONBLOCK);
 

        void
        create(LogLevel priority);
 

        void
        create(LogLevel priority,
               int fd);
 

        void
        create(LogLevel priority,
               const std::filesystem::path& filename,
               int flags = O_RDONLY | O_NONBLOCK);
 
 
    public:

        Device(std::nullptr_t)
            noexcept;

        Device();

        Device(int fd);

        Device(const std::filesystem::path& filename,
               int flags = O_RDONLY | O_NONBLOCK);
 
 
        ~Device()
            noexcept;
 

        void
        create();
 

        void
        create(int fd);
 

        void
        create(const std::filesystem::path& filename,
               int flags = O_RDONLY | O_NONBLOCK);
 

        void
        destroy()
            noexcept override;
 

        Device(Device&& other)
            noexcept;
 

        Device&
        operator =(Device&& other)
            noexcept;
 
 
        void
        acquire(libevdev* new_raw,
                int new_fd)
            noexcept;
 
 
        void
        acquire(state_type new_state)
            noexcept;
 
 
        state_type
        release()
            noexcept;
 

        void
        grab();

        void
        ungrab();

        void
        set_fd(int fd);

        void
        change_fd(int fd);

        int
        get_fd()
            const;

        void
        open(const std::filesystem::path& filename,
                 int flags = O_RDONLY | O_NONBLOCK);

        [[nodiscard]]
        bool
        is_open()
            const noexcept;

        void
        set_nonblock(bool enable);

        [[nodiscard]]
        bool
        get_nonblock()
            const;
 
        // ------------------ //
        // Logging facilities //
        // ------------------ //
 
        virtual
        void
        log(LogLevel priority,
            const char* file,
            int line,
            const char* func,
            const char* format,
            std::va_list args)
            const noexcept;
 
 
        // --------------------- //
        // Querying capabilities //
        // --------------------- //
 
 
        [[nodiscard]]
        std::string
        get_name()
            const;
 
        [[nodiscard]]
        std::optional<std::string>
        get_phys()
            const;
 
        [[nodiscard]]
        std::optional<std::string>
        get_uniq()
            const;
 
        [[nodiscard]]
        std::uint16_t
        get_product()
            const noexcept;
 
        [[nodiscard]]
        std::uint16_t
        get_vendor()
            const noexcept;
 
        [[nodiscard]]
        std::uint16_t
        get_bustype()
            const noexcept;
 
        [[nodiscard]]
        std::uint16_t
        get_version()
            const noexcept;
 
        [[nodiscard]]
        int
        get_driver_version()
            const noexcept;
 
 
        [[nodiscard]]
        bool
        has(Property prop)
            const noexcept;
 
        [[nodiscard]]
        bool
        has(Type type)
            const noexcept;
 
        [[nodiscard]]
        bool
        has(Type type, Code code)
            const noexcept;
 
        [[nodiscard]]
        bool
        has(const TypeCode& tc)
            const noexcept;
 
 
        [[nodiscard]]
        int
        get_abs_min (Code code)
            const noexcept;
 
        [[nodiscard]]
        int
        get_abs_max (Code code)
            const noexcept;
 
        [[nodiscard]]
        int
        get_abs_fuzz(Code code)
            const noexcept;
 
        [[nodiscard]]
        int
        get_abs_flat(Code code)
            const noexcept;
 
        [[nodiscard]]
        int
        get_abs_res (Code code)
        const noexcept;
 
        [[nodiscard]]
        AbsInfo
        get_abs_info(Code code)
            const;
 
        [[nodiscard]]
        int
        get_value(Type type,
                  Code code)
            const noexcept;
 
        [[nodiscard]]
        int
        get_value(const TypeCode& tc)
            const noexcept;
 
        [[nodiscard]]
        std::optional<int>
        try_get_value(Type type,
                      Code code)
            const noexcept;
 
        [[nodiscard]]
        std::optional<int>
        try_get_value(const TypeCode& tc)
            const noexcept;
 
        bool
        get_repeat(int& delay,
                   int& period)
            const noexcept;
 
 
        struct DelayPeriod {
            int delay;
            int period;
        };
 
        [[nodiscard]]
        std::optional<DelayPeriod>
        try_get_repeat()
            const noexcept;
 
 
        // ----------------------------- //
        // Multi-touch related functions //
        // ----------------------------- //
 
 
        [[nodiscard]]
        int
        get_slot(unsigned slot,
                 Code code)
            const noexcept;
 
        [[nodiscard]]
        std::optional<int>
        try_get_slot(unsigned slot,
                     Code code)
            const noexcept;
 
        int
        get_num_slots()
            const;
 
        [[nodiscard]]
        std::optional<int>
        try_get_num_slots()
            const noexcept;
 
        [[nodiscard]]
        int
        get_current_slot()
            const noexcept;
 
 
        // ---------------------------------------- //
        // Modifying the appearance or capabilities //
        // ---------------------------------------- //
 
 
        void
        set_name(const std::string& name)
            noexcept;
 
        void
        set_phys(const std::string& phys)
            noexcept;
 
        void
        set_uniq(const std::string& uniq)
            noexcept;
 
        void
        set_product(std::uint16_t pid)
            noexcept;
 
        void
        set_vendor(std::uint16_t vid)
            noexcept;
 
        void
        set_bustype(std::uint16_t bus)
            noexcept;
 
        void
        set_version(std::uint16_t ver)
            noexcept;
 
        void
        enable(Property prop);
 
        void
        disable(Property prop);
 
        void
        set_value(Type type,
                  Code code,
                  int value);
 
        void
        set_value(const TypeCode& tc,
                  int value);
 
        void
        set_slot(unsigned slot,
                 Code code,
                 int value);
 
        void
        set_abs_min(Code code,
                    int val)
            noexcept;
 
        void
        set_abs_max(Code code,
                    int val)
            noexcept;
 
        void
        set_abs_fuzz(Code code,
                     int val)
            noexcept;
 
        void
        set_abs_flat(Code code,
                     int val)
            noexcept;
 
        void
        set_abs_res(Code code,
                    int val)
            noexcept;
 
        void
        set_abs_info(Code code,
                     const AbsInfo& abs)
            noexcept;
 
        void
        enable(Type type);
 
        void
        disable(Type type);
 
        void
        enable(Type type,
               Code code);
 
        void
        enable(const TypeCode& tc);
 
        void
        enable_abs(Code code,
                   const AbsInfo& info);
 
        void
        enable_rep(Code code,
                   int arg);
 
        void
        disable(Type type,
                Code code);
 
        void
        disable(const TypeCode& tc);
 
        void
        set_kernel_abs_info(Code code,
                            const AbsInfo& abs);
 
        void
        set_kernel_led_value(Code code,
                             libevdev_led_value value);
 
        void
        set_clock_id(int clockid);
 
 
        // -------------- //
        // Event handling //
        // -------------- //
 
 
        Event
        read(ReadFlag flags = ReadFlag::normal);
 
        [[nodiscard]]
        ReadStatus
        read(Event& event,
             ReadFlag flags = ReadFlag::normal)
            noexcept;
 
        [[nodiscard]]
        bool
        has_pending();
 
 
        // ------------------- //
        // Convenience methods //
        // ------------------- //
 
 
        [[nodiscard]]
        std::vector<Property>
        get_properties()
            const;
 
        [[nodiscard]]
        std::vector<Type>
        get_types()
            const;
 
        [[nodiscard]]
        std::vector<Code>
        get_codes(Type type)
            const;
 
        [[nodiscard]]
        std::vector<Code>
        get_codes(Type type,
                  Code max)
            const;
 
 
        void
        enable_key(Code code);
 
        void
        enable_rel(Code code);
 
        void
        enable_abs(Code code);
 
    }; // class Device
 
} // namespace evdev
 
#endif