Improve:SD card event.

application/MissionManager/src/DataProcessing.h

@@ -23,6 +23,7 @@ using DataProcessingFunc = std::function<bool(VStateMachineData *)>;
 enum class InternalStateEvent
 {
     STORAGE_HANDLE_STATE_INIT = static_cast<int>(MissionEvent::END),
+    SD_CARD_HANDLE_STATE_SD_STATUS_REPORTED,
     MEDIA_REPORT_EVENT,
     END
 };

application/MissionManager/src/MissionState.cpp

@@ -19,6 +19,8 @@
 MissionState::MissionState(const std::string &name) : State(name)
 {
     mEventHandle[InternalStateEvent::MEDIA_REPORT_EVENT] = std::bind(&MissionState::MediaReportHandle, this, _1);
+    mEventHandle[InternalStateEvent::SD_CARD_HANDLE_STATE_SD_STATUS_REPORTED] =
+        std::bind(&MissionState::SdCardEventReportHandle, this, _1);
 }
 void MissionState::GoInState()
 {
@@ -38,3 +40,9 @@ bool MissionState::MediaReportHandle(VStateMachineData *msg)
     MissionStateMachine::GetInstance()->SwitchState(SystemState::STORAGE_HANDLE_STATE);
     return EXECUTED;
 }
+bool MissionState::SdCardEventReportHandle(VStateMachineData *msg)
+{
+    MissionStateMachine::GetInstance()->DelayMessage(msg);
+    MissionStateMachine::GetInstance()->SwitchState(SystemState::SD_CARD_HANDLE_STATE);
+    return EXECUTED;
+}

application/MissionManager/src/MissionState.h

@@ -27,5 +27,6 @@ public:
 
 private:
     bool MediaReportHandle(VStateMachineData *msg);
+    bool SdCardEventReportHandle(VStateMachineData *msg);
 };
 #endif

application/MissionManager/src/MissionStateMachine.cpp

@@ -99,6 +99,10 @@ void MissionStateMachine::RunStateMachine(const IpcMission &mission)
                              mStateTree[SystemState::STORAGE_HANDLE_STATE].get());
     mStateMachine->SetCurrentState(mStateTree[SystemState::TOP_STATE].get());
     mStateMachine->StartStateMachine();
+    /**
+     * @brief The business can only be processed after the state machine is started.
+     *
+     */
     std::shared_ptr<VMissionData> message =
         std::make_shared<VMissionData>(static_cast<MissionEvent>(InternalStateEvent::STORAGE_HANDLE_STATE_INIT));
     SendStateMessage(message);

application/MissionManager/src/SdCardHandleState.cpp

@@ -17,9 +17,11 @@
 #include "ILog.h"
 #include "IMediaManager.h"
 #include "MissionStateMachine.h"
-SdCardHandleState::SdCardHandleState() : State("SdCardHandleState")
+SdCardHandleState::SdCardHandleState() : State("SdCardHandleState"), mSdCardStatus(StorageEvent::END)
 {
     mEventHandle[InternalStateEvent::MEDIA_REPORT_EVENT] = std::bind(&SdCardHandleState::MediaReportHandle, this, _1);
+    mEventHandle[InternalStateEvent::SD_CARD_HANDLE_STATE_SD_STATUS_REPORTED] =
+        std::bind(&SdCardHandleState::SdCardEventHandle, this, _1);
 }
 void SdCardHandleState::GoInState()
 {
@@ -43,6 +45,15 @@ bool SdCardHandleState::MediaReportHandle(VStateMachineData *msg)
         LogError("nullptr pointer.\n");
         return NOT_EXECUTED;
     }
+    if (StorageEvent::SD_CARD_INSERT != mSdCardStatus) {
+        /**
+         * @brief The SD card has not been mounted yet, cache the data for the quick start first.
+         *
+         */
+        LogWarning("Sd card is not inserted, cache data.\n");
+        mFileNeedToSave = std::make_shared<SaveFileInfo>(data->mData.mFileName);
+        return EXECUTED;
+    }
     LogInfo("file = %s.\n", data->mData.mFileName.c_str());
     SaveFileInfo saveFileInfo(data->mData.mFileName);
     StatusCode code = IFilesManager::GetInstance()->SaveFile(saveFileInfo);
@@ -51,3 +62,20 @@ bool SdCardHandleState::MediaReportHandle(VStateMachineData *msg)
     }
     return EXECUTED;
 }
