hunting/middleware/McuManager/src/McuManagerImpl.cpp

/*
 * Copyright (c) 2023 Fancy Code.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
#include "McuManagerImpl.h"
#include "ILog.h"
class McuRecvImpl
{
public:
    McuRecvImpl(const unsigned int &serialNumber, const OtherSideSendType &sendType)
        : mSerialNumber(serialNumber), mSendType(sendType)
    {
    }
    virtual ~McuRecvImpl() = default;

protected:
    std::shared_ptr<McuManagerImpl> mMcuManager;
    const unsigned int mSerialNumber;

public:
    const OtherSideSendType mSendType;
};
McuManagerImpl::McuManagerImpl()
{
    mMcuAskHandle[OtherSideSendType::SEND_IPC_MISSION] =
        std::bind(&McuManagerImpl::McuAskSendIpcMissionHandle, this, _1);
    mMcuAskHandle[OtherSideSendType::SEND_HEART_BEAT] = std::bind(&McuManagerImpl::McuAskSendHeartBeatHandle, this, _1);
}
std::shared_ptr<VProtocolBase> McuManagerImpl::SharedFromThis(void)
{
    return shared_from_this();
}
const StatusCode McuManagerImpl::Init(void)
{
    McuDevice::Init();
    McuProtocol::Init();
    return CreateStatusCode(STATUS_CODE_OK);
}
const StatusCode McuManagerImpl::UnInit(void)
{
    McuDevice::UnInit();
    McuProtocol::UnInit();
    mMcuAskList.clear();
    mMonitor.reset();
    return CreateStatusCode(STATUS_CODE_OK);
}
const StatusCode McuManagerImpl::SetMcuMonitor(std::shared_ptr<VMcuMonitor> &monitor)
{
    std::lock_guard<std::mutex> locker(mMutex);
    mMonitor = monitor;
    for (auto ask : mMcuAskList) {
        std::shared_ptr<McuRecvImpl> data = std::dynamic_pointer_cast<McuRecvImpl>(ask);
        auto handle = mMcuAskHandle.find(data->mSendType);
        if (handle != mMcuAskHandle.end()) {
            handle->second(ask);
        }
    }
    mMcuAskList.clear();
    return CreateStatusCode(STATUS_CODE_OK);
}
const StatusCode McuManagerImpl::GetIpcMission(std::shared_ptr<VMcuAsk> &ask)
{
    std::shared_ptr<VProtocolContext> context = std::make_shared<ProtocolContext<std::shared_ptr<VMcuAsk>>>(ask);
    return McuProtocol::GetIpcMission(context);
}
const StatusCode McuManagerImpl::CutOffPowerSupply(std::shared_ptr<VMcuAsk> &ask)
{
    std::shared_ptr<VProtocolContext> context = std::make_shared<ProtocolContext<std::shared_ptr<VMcuAsk>>>(ask);
    return McuProtocol::CutOffPowerSupply(context);
}
const StatusCode McuManagerImpl::FeedWatchDog(std::shared_ptr<VMcuAsk> &ask)
{
    std::shared_ptr<VProtocolContext> context = std::make_shared<ProtocolContext<std::shared_ptr<VMcuAsk>>>(ask);
    return McuProtocol::FeedWatchDog(context);
}
const StatusCode McuManagerImpl::SetFeedingCycleForWatchDog(std::shared_ptr<VMcuAsk> &ask, const unsigned char &hour,
                                                            const unsigned char &min, const unsigned char &second)
{
    std::shared_ptr<VProtocolContext> context = std::make_shared<ProtocolContext<std::shared_ptr<VMcuAsk>>>(ask);
    return McuProtocol::SetFeedingCycleForWatchDog(hour, min, second, context);
}
const StatusCode McuManagerImpl::SetDateTime(std::shared_ptr<VMcuAsk> &ask, const McuAskDateTime &value)
{
    std::shared_ptr<VProtocolContext> context = std::make_shared<ProtocolContext<std::shared_ptr<VMcuAsk>>>(ask);
    return McuProtocol::McuSetDateTime(
        value.mYear, value.mMon, value.mDay, value.mHour, value.mMin, value.mSecond, context);
}
const StatusCode McuManagerImpl::SetPirSensitivity(std::shared_ptr<VMcuAsk> &ask, const unsigned char &sensitivity)
{
    std::shared_ptr<VProtocolContext> context = std::make_shared<ProtocolContext<std::shared_ptr<VMcuAsk>>>(ask);
    return McuProtocol::SetPirSensitivity(sensitivity, context);
}
const StatusCode McuManagerImpl::ContorlInfraredLight(std::shared_ptr<VMcuAsk> &ask, const ControlLight &control)
{
    std::shared_ptr<VProtocolContext> context = std::make_shared<ProtocolContext<std::shared_ptr<VMcuAsk>>>(ask);
    return McuProtocol::ContorlInfraredLight(static_cast<const unsigned char>(control), context);
}
const StatusCode McuManagerImpl::GetPhotosensitivityValue(std::shared_ptr<VMcuAsk> &ask)
{
    std::shared_ptr<VProtocolContext> context = std::make_shared<ProtocolContext<std::shared_ptr<VMcuAsk>>>(ask);
    return McuProtocol::GetPhotosensitivityValue(context);
}
const char *McuManagerImpl::PrintIpcMissionString(const IpcMission &mission)
{
    switch (mission) {
    case IpcMission::PIR_TRIGGERED: {
        return "PIR_TRIGGERED";
    }
    case IpcMission::TEST: {
        return "TEST";
    }
    case IpcMission::CONTINUOUS_SHOOTING: {
        return "CONTINUOUS_SHOOTING";
    }
    case IpcMission::PIR_TRIGGERED_DELAY: {
        return "PIR_TRIGGERED_DELAY";
    }
    case IpcMission::REGULAR_START: {
        return "REGULAR_START";
    }
    default: {
        return "UNKNOWN";
    }
    }
}
std::shared_ptr<VMcuMonitor> McuManagerImpl::GetMcuMonitor(void)
{
    auto monitor = mMonitor.lock();
    if (!monitor) {
        LogWarning("mMonitor is nullptr.\n");
        return nullptr;
    }
    if (mMonitor.expired()) {
        LogWarning("mMonitor shared ptr expired failed.\n");
        return nullptr;
    }
    return monitor;
}
void McuManagerImpl::OtherSideSendIpcMission(const unsigned int &serialNumber, const unsigned char &mission)
{
    class McuRecvIpcMission : public McuRecvImpl, public McuRecv<unsigned char>
    {
    public:
        McuRecvIpcMission(std::shared_ptr<McuManagerImpl> &mcuManager, const unsigned int &serialNumber,
                          const OtherSideSendType &sendType, const unsigned char &mission)
            : McuRecvImpl(serialNumber, sendType)
        {
            McuRecv::mDataRecvReply = mission;
            McuRecvImpl::mMcuManager = mcuManager;
        }
        ~McuRecvIpcMission() = default;
        void ReplyFinished(const bool result) override
        {
            McuRecvImpl::mMcuManager->ReplyOtherSideSendIpcMission(ASK_RESULT::SUCCEED, McuRecvImpl::mSerialNumber);
        }
    };
    std::shared_ptr<VMcuMonitor> monitor = GetMcuMonitor();
    std::shared_ptr<McuManagerImpl> manager = std::dynamic_pointer_cast<McuManagerImpl>(SharedFromThis());
    std::shared_ptr<VMcuRecv> recv =
        std::make_shared<McuRecvIpcMission>(manager, serialNumber, OtherSideSendType::SEND_IPC_MISSION, mission);
    if (monitor) {
        monitor->RecvIpcMissionEvent(recv, static_cast<IpcMission>(mission));
    }
    else {
        LogWarning("mMonitor is nullptr, AddMcuRecv.\n");
        AddMcuRecv(recv);
    }
}
void McuManagerImpl::OtherSideSendHearBeat(const unsigned int &serialNumber)
{
    class McuRecvHeartBeat : public McuRecvImpl, public VMcuRecv
    {
    public:
        McuRecvHeartBeat(std::shared_ptr<McuManagerImpl> &mcuManager, const unsigned int &serialNumber,
                         const OtherSideSendType &sendType)
            : McuRecvImpl(serialNumber, sendType)
        {
            McuRecvImpl::mMcuManager = mcuManager;
        }
        ~McuRecvHeartBeat() = default;
        void ReplyFinished(const bool result) override
        {
            McuRecvImpl::mMcuManager->ReplyOtherSideSendHeartBeat(McuRecvImpl::mSerialNumber);
        }
    };
    std::shared_ptr<VMcuMonitor> monitor = GetMcuMonitor();
    std::shared_ptr<McuManagerImpl> manager = std::dynamic_pointer_cast<McuManagerImpl>(SharedFromThis());
    std::shared_ptr<VMcuRecv> recv =
        std::make_shared<McuRecvHeartBeat>(manager, serialNumber, OtherSideSendType::SEND_HEART_BEAT);
    if (monitor) {
        LogInfo("Mcu manager report heart beat to mcu monitor.\n");
        monitor->RecvMcuHeartBeatEvent(recv);
    }
    else {
        LogWarning("mMonitor is nullptr, AddMcuRecv.\n");
        AddMcuRecv(recv);
    }
}
void McuManagerImpl::OtherSideSendGetIntervalStart(const unsigned int &serialNumber)
{
    class McuRecvGetIntervalStart : public McuRecvImpl, public McuRecv<McuGetIntervalStart>
    {
    public:
        McuRecvGetIntervalStart(std::shared_ptr<McuManagerImpl> &mcuManager, const unsigned int &serialNumber,
                                const OtherSideSendType &sendType)
            : McuRecvImpl(serialNumber, sendType)
        {
            McuRecvImpl::mMcuManager = mcuManager;
        }
        ~McuRecvGetIntervalStart() = default;
        void ReplyFinished(const bool result) override
        {
            LogInfo("OtherSideSendGetIntervalStart finised.\n");
            McuRecvImpl::mMcuManager->ReplyOtherSideSendGetIntervalStart(mDataRecvReply, McuRecvImpl::mSerialNumber);
        }
    };
    std::shared_ptr<VMcuMonitor> monitor = GetMcuMonitor();
    std::shared_ptr<McuManagerImpl> manager = std::dynamic_pointer_cast<McuManagerImpl>(SharedFromThis());
    std::shared_ptr<VMcuRecv> recv =
        std::make_shared<McuRecvGetIntervalStart>(manager, serialNumber, OtherSideSendType::GET_INTERVAL_START);
    if (monitor) {
        LogInfo("Mcu manager report get interval start to mcu monitor.\n");
        monitor->RecvGetIntervalStartEvent(recv);
    }
    else {
        LogWarning("mMonitor is nullptr, AddMcuRecv.\n");
        AddMcuRecv(recv);
    }
}
void McuManagerImpl::OtherSideSendGetDateTime(const unsigned int &serialNumber)
{
    class McuRecvGetDateTime : public McuRecvImpl, public McuRecv<McuReplyDateTime>
    {
    public:
        McuRecvGetDateTime(std::shared_ptr<McuManagerImpl> &mcuManager, const unsigned int &serialNumber,
                           const OtherSideSendType &sendType)
            : McuRecvImpl(serialNumber, sendType)
        {
            McuRecvImpl::mMcuManager = mcuManager;
        }
        ~McuRecvGetDateTime() = default;
        void ReplyFinished(const bool result) override
        {
            McuRecvImpl::mMcuManager->ReplyOtherSideSendGetDateTime(mDataRecvReply, McuRecvImpl::mSerialNumber);
        }
    };
    std::shared_ptr<VMcuMonitor> monitor = GetMcuMonitor();
    std::shared_ptr<McuManagerImpl> manager = std::dynamic_pointer_cast<McuManagerImpl>(SharedFromThis());
    std::shared_ptr<VMcuRecv> recv =
        std::make_shared<McuRecvGetDateTime>(manager, serialNumber, OtherSideSendType::GET_DATE_TIME);
    if (monitor) {
        LogInfo("Mcu manager report heart beat to mcu monitor.\n");
        monitor->RecvMcuHeartBeatEvent(recv);
    }
    else {
        LogWarning("mMonitor is nullptr, AddMcuRecv.\n");
        AddMcuRecv(recv);
    }
}
void McuManagerImpl::OtherSideSendGetPirSensitivity(const unsigned int &serialNumber)
{
    class McuRecvGetDateTime : public McuRecvImpl, public McuRecv<McuGetPirSensitivity>
    {
    public:
        McuRecvGetDateTime(std::shared_ptr<McuManagerImpl> &mcuManager, const unsigned int &serialNumber,
                           const OtherSideSendType &sendType)
            : McuRecvImpl(serialNumber, sendType)
        {
            McuRecvImpl::mMcuManager = mcuManager;
        }
        ~McuRecvGetDateTime() = default;
        void ReplyFinished(const bool result) override
        {
            McuRecvImpl::mMcuManager->ReplyOtherSideSendGetPirSensitivity(mDataRecvReply.mSensitivity,
                                                                          McuRecvImpl::mSerialNumber);
        }
    };
    std::shared_ptr<VMcuMonitor> monitor = GetMcuMonitor();
    std::shared_ptr<McuManagerImpl> manager = std::dynamic_pointer_cast<McuManagerImpl>(SharedFromThis());
    std::shared_ptr<VMcuRecv> recv =
        std::make_shared<McuRecvGetDateTime>(manager, serialNumber, OtherSideSendType::GET_DATE_TIME);
    if (monitor) {
        LogInfo("Mcu manager report heart beat to mcu monitor.\n");
        monitor->RecvMcuHeartBeatEvent(recv);
    }
    else {
        LogWarning("mMonitor is nullptr, AddMcuRecv.\n");
        AddMcuRecv(recv);
    }
}
void McuManagerImpl::ReplyOtherSideSendIpcMission(const ASK_RESULT &result, const unsigned int &serialNumber)
{
    LogInfo("ReplyOtherSideSendIpcMission\n");
    McuProtocol::ReplyOtherSideSendIpcMission(static_cast<ReplyResult>(result), serialNumber);
}
void McuManagerImpl::ReplyOtherSideSendHeartBeat(const unsigned int &serialNumber)
{
    LogInfo("ReplyOtherSideSendHeartBeat\n");
    McuProtocol::ReplyOtherSideSendHearBeat(static_cast<ReplyResult>(ASK_RESULT::SUCCEED), serialNumber);
}
void McuManagerImpl::ReplyOtherSideSendGetIntervalStart(const McuGetIntervalStart &interval,
                                                        const unsigned int &serialNumber)
{
    LogInfo("ReplyOtherSideSendGetIntervalStart\n");
    McuProtocol::ReplyOtherSideSendGetIntervalStart(
        static_cast<ReplyResult>(ASK_RESULT::SUCCEED), serialNumber, interval.mHour, interval.mMin, interval.mSecond);
}
void McuManagerImpl::ReplyOtherSideSendGetDateTime(const McuReplyDateTime &time, const unsigned int &serialNumber)
{
    LogInfo("ReplyOtherSideSendGetDateTime\n");
    McuProtocol::ReplyOtherSideSendGetDateTime(static_cast<ReplyResult>(ASK_RESULT::SUCCEED),
                                               serialNumber,
                                               time.mYear,
                                               time.mMon,
                                               time.mDay,
                                               time.mHour,
                                               time.mMin,
                                               time.mSecond);
}
void McuManagerImpl::ReplyOtherSideSendGetPirSensitivity(const unsigned char &sensitivity,
                                                         const unsigned int &serialNumber)
{
    LogInfo("ReplyOtherSideSendGetPirSensitivity\n");
    McuProtocol::ReplyOtherSideSendGetPirSensitivity(
        static_cast<ReplyResult>(ASK_RESULT::SUCCEED), serialNumber, sensitivity);
}
void McuManagerImpl::AddMcuRecv(std::shared_ptr<VMcuRecv> &recv)
{
    std::lock_guard<std::mutex> locker(mMutex);
    mMcuAskList.push_back(recv);
}
void McuManagerImpl::McuAskSendIpcMissionHandle(std::shared_ptr<VMcuRecv> &recv)
{
    std::shared_ptr<VMcuMonitor> monitor = GetMcuMonitor();
    std::shared_ptr<McuRecv<unsigned char>> data = std::dynamic_pointer_cast<McuRecv<unsigned char>>(recv);
    if (monitor) {
        monitor->RecvIpcMissionEvent(recv, static_cast<IpcMission>(data->mDataRecvReply));
    }
}
void McuManagerImpl::McuAskSendHeartBeatHandle(std::shared_ptr<VMcuRecv> &recv)
{
    std::shared_ptr<VMcuMonitor> monitor = GetMcuMonitor();
    if (monitor) {
        monitor->RecvMcuHeartBeatEvent(recv);
    }
}