InternalServices.hpp

Go to the documentation of this file.

 
#pragma once
 
//-------------------------------------------------------------------
// Imports
//-------------------------------------------------------------------
 
#include "InternalTypes.hpp"
#include <cstdint>
#include <type_traits>
 
//-------------------------------------------------------------------
// Dependency manager
//-------------------------------------------------------------------
 
template <typename Service>
struct DependencyManager
{
    static Service &call()
    {
        if constexpr (!::std::is_default_constructible<Service>::value)
        {
            if (_singleton)
                return *_singleton;
        }
        else
        {
            if (!_singleton)
                _singleton = new Service();
            return *_singleton;
        }
        throw ::std::runtime_error("Service provider not injected");
    }
 
    template <class Provider, typename... _Args>
    static void inject(_Args &&...__args)
    {
 
        static_assert(
            std::is_base_of<Service, Provider>::value,
            "Provider does not implement Service");
        inject(new Provider(::std::forward<_Args>(__args)...));
    }
 
    static void inject(Service *provider)
    {
        if (provider)
        {
            if (!_singleton)
                _singleton = provider;
            else
                throw ::std::runtime_error(
                    "Provider already injected to service");
        }
        else
            throw ::std::runtime_error("A null provider is not allowed");
    }
 
    static void reset()
    {
        _singleton = nullptr;
    }
 
private:
    inline static Service *_singleton = nullptr;
};
 
//-------------------------------------------------------------------
// Input service
//-------------------------------------------------------------------
 
class InputService : public DependencyManager<InputService>
{
public:
    virtual void recalibrateAxes() {}
 
    virtual void reverseLeftAxis() {}
 
    virtual void reverseRightAxis() {}
 
    virtual void setRotaryPulseWidthMultiplier(
        PulseWidthMultiplier multiplier,
        bool save = true) {}
 
    virtual PulseWidthMultiplier getRotaryPulseWidthMultiplier()
    {
        return (PulseWidthMultiplier::X1);
    }
 
    virtual bool getAxisCalibration(
        int &minLeft,
        int &maxLeft,
        int &minRight,
        int &maxRight) { return (false); }
 
    virtual void setAxisCalibration(
        int minLeft,
        int maxLeft,
        int minRight,
        int maxRight,
        bool save = true) {}
 
    virtual void getAxisPolarity(
        bool &leftAxisReversed,
        bool &rightAxisReversed) {}
 
    virtual void setAxisPolarity(
        bool leftAxisReversed,
        bool rightAxisReversed,
        bool save = true) {}
 
    virtual void update() {}
};
 
//-------------------------------------------------------------------
// Input hub service
//-------------------------------------------------------------------
 
class InputHubService : public DependencyManager<InputHubService>
{
public:
    virtual bool getSecurityLock()
    {
        return (false);
    }
 
    virtual uint8_t getBitePoint()
    {
        return (CLUTCH_DEFAULT_VALUE);
    }
 
    virtual ClutchWorkingMode getClutchWorkingMode()
    {
        return (ClutchWorkingMode::_DEFAULT_VALUE);
    }
 
    virtual AltButtonsWorkingMode getAltButtonsWorkingMode()
    {
        return (AltButtonsWorkingMode::_DEFAULT_VALUE);
    }
 
    virtual DPadWorkingMode getDPadWorkingMode()
    {
        return (DPadWorkingMode::_DEFAULT_VALUE);
    }
 
    virtual void setBitePoint(uint8_t value, bool save = true)
    {
    }
 
    virtual void setClutchWorkingMode(ClutchWorkingMode mode, bool save = true)
    {
    }
 
    virtual void setAltButtonsWorkingMode(
        AltButtonsWorkingMode mode,
        bool save = true) {}
 
    virtual void setDPadWorkingMode(DPadWorkingMode mode, bool save = true)
    {
    }
 
    virtual void setSecurityLock(bool value, bool save = true)
    {
    }
};
 
//-------------------------------------------------------------------
// Input map service
//-------------------------------------------------------------------
 
class InputMapService : public DependencyManager<InputMapService>
{
public:
    virtual void setMap(
        uint8_t firmware_defined,
        uint8_t user_defined,
        uint8_t user_defined_alt) {}
 
    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() {}
};
 
//-------------------------------------------------------------------
// Power service
//-------------------------------------------------------------------
 
class PowerService : public DependencyManager<PowerService>
{
public:
    virtual void shutdown() {}
};
 
//-------------------------------------------------------------------
// Battery service
//-------------------------------------------------------------------
 
class BatteryService : public DependencyManager<BatteryService>
{
public:
    virtual int getLastBatteryLevel() { return (0); }
 
    virtual bool hasBattery() { return (false); }
 
    virtual bool isBatteryPresent()
    {
        return (false);
    }
 
    virtual void getStatus(BatteryStatus &status) {}
};
 
//-------------------------------------------------------------------
// Battery calibration
//-------------------------------------------------------------------
 
class BatteryCalibrationService
    : public DependencyManager<BatteryCalibrationService>
{
public:
    virtual void restartAutoCalibration()
    {
    }
 
    virtual int getBatteryLevel(int reading)
    {
        return (-1);
    }
 
    virtual int getBatteryLevelAutoCalibrated(int reading)
    {
        return (0);
    }
 
    virtual uint8_t getCalibrationDataCount()
    {
        return (0);
    }
 
    virtual uint16_t getCalibrationData(uint8_t index)
    {
        return (0);
    }
 
    virtual void setCalibrationData(
        uint8_t index, uint16_t data,
        bool save = true) {}
 
    virtual int getAutoCalibrationParameter()
    {
        return (-1);
    }
 
    virtual void setAutoCalibrationParameter(int value, bool save = true)
    {
    }
};
 
//-------------------------------------------------------------------
// HID
//-------------------------------------------------------------------
 
class HidService : public DependencyManager<HidService>
{
public:
    virtual void getCustomHardwareID(
        uint16_t &customVID,
        uint16_t &customPID) {}
 
    virtual void setCustomHardwareID(
        uint16_t customVID,
        uint16_t customPID,
        bool save = true) {}
};
 
//-------------------------------------------------------------------
// UI
//-------------------------------------------------------------------
 
class UIService : public DependencyManager<UIService>
{
public:
    virtual uint8_t getMaxFPS()
    {
        return (0);
    }
};
 
//-------------------------------------------------------------------
// Firmware
//-------------------------------------------------------------------
 
class FirmwareService : public DependencyManager<FirmwareService>
{
    friend void firmwareSetIsRunningState(bool state);
 
public:
    virtual bool isRunning()
    {
        return (_is_running);
    }
 
private:
    inline static bool _is_running = false;
};