+bool SdCardHandleState::SdCardEventHandle(VStateMachineData *msg)
+{
+    std::shared_ptr<MissionMessage> message = std::dynamic_pointer_cast<MissionMessage>(msg->GetMessageObj());
+    std::shared_ptr<VMissionDataV2<StorageEvent>> data =
+        std::dynamic_pointer_cast<VMissionDataV2<StorageEvent>>(message->mMissionData);
+    LogInfo(" SdCardEventHandle event:%s.\n", IStorageManager::GetInstance()->PrintStringStorageEvent(data->mData));
+    if (mFileNeedToSave && StorageEvent::SD_CARD_INSERT == data->mData) {
+        LogInfo("Sd card is inserted for the first time.\n");
+        StatusCode code = IFilesManager::GetInstance()->SaveFile(*(mFileNeedToSave.get()));
+        if (IsCodeOK(code) == false) {
+            LogError("SaveFile failed.\n");
+        }
+        mFileNeedToSave.reset();
+    }
+    mSdCardStatus = data->mData;
+    return EXECUTED;
+}

application/MissionManager/src/SdCardHandleState.h

@@ -17,6 +17,8 @@
 #include "DataProcessing.h"
 #include "IMediaManager.h"
 #include "IStateMachine.h"
+#include "IStorageManager.h"
+#include "IFilesManager.h"
 class SdCardHandleState : public State, public DataProcessing, public std::enable_shared_from_this<SdCardHandleState>
 {
 public:
@@ -28,5 +30,10 @@ public:
 
 private:
     bool MediaReportHandle(VStateMachineData *msg);
+    bool SdCardEventHandle(VStateMachineData *msg);
+
+private:
+    StorageEvent mSdCardStatus;
+    std::shared_ptr<SaveFileInfo> mFileNeedToSave;
 };
 #endif

application/MissionManager/src/StorageHandleState.cpp

@@ -45,6 +45,9 @@ void StorageHandleState::UnInit(void)
 void StorageHandleState::ReportEvent(const StorageEvent &event)
 {
     LogInfo("StorageHandleState::ReportEvent.\n");
+    std::shared_ptr<VMissionData> message = std::make_shared<VMissionDataV2<StorageEvent>>(
+        static_cast<MissionEvent>(InternalStateEvent::SD_CARD_HANDLE_STATE_SD_STATUS_REPORTED), event);
+    MissionStateMachine::GetInstance()->SendStateMessage(message);
 }
 bool StorageHandleState::StorageStartInitHandle(VStateMachineData *msg)
 {

hal/include/IHalCpp.h

@@ -34,7 +34,9 @@ enum class SdCardHalStatus
     MOUNTED = 0,
     UNMOUNTED,
     INSERTED,
-    PULL_OUT,
+    PULL_OUT_DEVICE_NOT_EXIST,
+    PULL_OUT_OPEN_FAILED,
+    PULL_OUT_NOT_BLOCK_DEVICE,
     ERROR,
     END
 };

hal/src/SdCardHal.cpp

@@ -24,10 +24,8 @@
 #include <sys/types.h>
 #include <unistd.h>
 const char *SD_CARD_DEVICE = SD_CARD_DEV;
