InternalServices.hpp

Go to the documentation of this file.

 
#pragma once
 
//-------------------------------------------------------------------
// Imports
//-------------------------------------------------------------------
 
#include "InternalTypes.hpp"
#include <cstdint>
#include <type_traits>
#include <cassert>
#include <typeinfo>
#include <vector>
 
//-------------------------------------------------------------------
// Global macros
//-------------------------------------------------------------------
 
#define MOCK \
    {        \
    }
 
#define MOCK_R(value) \
    {                 \
        return value; \
    }
 
#define SERVICE(ClassName) \
    ClassName:             \
public                     \
    DependencyManager<ClassName>
 
#define VOID_SINGLETON_INVOKER(Decl, Call) \
    static void Decl                       \
    {                                      \
        getInstance()->Call;               \
    }
 
#define SINGLETON_INVOKER(ReturnType, Decl, Call) \
    static ReturnType Decl                        \
    {                                             \
        return getInstance()->Call;               \
    }
 
#define ALL_INVOKER(Decl, Call)             \
    static void Decl                        \
    {                                       \
        auto instances = getAllInstances(); \
        for (auto instance : instances)     \
            instance->Call;                 \
    }
 
#define BOTH_INVOKER(Decl, Call)            \
    static void Decl                        \
    {                                       \
        getInstance()->Call;                \
        auto instances = getAllInstances(); \
        for (auto instance : instances)     \
            instance->Call;                 \
    }
 
//-------------------------------------------------------------------
// Dependency manager
//-------------------------------------------------------------------
 
template <typename Service>
struct DependencyManager
{
    typedef std::vector<Service *> InstanceSet;
 
    static Service *getInstance()
    {
        if constexpr ((std::is_abstract<Service>::value) || (!std::is_default_constructible<Service>::value))
        {
            assert((_singleton != nullptr) && "Provider not injected to Service");
        }
        else
        {
            if (_singleton == nullptr)
                _singleton = new Service();
        }
        return _singleton;
    }
 
    static const InstanceSet getAllInstances() { return _instanceSet; }
 
    template <typename Provider>
    static void inject(Provider *instance, bool multipleInstances = false)
    {
        static_assert(std::is_base_of<Service, Provider>::value, "Provider is not derived from Service");
        assert((instance != nullptr) && "A null provider is not allowed");
        if (multipleInstances)
        {
            _instanceSet.push_back(instance);
        }
        else
        {
            assert((_singleton == nullptr) && "Provider already injected to service");
            _singleton = instance;
        }
    }
 
    static void reset()
    {
        if (_singleton != nullptr)
        {
            delete _singleton;
            _singleton = nullptr;
        }
        for (auto instance : _instanceSet)
            delete instance;
        _instanceSet.clear();
    }
 
    virtual ~DependencyManager() = default;
 
private:
    inline static InstanceSet _instanceSet = {};
    inline static Service *_singleton = nullptr;
};
 
//-------------------------------------------------------------------
// Input service
//-------------------------------------------------------------------
 
class SERVICE(InputService)
{
public:
    virtual void recalibrateAxes() MOCK;
 
    virtual void reverseLeftAxis() MOCK;
 
    virtual void reverseRightAxis() MOCK;
 
    virtual void setRotaryPulseWidthMultiplier(
        PulseWidthMultiplier multiplier,
        bool save) MOCK;
 
    virtual PulseWidthMultiplier getRotaryPulseWidthMultiplier() MOCK_R(PulseWidthMultiplier::X1);
 
    virtual bool getAxisCalibration(
        int &minLeft,
        int &maxLeft,
        int &minRight,
        int &maxRight) MOCK_R(false);
 
    virtual void setAxisCalibration(
        int minLeft,
        int maxLeft,
        int minRight,
        int maxRight,
        bool save) MOCK;
 
    virtual void getAxisPolarity(
        bool &leftAxisReversed,
        bool &rightAxisReversed) MOCK;
 
    virtual void setAxisPolarity(
        bool leftAxisReversed,
        bool rightAxisReversed,
        bool save) MOCK;
 
