nt9856x/code/application/sifarsdk/hal/include/IHal.h

#ifndef IHAL_H
#define IHAL_H
#include "VReturnCode.h"
#include "IHalCommon.h"
#include <iostream>
#include <memory>
#include <functional>
#include <vector>
constexpr int INVALID_PERIOD = -1;
constexpr int PERIPHERAL_CHECK_PERIOD_MS = 100;
constexpr int IMEI_LEN = 15;
constexpr long int KEY_DO_NOT_HOLD_PRESSING = -1;
class VKeyEventMonitor
{
public:
    VKeyEventMonitor() = default;
    virtual ~VKeyEventMonitor() = default;
    virtual void HalKeyEventHappened(const SfKeyDefine &key, const SfKeyEvent &event, void *context) {}
    virtual void TimerKeyEventHappened(const SfKeyDefine &key, const SfKeyEvent &event, void *context) {}
    virtual long int GetHoldPressingTimeMs(void) { return KEY_DO_NOT_HOLD_PRESSING; }
    // virtual bool IsKeyPressing(void) { return false; }
};
class VKeyContrl
{
public:
    VKeyContrl() = default;
    virtual ~VKeyContrl() = default;
    virtual void Init(void) {}
    virtual void UnInit(void) {}
    virtual void SetKeyEventMonitor(std::shared_ptr<VKeyEventMonitor> monitor, void *context) {}
};
class VLedContrl
{
public:
    VLedContrl() = default;
    virtual ~VLedContrl() = default;
    virtual void Init(void) {}
    virtual void UnInit(void) {}
    virtual bool SetLedState(const SfLedState &state) { return false; }
};
enum class GpioPin
{
    PIR = 0,
    USB,
    END
};
enum class GpioInputValue
{
    VALID = 0,
    INVALID,
    END
};
class VGpioInputMonitor
{
public:
    VGpioInputMonitor() = default;
    virtual ~VGpioInputMonitor() = default;
    virtual void InputTransform(const GpioPin &device, const GpioInputValue &value, void *context) {}
};
class VGpioInputHandle
{
public:
    VGpioInputHandle() = default;
    virtual ~VGpioInputHandle() = default;
    virtual void Init(void) {}
    virtual void UnInit(void) {}
    virtual void SetInputMonitor(std::shared_ptr<VGpioInputMonitor> monitor, void *context) {}
};
enum class ResponseCode
{
    RESPONSE_OK = 0,
    RESPONSE_FAILED,
    RESPONSE_FAILED_RETRY,
    RESPONSE_CODE_END
};
constexpr char *ONLY_READ_FROM_NETWORK = nullptr;
class VNetworkTask
{
public:
    VNetworkTask() = default;
    virtual ~VNetworkTask() = default;
    virtual const char *GetWriteBuf(void) = 0;
    virtual unsigned int GetWriteBufLength(void) = 0;
    virtual bool IsTaskBlock(void) = 0;
    virtual unsigned int RetryTimes(void) = 0;
    virtual ResponseCode Response(const char *buf, const unsigned int &length) = 0;
};
constexpr int INVALID_INDEX = -1;
class VNetWorkHardware
{
public:
    VNetWorkHardware() = default;
    virtual ~VNetWorkHardware() = default;
    virtual RETURN_CODE Init(void) { return VReturnCode::NewCode(VReturnCodeDefine::NOT_OK_VIRTUAL_FUNCTION); }
    virtual RETURN_CODE UnInit(void) { return VReturnCode::NewCode(VReturnCodeDefine::NOT_OK_VIRTUAL_FUNCTION); }
    virtual RETURN_CODE NetworkWrite(std::shared_ptr<VNetworkTask> task) { return VReturnCode::NewCode(VReturnCodeDefine::NOT_OK_VIRTUAL_FUNCTION); }
    virtual bool IsModuleWorking(void) { return false; }
    virtual RETURN_CODE IsHardwareSupport(void) { return VReturnCode::NewCode(VReturnCodeDefine::NOT_OK_VIRTUAL_FUNCTION); }
    virtual RETURN_CODE NetDriverLoad(void) { return VReturnCode::NewCode(VReturnCodeDefine::NOT_OK_VIRTUAL_FUNCTION); }
    virtual unsigned int GetPdpIndex(void) { return INVALID_INDEX; }
};
class CameraFileMessage
{
public:
    CameraFileMessage() = default;
    virtual ~CameraFileMessage() = default;
    SF_FILE_TYPE_E enFileTye;
    std::string mThumbFileName;
    std::string mThumbFilePath;
};
class VCameraHalOwner
{
public:
    VCameraHalOwner() = default;
    virtual ~VCameraHalOwner() = default;
    virtual void CameraFinshTask(const std::vector<CameraFileMessage> &files) = 0;
    virtual void SpontaneousTaskFromCamera(const std::vector<CameraFileMessage> &files) = 0;
    virtual int AudioStream_write(const char *pu8Addr, const unsigned int &u32Len, const unsigned int &TimeStamp) = 0;
    virtual int VideoStream_write(char *pu8Addr, const unsigned int &u32Len, const unsigned int &TimeStamp, const unsigned int &key_frame) = 0;
};
constexpr int NOT_MULTI_SHOT = false;
constexpr int MULTI_SHOT = true;
class CameraTaskData
{
public:
    CameraTaskData(const CameraTaskType &type, const signed int &isNight, const unsigned int &multiShot)
        : mType(type), mIsNight(isNight), mMultiShot(multiShot)
    {
    }
    ~CameraTaskData()
    {
    }
    const CameraTaskType mType;
    const signed int mIsNight;
    const unsigned int mMultiShot;
};
class VCameraHal
{
public:
    VCameraHal() = default;
    virtual ~VCameraHal() = default;
    virtual RETURN_CODE SetCameraOwner(std::shared_ptr<VCameraHalOwner> &owner) { return VReturnCode::NewCode(VReturnCodeDefine::NOT_OK_VIRTUAL_FUNCTION); }
    virtual RETURN_CODE StartSingleTask(const CameraTaskData &data) { return VReturnCode::NewCode(VReturnCodeDefine::NOT_OK_VIRTUAL_FUNCTION); }
    virtual RETURN_CODE StopTask(void) { return VReturnCode::NewCode(VReturnCodeDefine::NOT_OK_VIRTUAL_FUNCTION); }
    virtual RETURN_CODE sf_venc_stream_thread(void) { return VReturnCode::NewCode(VReturnCodeDefine::NOT_OK_VIRTUAL_FUNCTION); }
    virtual RETURN_CODE SetNightMode(const bool &isNight) { return VReturnCode::NewCode(VReturnCodeDefine::NOT_OK_VIRTUAL_FUNCTION); }
    virtual RETURN_CODE HalBeReadyForLive(void) { return VReturnCode::NewCode(VReturnCodeDefine::NOT_OK_VIRTUAL_FUNCTION); }
    virtual void sf_venc_stream_start(void) {}
    virtual void sf_venc_stream_stop(void) {}
    virtual void sf_audio_stream_start(void) {}
    virtual void sf_audio_stream_stop(void) {}
};
enum class RtcDeviceSupport
{
    SUPPORT = 0,
    NOT_SUPPORT,
    END
};
class RtcDevice
{
public:
    RtcDevice(const char *rtcDevice, const RtcDeviceSupport &support)
        : mRtcDevice(rtcDevice), mSupport(support)
    {
    }
    ~RtcDevice()
    {
    }
    const char *mRtcDevice;
    const RtcDeviceSupport mSupport;
};
class VLightWeightCPU
{
public:
    VLightWeightCPU() = default;
    virtual ~VLightWeightCPU() = default;
    virtual bool Read(char *readBuf, const unsigned int length) { return 0; }
    virtual bool Write(const char *writeBuf, const unsigned length) { return 0; }
};
class McuDeviceInformation
{
public:
    McuDeviceInformation(const char *device, const int &speed, const char &flow_ctrl, const int &databits, const int &stopbits, const char &parity)
        : mDevice(device), mSpeed(speed), mFlow_ctrl(flow_ctrl), mDatabits(databits), mStopbits(stopbits), mParity(parity)
    {
    }
    ~McuDeviceInformation() = default;
    const char *mDevice;
    const int mSpeed;
    const char mFlow_ctrl;
    const int mDatabits;
    const int mStopbits;
    const char mParity;
};
enum class SdCardEvent
{
    MOUNT_SUCCEED = 0,
    MOUNT_FAILED,
    SD_ERROR,
    SD_OUT,
    SD_FULL,
    END
};
class VSDCardOwner
{
public:
    VSDCardOwner() = default;
    virtual ~VSDCardOwner() = default;
    virtual void SDCardHalEvent(const SdCardEvent &event) {}
};
class VSDCardHal
{
public:
    VSDCardHal() = default;
    virtual ~VSDCardHal() = default;
    virtual RETURN_CODE GetSdCardState(SdCardEvent &state) { return VReturnCode::NewCode(VReturnCodeDefine::NOT_OK_VIRTUAL_FUNCTION); }
    virtual RETURN_CODE SetOwner(const std::shared_ptr<VSDCardOwner> &owner) { return VReturnCode::NewCode(VReturnCodeDefine::NOT_OK_VIRTUAL_FUNCTION); }
    virtual RETURN_CODE Format(void) { return VReturnCode::NewCode(VReturnCodeDefine::NOT_OK_VIRTUAL_FUNCTION); }
    virtual RETURN_CODE MsdcMode(void) { return VReturnCode::NewCode(VReturnCodeDefine::NOT_OK_VIRTUAL_FUNCTION); }
    virtual RETURN_CODE UvcMode(void) { return VReturnCode::NewCode(VReturnCodeDefine::NOT_OK_VIRTUAL_FUNCTION); }
};
enum class NETWORK_MODULE_UPGRADE_RESULT
{
    SUCCEED = 0,
    FAILED,
    END
};
class NetWorkUpgradeResult
{
public:
    NetWorkUpgradeResult(const NETWORK_MODULE_UPGRADE_RESULT &result)
        : mResult(result)
    {
    }
    ~NetWorkUpgradeResult() = default;
    const NETWORK_MODULE_UPGRADE_RESULT mResult;
};
class IHal
{
public:
    IHal() = default;
    virtual ~IHal() = default;
    static std::shared_ptr<IHal> &GetInstance(std::shared_ptr<IHal> *impl = nullptr);
    virtual RETURN_CODE Init(void) { return VReturnCode::NewCode(VReturnCodeDefine::NOT_OK_VIRTUAL_FUNCTION); }
    virtual RETURN_CODE UnInit(void) { return VReturnCode::NewCode(VReturnCodeDefine::NOT_OK_VIRTUAL_FUNCTION); }
    virtual RETURN_CODE GetKeyContrlHandle(const SfKeyDefine &key, std::shared_ptr<VKeyContrl> &keyContrl) { return VReturnCode::NewCode(VReturnCodeDefine::NOT_OK_VIRTUAL_FUNCTION); }
    virtual RETURN_CODE GetGpioInputHandle(const GpioPin &gpio, std::shared_ptr<VGpioInputHandle> &gpioHandle) { return VReturnCode::NewCode(VReturnCodeDefine::NOT_OK_VIRTUAL_FUNCTION); }
    virtual RETURN_CODE GetLedContrlHandle(const SfLedIndex &led, std::shared_ptr<VLedContrl> &ledContrl) { return VReturnCode::NewCode(VReturnCodeDefine::NOT_OK_VIRTUAL_FUNCTION); }
    virtual RETURN_CODE GetNetworkHardware(std::shared_ptr<VNetWorkHardware> &module) { return VReturnCode::NewCode(VReturnCodeDefine::NOT_OK_VIRTUAL_FUNCTION); }
    virtual RETURN_CODE GetCameraHal(const CameraType &type, std::shared_ptr<VCameraHal> &camera) { return VReturnCode::NewCode(VReturnCodeDefine::NOT_OK_VIRTUAL_FUNCTION); }
    virtual const RtcDevice &GetRtcDevice(void)
    {
        static RtcDevice rtc("Not_support", RtcDeviceSupport::NOT_SUPPORT);
        return rtc;
    }
    virtual const char *GetSDCardSystemPath(void) { return "./sdcard/"; }
    virtual const char *GetPictureThumbPath(void) { return "./sdcard/DCIM/THUMB/"; }
    virtual const char *GetVideoStreamPath(void) { return "./sdcard/DCIM/SMALL/"; }
    virtual const char *GetSDCardCheckPath(void) { return "./sdcard/DCIM"; }
    virtual RETURN_CODE GetLightWeightCPU(std::shared_ptr<VLightWeightCPU> &lcpu) { return VReturnCode::NewCode(VReturnCodeDefine::NOT_OK_VIRTUAL_FUNCTION); }
    virtual const McuDeviceInformation GetMcuDeviceInformation(void)
    {
        McuDeviceInformation info("", 0, 0, 0, 0, 0);
        return info;
    }
    virtual void DoSomethingBeforPowerOff(void) {}
    virtual RETURN_CODE GetSDCardHal(std::shared_ptr<VSDCardHal> &sdCardHal) { return VReturnCode::NewCode(VReturnCodeDefine::NOT_OK_VIRTUAL_FUNCTION); }
    virtual const NetWorkUpgradeResult NetworkModuleUpgrade(void)
    {
        NetWorkUpgradeResult result(NETWORK_MODULE_UPGRADE_RESULT::END);
        return result;
    }
};
bool CreateHalModuleInstance(void);
#endif // !IHAL_H