-SdCardHal::SdCardHal()
+SdCardHal::SdCardHal() : mStatus(SdCardHalStatus::END), mThreadRuning(false), mDeviceFd(-1)
 {
-    mThreadRuning = false;
-    mStatus = SdCardHalStatus::END;
 }
 void SdCardHal::SetSdCardMonitor(std::shared_ptr<VSdCardHalMonitor> &monitor)
 {
@@ -57,35 +55,52 @@ void SdCardHal::UnInit(void)
 void SdCardHal::DevDetectingThread(void)
 {
     constexpr int SLEEP_TIME_MS = 100;
+    constexpr int DEVICE_EXIST = 0;
     // SdCardHalStatus status = SdCardHalStatus::END;
-    int fd = -1;
     // const char *SD_CARD_DEVICE = "/SD_CARD_DEVICE/mmcblk1p1";
     mThreadRuning = true;
     while (mThreadRuning) {
-        fd = fx_open(SD_CARD_DEVICE, O_RDONLY);
+        if (access(SD_CARD_DEVICE, F_OK) != DEVICE_EXIST) {
-        if (fd < 0) {
+            if (SdCardHalStatus::PULL_OUT_DEVICE_NOT_EXIST != mStatus) {
+                mStatus = SdCardHalStatus::PULL_OUT_DEVICE_NOT_EXIST;
+                ReportDetecedChangedResult(mStatus);
+            }
+            if (mDeviceFd > 0) {
+                close(mDeviceFd);
+                mDeviceFd = -1;
+            }
+            goto CONTINUE;
+        }
+        if (mDeviceFd < 0) {
+            mDeviceFd = fx_open(SD_CARD_DEVICE, O_RDONLY);
+            if (mDeviceFd < 0) {
                 // LogInfo("sdCardHal: %s open failed.\n", SD_CARD_DEVICE);
-            if (SdCardHalStatus::PULL_OUT != mStatus) {
+                if (SdCardHalStatus::PULL_OUT_OPEN_FAILED != mStatus) {
-                mStatus = SdCardHalStatus::PULL_OUT;
+                    mStatus = SdCardHalStatus::PULL_OUT_OPEN_FAILED;
                     ReportDetecedChangedResult(mStatus);
                 }
                 goto CONTINUE;
             }
+        }
         struct stat sdStat;
-        if (fx_fstat(fd, &sdStat) < 0) {
+        if (fx_fstat(mDeviceFd, &sdStat) < 0) {
             // LogInfo("sdCardHal: %s fstat failed.\n", SD_CARD_DEVICE);
             if (SdCardHalStatus::ERROR != mStatus) {
                 mStatus = SdCardHalStatus::ERROR;
                 ReportDetecedChangedResult(mStatus);
             }
+            close(mDeviceFd);
+            mDeviceFd = -1;
             goto CONTINUE;
         }
         if (!S_ISBLK(sdStat.st_mode)) {
             // LogInfo("sdCardHal: %s is not block device.\n", SD_CARD_DEVICE);
-            if (SdCardHalStatus::PULL_OUT != mStatus) {
+            if (SdCardHalStatus::PULL_OUT_NOT_BLOCK_DEVICE != mStatus) {
-                mStatus = SdCardHalStatus::PULL_OUT;
+                mStatus = SdCardHalStatus::PULL_OUT_NOT_BLOCK_DEVICE;
                 ReportDetecedChangedResult(mStatus);
             }
+            close(mDeviceFd);
+            mDeviceFd = -1;
         }
         else {
             // LogInfo("sdCardHal: %s is inserted.\n", SD_CARD_DEVICE);
@@ -97,22 +112,32 @@ void SdCardHal::DevDetectingThread(void)
     CONTINUE:
         std::this_thread::sleep_for(std::chrono::milliseconds(SLEEP_TIME_MS));
     }
+    if (mDeviceFd > 0) {
+        close(mDeviceFd);
+        mDeviceFd = -1;
+    }
 }
 void SdCardHal::ReportDetecedChangedResult(const SdCardHalStatus &status)
 {
     LogInfo("SdCardHalStatus changed: %s.\n", PrintfStatusString(status));
+    SdCardHalStatus mountedStatus = SdCardHalStatus::END;
     if (SdCardHalStatus::INSERTED == status) {
         LogInfo("mount sd SD_CARD_DEVICE %s.\n", SD_CARD_MOUNT_PATH);
         constexpr int BUF_LENGTH = 128;
         char cmd[BUF_LENGTH] = {0};
         snprintf(cmd, BUF_LENGTH, "mount %s %s", SD_CARD_DEV, SD_CARD_MOUNT_PATH);
         fx_system(cmd);
+        mountedStatus = SdCardHalStatus::MOUNTED;
     }
     auto monitor = mMonitor.lock();
     if (mMonitor.expired()) {
         LogWarning("SdCardHal: monitor is expired.\n");
         return;
     }
+    if (SdCardHalStatus::END != mountedStatus) {
+        monitor->ReportEvent(mountedStatus);
+        return;
+    }
     monitor->ReportEvent(status);
 }
 const char *SdCardHal::PrintfStatusString(const SdCardHalStatus &status)
@@ -124,8 +149,12 @@ const char *SdCardHal::PrintfStatusString(const SdCardHalStatus &status)
         return "UNMOUNTED.";
     case SdCardHalStatus::INSERTED:
         return "INSERTED.";
-    case SdCardHalStatus::PULL_OUT:
+    case SdCardHalStatus::PULL_OUT_DEVICE_NOT_EXIST:
-        return "PULL_OUT.";
+        return "PULL_OUT_DEVICE_NOT_EXIST.";
+    case SdCardHalStatus::PULL_OUT_OPEN_FAILED:
+        return "PULL_OUT_OPEN_FAILED.";
+    case SdCardHalStatus::PULL_OUT_NOT_BLOCK_DEVICE:
+        return "PULL_OUT_NOT_BLOCK_DEVICE.";
     case SdCardHalStatus::END:
         return "END.";
     default:

hal/src/SdCardHal.h

@@ -36,5 +36,6 @@ private:
     bool mThreadRuning;
     std::thread mDevDetectingThread;
     std::weak_ptr<VSdCardHalMonitor> mMonitor;
+    int mDeviceFd;
 };
 #endif

middleware/StorageManager/include/IStorageManager.h

@@ -43,5 +43,6 @@ public:
     virtual StatusCode UnInit(void);
     virtual StatusCode SetMonitor(std::shared_ptr<VStorageMoniter> &monitor);
     virtual StatusCode SaveFile(const std::string &sourceFile, const std::string &savePaht);
+    virtual const char *PrintStringStorageEvent(const StorageEvent &event);
 };
 #endif

middleware/StorageManager/src/IStorageManager.cpp

@@ -47,3 +47,7 @@ StatusCode IStorageManager::SaveFile(const std::string &sourceFile, const std::s
 {
     return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
 }
+const char *IStorageManager::PrintStringStorageEvent(const StorageEvent &event)
+{
+    return "STATUS_CODE_VIRTUAL_FUNCTION";
+}

middleware/StorageManager/src/SdCardHandle.cpp

@@ -69,7 +69,9 @@ StorageEvent SdCardHandle::StorageEventConvert(const SdCardHalStatus &status)
         return StorageEvent::SD_CARD_REMOVE;
     case SdCardHalStatus::INSERTED:
         return StorageEvent::SD_ABNORMAL;
-    case SdCardHalStatus::PULL_OUT:
+    case SdCardHalStatus::PULL_OUT_DEVICE_NOT_EXIST:
+    case SdCardHalStatus::PULL_OUT_OPEN_FAILED:
+    case SdCardHalStatus::PULL_OUT_NOT_BLOCK_DEVICE:
         return StorageEvent::SD_CARD_REMOVE;
     case SdCardHalStatus::ERROR:
         return StorageEvent::SD_ABNORMAL;

middleware/StorageManager/src/StorageBase.cpp

@@ -59,3 +59,33 @@ bool StorageBase::CheckDirectory(const char *filepath)
     free(path);
     return true;
 }
+const char *StorageBase::PrintStringStorageEvent(const StorageEvent &event)
+{
+    switch (event) {
+    case StorageEvent::SD_CARD_INSERT: {
+        return "SD_CARD_INSERT";
+        break;
+    }
+    case StorageEvent::SD_CARD_REMOVE: {
+        return "SD_CARD_REMOVE";
+        break;
+    }
+    case StorageEvent::SD_ABNORMAL: {
+        return "SD_ABNORMAL";
+        break;
+    }
+    case StorageEvent::EMMC_NORMAL: {
+        return "EMMC_NORMAL";
+        break;
+    }
+    case StorageEvent::END: {
+        return "END";
+        break;
+    }
+
+    default: {
+        return "UNDEFINE";
+        break;
+    }
+    }
+}

middleware/StorageManager/src/StorageBase.h

@@ -23,6 +23,9 @@ public:
     virtual ~StorageBase() = default;
     bool CheckDirectory(const char *filepath);
 
+protected:
+    const char *PrintStringStorageEvent(const StorageEvent &event);
+
 protected:
     std::weak_ptr<VStorageMoniter> mStorageMonitor;
 };

middleware/StorageManager/src/StorageManagerImpl.cpp

@@ -34,3 +34,7 @@ StatusCode StorageManagerImpl::SaveFile(const std::string &sourceFile, const std
 {
     return SdCardHandle::SdSaveFile(sourceFile, savePaht);
 }
+const char *StorageManagerImpl::PrintStringStorageEvent(const StorageEvent &event)
+{
+    return StorageBase::PrintStringStorageEvent(event);
+}

middleware/StorageManager/src/StorageManagerImpl.h

@@ -27,5 +27,6 @@ public:
     StatusCode UnInit(void) override;
     StatusCode SetMonitor(std::shared_ptr<VStorageMoniter> &monitor) override;
     StatusCode SaveFile(const std::string &sourceFile, const std::string &savePaht) override;
+    const char *PrintStringStorageEvent(const StorageEvent &event) override;
 };
 #endif