    virtual void update() MOCK;
 
 
    struct call
    {
        VOID_SINGLETON_INVOKER(recalibrateAxes(), recalibrateAxes())
        VOID_SINGLETON_INVOKER(reverseLeftAxis(), reverseLeftAxis())
        VOID_SINGLETON_INVOKER(reverseRightAxis(), reverseRightAxis())
        VOID_SINGLETON_INVOKER(
            setRotaryPulseWidthMultiplier(PulseWidthMultiplier multiplier, bool save = true),
            setRotaryPulseWidthMultiplier(multiplier, save))
        SINGLETON_INVOKER(
            PulseWidthMultiplier,
            getRotaryPulseWidthMultiplier(),
            getRotaryPulseWidthMultiplier())
        SINGLETON_INVOKER(
            bool,
            getAxisCalibration(
                int &minLeft,
                int &maxLeft,
                int &minRight,
                int &maxRight),
            getAxisCalibration(minLeft, maxLeft, minRight, maxRight))
        VOID_SINGLETON_INVOKER(
            setAxisCalibration(
                int minLeft,
                int maxLeft,
                int minRight,
                int maxRight,
                bool save = true),
            setAxisCalibration(minLeft, maxLeft, minRight, maxRight, save))
        VOID_SINGLETON_INVOKER(
            getAxisPolarity(
                bool &leftAxisReversed,
                bool &rightAxisReversed),
            getAxisPolarity(
                leftAxisReversed,
                rightAxisReversed))
        VOID_SINGLETON_INVOKER(
            setAxisPolarity(
                bool leftAxisReversed,
                bool rightAxisReversed,
                bool save = true),
            setAxisPolarity(
                leftAxisReversed,
                rightAxisReversed,
                save))
        VOID_SINGLETON_INVOKER(update(), update());
    };
 
 
};
 
//-------------------------------------------------------------------
// Input hub service
//-------------------------------------------------------------------
 
class SERVICE(InputHubService)
{
public:
    virtual bool getSecurityLock() MOCK_R(false);
    virtual uint8_t getBitePoint() MOCK_R(CLUTCH_DEFAULT_VALUE);
    virtual ClutchWorkingMode getClutchWorkingMode() MOCK_R(ClutchWorkingMode::_DEFAULT_VALUE);
    virtual AltButtonsWorkingMode getAltButtonsWorkingMode() MOCK_R(AltButtonsWorkingMode::_DEFAULT_VALUE);
    virtual DPadWorkingMode getDPadWorkingMode() MOCK_R(DPadWorkingMode::_DEFAULT_VALUE);
    virtual void setBitePoint(uint8_t value, bool save) MOCK;
    virtual void setClutchWorkingMode(ClutchWorkingMode mode, bool save) MOCK;
    virtual void setAltButtonsWorkingMode(AltButtonsWorkingMode mode, bool save) MOCK;
    virtual void setDPadWorkingMode(DPadWorkingMode mode, bool save) MOCK;
    virtual void setSecurityLock(bool value, bool save) MOCK;
 
 
    struct call
    {
        SINGLETON_INVOKER(bool, getSecurityLock(), getSecurityLock())
        SINGLETON_INVOKER(uint8_t, getBitePoint(), getBitePoint())
        SINGLETON_INVOKER(ClutchWorkingMode, getClutchWorkingMode(), getClutchWorkingMode())
        SINGLETON_INVOKER(AltButtonsWorkingMode, getAltButtonsWorkingMode(), getAltButtonsWorkingMode())
        SINGLETON_INVOKER(DPadWorkingMode, getDPadWorkingMode(), getDPadWorkingMode())
 
        VOID_SINGLETON_INVOKER(setBitePoint(uint8_t value, bool save = true), setBitePoint(value, save))
        VOID_SINGLETON_INVOKER(
            setClutchWorkingMode(ClutchWorkingMode mode, bool save = true),
            setClutchWorkingMode(mode, save))
        VOID_SINGLETON_INVOKER(
            setAltButtonsWorkingMode(AltButtonsWorkingMode mode, bool save = true),
            setAltButtonsWorkingMode(mode, save))
        VOID_SINGLETON_INVOKER(
            setDPadWorkingMode(DPadWorkingMode mode, bool save = true),
            setDPadWorkingMode(mode, save))
        VOID_SINGLETON_INVOKER(
            setSecurityLock(bool value, bool save = true),
            setSecurityLock(value, save))
    };
 
 
};
 
//-------------------------------------------------------------------
// Input map service
//-------------------------------------------------------------------
 
class SERVICE(InputMapService)
{
public:
    virtual void setMap(
        uint8_t firmware_defined,
        uint8_t user_defined,
        uint8_t user_defined_alt) MOCK;
    virtual void getMap(
        uint8_t firmware_defined,
        uint8_t &user_defined,
        uint8_t &user_defined_alt)
    {
        user_defined = firmware_defined;
        user_defined_alt = firmware_defined + 64;
    };
    virtual void resetMap() MOCK;
 
    struct call
    {
        VOID_SINGLETON_INVOKER(
            setMap(uint8_t firmware_defined, uint8_t user_defined, uint8_t user_defined_alt),
            setMap(firmware_defined, user_defined, user_defined_alt))
        VOID_SINGLETON_INVOKER(
            getMap(uint8_t firmware_defined, uint8_t &user_defined, uint8_t &user_defined_alt),
            getMap(firmware_defined, user_defined, user_defined_alt))
        VOID_SINGLETON_INVOKER(resetMap(), resetMap())
    };
};
 
//-------------------------------------------------------------------
// Power service
//-------------------------------------------------------------------
 
class SERVICE(PowerService)
{
public:
    virtual void shutdown() MOCK;
 
    struct call
    {
        VOID_SINGLETON_INVOKER(shutdown(), shutdown())
    };
};
 
//-------------------------------------------------------------------
// Battery service
//-------------------------------------------------------------------
 
class SERVICE(BatteryService)
{
public:
    virtual int getLastBatteryLevel() MOCK_R(0);
 
    virtual bool hasBattery() MOCK_R(false);
 
    virtual bool isBatteryPresent() MOCK_R(false);
 
    virtual void getStatus(BatteryStatus &status) MOCK;
 
    struct call
    {
        SINGLETON_INVOKER(int, getLastBatteryLevel(), getLastBatteryLevel())
        SINGLETON_INVOKER(bool, hasBattery(), hasBattery())
        SINGLETON_INVOKER(bool, isBatteryPresent(), isBatteryPresent())
        VOID_SINGLETON_INVOKER(
            getStatus(BatteryStatus &status),
            getStatus(status))
    };
};
 
//-------------------------------------------------------------------
// Battery calibration
//-------------------------------------------------------------------
 
class SERVICE(BatteryCalibrationService)
{
public:
    virtual void restartAutoCalibration() MOCK;
 
    virtual int getBatteryLevel(int reading) MOCK_R(-1);
 
    virtual int getBatteryLevelAutoCalibrated(int reading) MOCK_R(0);
 
    virtual uint8_t getCalibrationDataCount() MOCK_R(0);
 
    virtual uint16_t getCalibrationData(uint8_t index) MOCK_R(0);
 
    virtual void setCalibrationData(uint8_t index, uint16_t data, bool save) MOCK;
 
    virtual int getAutoCalibrationParameter() MOCK_R(-1);
 
    virtual void setAutoCalibrationParameter(int value, bool save) MOCK;
 
 
    struct call
    {
        VOID_SINGLETON_INVOKER(restartAutoCalibration(), restartAutoCalibration())
        SINGLETON_INVOKER(int, getBatteryLevel(int reading), getBatteryLevel(reading))
        SINGLETON_INVOKER(int, getBatteryLevelAutoCalibrated(int reading), getBatteryLevelAutoCalibrated(reading))
        SINGLETON_INVOKER(uint8_t, getCalibrationDataCount(), getCalibrationDataCount())
        SINGLETON_INVOKER(uint16_t, getCalibrationData(uint8_t index), getCalibrationData(index))
        VOID_SINGLETON_INVOKER(
            setCalibrationData(uint8_t index, uint16_t data, bool save = true),
            setCalibrationData(index, data, save))
        SINGLETON_INVOKER(int, getAutoCalibrationParameter(), getAutoCalibrationParameter())
        VOID_SINGLETON_INVOKER(
            setAutoCalibrationParameter(int value, bool save = true),
            setAutoCalibrationParameter(value, save))
    };
 
};
 
//-------------------------------------------------------------------
// HID
//-------------------------------------------------------------------
 
class SERVICE(HidService)
{
public:
    virtual void getCustomHardwareID(
        uint16_t &customVID,
        uint16_t &customPID) MOCK;
 
    virtual void setCustomHardwareID(
        uint16_t customVID,
        uint16_t customPID,
        bool save) MOCK;
 
    struct call
    {
        VOID_SINGLETON_INVOKER(
            getCustomHardwareID(uint16_t &customVID, uint16_t &customPID),
            getCustomHardwareID(customVID, customPID))
        VOID_SINGLETON_INVOKER(
            setCustomHardwareID(uint16_t customVID, uint16_t customPID, bool save = true),
            setCustomHardwareID(customVID, customPID, save))
    };
};
 
//-------------------------------------------------------------------
// UI
//-------------------------------------------------------------------
 
class SERVICE(UIService)
{
public:
    virtual uint8_t getMaxFPS() MOCK_R(0);
 
    struct call
    {
        SINGLETON_INVOKER(uint8_t, getMaxFPS(), getMaxFPS())
    };
};
 
//-------------------------------------------------------------------
// Firmware
//-------------------------------------------------------------------
 
class SERVICE(FirmwareService)
{
    friend void firmwareSetIsRunningState(bool state);
 
public:
    virtual bool isRunning() MOCK_R(_is_running);
 
    struct call
    {
        SINGLETON_INVOKER(bool, isRunning(), isRunning())
    };
 
private:
    inline static bool _is_running = false;
};