Format sd card.

application/MissionManager/src/DataProcessing.h

@@ -30,6 +30,7 @@ enum class InternalStateEvent
     MEDIA_REPORT_EVENT,
     KEY_EVENT_HANDLE,
     RESET_KEY_MEDIA_TASK,
+    FORMAT_KEY_FORMAT_SD_CARD,
     MEDIA_HANDLE_STATE_TASK_TIME_OUT,
     MEDIA_HANDLE_STATE_TASK_FINISHED,
     END

application/MissionManager/src/IdleState.cpp

@@ -24,6 +24,8 @@ IdleState::IdleState() : State("IdleState")
     // mEventHandle[InternalStateEvent::SD_CARD_HANDLE_STATE_SD_STATUS_REPORTED] =
     //     std::bind(&IdleState::SdCardEventHandle, this, _1);
     mEventHandle[InternalStateEvent::RESET_KEY_MEDIA_TASK] = std::bind(&IdleState::ResetKeyMediaTaskHandle, this, _1);
+    mEventHandle[InternalStateEvent::FORMAT_KEY_FORMAT_SD_CARD] =
+        std::bind(&IdleState::FormatKeyFormattingSDCardHandle, this, _1);
 }
 void IdleState::GoInState()
 {
@@ -38,6 +40,12 @@ bool IdleState::ExecuteStateMsg(VStateMachineData *msg)
     return DataProcessing::EventHandle(msg);
 }
 bool IdleState::ResetKeyMediaTaskHandle(VStateMachineData *msg)
+{
+    MissionStateMachine::GetInstance()->DelayMessage(msg);
+    MissionStateMachine::GetInstance()->SwitchState(SystemState::STORAGE_HANDLE_STATE);
+    return EXECUTED;
+}
+bool IdleState::FormatKeyFormattingSDCardHandle(VStateMachineData *msg)
 {
     MissionStateMachine::GetInstance()->DelayMessage(msg);
     MissionStateMachine::GetInstance()->SwitchState(SystemState::STORAGE_HANDLE_STATE);

application/MissionManager/src/IdleState.h

@@ -27,6 +27,7 @@ public:
 
 private:
     bool ResetKeyMediaTaskHandle(VStateMachineData *msg);
+    bool FormatKeyFormattingSDCardHandle(VStateMachineData *msg);
 
 private:
 };

application/MissionManager/src/SdCardHandleState.cpp

@@ -32,6 +32,8 @@ SdCardHandleState::SdCardHandleState() : State("SdCardHandleState"), mSdCardStat
         std::bind(&SdCardHandleState::SdCardEventHandle, this, _1);
     mEventHandle[InternalStateEvent::RESET_KEY_MEDIA_TASK] =
         std::bind(&SdCardHandleState::ResetKeyMediaTaskHandle, this, _1);
+    mEventHandle[InternalStateEvent::FORMAT_KEY_FORMAT_SD_CARD] =
+        std::bind(&SdCardHandleState::FormatKeyFormattingSDCardHandle, this, _1);
 }
 void SdCardHandleState::GoInState()
 {
@@ -109,4 +111,14 @@ bool SdCardHandleState::ResetKeyMediaTaskHandle(VStateMachineData *msg)
     }
     LogWarning("Sd card is not inserted, ignore reset key media task.\n");
     return HANDLE_HELPESS;
+}
+bool SdCardHandleState::FormatKeyFormattingSDCardHandle(VStateMachineData *msg)
+{
+    if (StorageEvent::SD_CARD_INSERT == mSdCardStatus) {
+        LogInfo("FormatKeyFormattingSDCardHandle.\n");
+        IStorageManager::GetInstance()->FormatSDCardNow();
+        return EXECUTED;
+    }
+    LogWarning("Sd card is not inserted, ignore format key.\n");
+    return EXECUTED;
 }

application/MissionManager/src/SdCardHandleState.h

@@ -38,6 +38,7 @@ protected:
     bool MediaReportHandle(VStateMachineData *msg);
     bool SdCardEventHandle(VStateMachineData *msg);
     bool ResetKeyMediaTaskHandle(VStateMachineData *msg);
+    bool FormatKeyFormattingSDCardHandle(VStateMachineData *msg);
 
 private:
     StorageEvent mSdCardStatus;

application/MissionManager/src/TestMissionState.cpp

@@ -24,13 +24,15 @@
 #include "MissionStateMachine.h"
 #include <functional>
 #include <memory>
-TestMissionState::TestMissionState() : MissionState("TestMissionState")
+TestMissionState::TestMissionState() : MissionState("TestMissionState"), mFormattingSDCard(false)
 {
     mEventHandle[InternalStateEvent::ANY_STATE_SD_STATUS_PERORIED] =
         std::bind(&TestMissionState::SdCardEventReportSendToApp, this, _1);
     mEventHandle[InternalStateEvent::RESET_KEY_MEDIA_TASK] =
         std::bind(&TestMissionState::ResetKeyMediaTaskHandle, this, _1);
     mKeyClickHandle["reset"] = std::bind(&TestMissionState::ClickResetKey, this, _1);
+    mKeyHoldDownHandle["format"] = std::bind(&TestMissionState::HoldDownFormatKey, this, _1);
+    mKeyHoldUpHandle["format"] = std::bind(&TestMissionState::HoldUpFormatKey, this, _1);
 }
 void TestMissionState::GoInState()
 {
@@ -75,6 +77,24 @@ bool TestMissionState::ClickResetKey(const KeyEventData &data)
     MissionStateMachine::GetInstance()->SendStateMessage(message);
     return EXECUTED;
 }
+bool TestMissionState::HoldDownFormatKey(const KeyEventData &data)
+{
+    constexpr int FORMAT_SD_CARD_PRESSING_TIME_MS = 1000 * 15;
+    if (FORMAT_SD_CARD_PRESSING_TIME_MS <= data.mHoldTime && false == mFormattingSDCard) {
+        LogInfo("format key down.\n");
+        mFormattingSDCard = true;
+        std::shared_ptr<VMissionData> message =
+            std::make_shared<VMissionData>(static_cast<MissionEvent>(InternalStateEvent::FORMAT_KEY_FORMAT_SD_CARD));
+        MissionStateMachine::GetInstance()->SendStateMessage(message);
+        return EXECUTED;
+    }
+    return NOT_EXECUTED;
+}
+bool TestMissionState::HoldUpFormatKey(const KeyEventData &data)
+{
+    mFormattingSDCard = false;
+    return EXECUTED;
+}
 SdCardStatus TestMissionState::SdCardStatusConvert(const StorageEvent &event)
 {
     switch (event) {

application/MissionManager/src/TestMissionState.h

@@ -30,8 +30,13 @@ private:
     bool SdCardEventReportSendToApp(VStateMachineData *msg);
     bool ResetKeyMediaTaskHandle(VStateMachineData *msg);
     bool ClickResetKey(const KeyEventData &data);
+    bool HoldDownFormatKey(const KeyEventData &data);
+    bool HoldUpFormatKey(const KeyEventData &data);
 
 private:
     SdCardStatus SdCardStatusConvert(const StorageEvent &event);
+
+private:
+    bool mFormattingSDCard;
 };
 #endif

hal/abstract/IHalCpp.cpp

@@ -133,6 +133,11 @@ StatusCode VSdCardHal::GetCapacity(unsigned long long &totalSizeMB, unsigned lon
     LogWarning("STATUS_CODE_VIRTUAL_FUNCTION.\n");
     return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
 }
+StatusCode VSdCardHal::FormatSDCard(void)
+{
+    LogWarning("STATUS_CODE_VIRTUAL_FUNCTION.\n");
+    return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
+}
 StatusCode IHalCpp::Init(void)
 {
     LogWarning("STATUS_CODE_VIRTUAL_FUNCTION.\n");

hal/include/IHalCpp.h

@@ -151,6 +151,7 @@ public:
     virtual SdCardHalStatus GetSdCardStatus(void);
     virtual StatusCode GetCapacity(unsigned long long &totalSizeMB, unsigned long long &freeSizeMB,
                                    unsigned long long &usedSizeMB);
+    virtual StatusCode FormatSDCard(void);
 };
 class IHalCpp
 {

hal/src/SdCardHal.cpp

@@ -65,6 +65,18 @@ StatusCode SdCardHal::GetCapacity(unsigned long long &totalSizeMB, unsigned long
     LogInfo("Used size: %llu MB\n", usedSizeMB);
     return CreateStatusCode(STATUS_CODE_OK);
 }
+StatusCode SdCardHal::FormatSDCard(void)
+{
+    char command[128] = {0};
+    sprintf(command, "mkfs.ext4 -F %s", SD_CARD_DEVICE);
+    int ret = fx_system(command);
+    if (ret != 0) {
+        LogError("Format sd card failed [%s].\n", SD_CARD_DEVICE);
+        return CreateStatusCode(STATUS_CODE_NOT_OK);
+    }
+    LogInfo("Format sd card success.\n");
+    return CreateStatusCode(STATUS_CODE_OK);
+}
 void SdCardHal::Init(void)
 {
     auto detectThread = [](std::shared_ptr<SdCardHal> sdCardHal) {

hal/src/SdCardHal.h

@@ -25,6 +25,7 @@ public:
     SdCardHalStatus GetSdCardStatus(void) override;
     StatusCode GetCapacity(unsigned long long &totalSizeMB, unsigned long long &freeSizeMB,
                            unsigned long long &usedSizeMB) override;
+    StatusCode FormatSDCard(void) override;
     void Init(void);
     void UnInit(void);
     void DevDetectingThread(void);

middleware/FilesManager/src/sqlite3/SqliteHandle.cpp

@@ -157,24 +157,7 @@ bool SqliteHandle::SyncFile(const SyncFileInfo &info)
         sqlite3_free(errMsg);
         return false;
     }
-    // if (UpdateCreateTime(mDb, info.mSerialNumber, info.mCreateTime_s) == false) {
+    LogInfo("Sync file success.\n");
-    //     return false;
-    // }
-    // if (UpdateFileName(mDb, info.mSerialNumber, info.mFileName) == false) {
-    //     return false;
-    // }
-    // if (UpdateFileSize(mDb, info.mSerialNumber, info.mFileSize) == false) {
-    //     return false;
-    // }
-    // if (UpdateFileStatus(mDb, info.mSerialNumber, info.mStatus) == false) {
-    //     return false;
-    // }
-    // if (UpdateFileType(mDb, info.mSerialNumber, info.mType) == false) {
-    //     return false;
-    // }
-    // if (UpdateFileDuration(mDb, info.mSerialNumber, info.mFileDuration) == false) {
-    //     return false;
-    // }
     return true;
 }
 bool SqliteHandle::SearchFiles(const std::vector<FileCreateType> &types, std::vector<SyncFileInfo> &info)

middleware/StorageManager/include/IStorageManager.h

@@ -56,5 +56,6 @@ public:
     virtual StatusCode GetSdCardInfo(SdCardInfo &info);
     virtual std::string GetFilesDatabasePath(void);
     virtual std::string GetFilesSavingPath(void);
+    virtual StatusCode FormatSDCardNow(void);
 };
 #endif

middleware/StorageManager/src/IStorageManager.cpp

@@ -77,4 +77,9 @@ std::string IStorageManager::GetFilesSavingPath(void)
     LogWarning("STATUS_CODE_VIRTUAL_FUNCTION\n");
     std::string path = "undefined";
     return path;
+}
+StatusCode IStorageManager::FormatSDCardNow(void)
+{
+    LogWarning("STATUS_CODE_VIRTUAL_FUNCTION\n");
+    return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
 }

middleware/StorageManager/src/SdCardHandle.cpp

@@ -37,6 +37,11 @@ StatusCode SdCardHandle::GetSdCardInfo(SdCardInfo &info)
     info.mEvent = StorageEventConvert(mSdCardHal->GetSdCardStatus());
     return mSdCardHal->GetCapacity(info.mTotalSizeMB, info.mFreeSizeMB, info.mUsedSizeMB);
 }
+StatusCode SdCardHandle::FormatSDCardNow(void)
+{
+    mSdCardHal->FormatSDCard();
+    return CreateStatusCode(STATUS_CODE_OK);
+}
 void SdCardHandle::SdCardInit(void)
 {
     IHalCpp::GetInstance()->GetSdCardHal(mSdCardHal);

middleware/StorageManager/src/SdCardHandle.h

@@ -25,6 +25,7 @@ public:
     virtual ~SdCardHandle() = default;
     void ReportEvent(const SdCardHalStatus &status) override;
     StatusCode GetSdCardInfo(SdCardInfo &info) override;
+    StatusCode FormatSDCardNow(void) override;
     void SdCardInit(void);
     void SdCardUnInit(void);
 

test/application/HuntingCamera/src_mock/DeviceManager_Mock_Test.cpp

@@ -65,6 +65,21 @@ TEST_F(HuntingCameraTest, HS_INTEGRATION_HunttingCamera_EXAMPLE_KeyControlClick)
     std::this_thread::sleep_for(std::chrono::milliseconds(100));
     MainThread::GetInstance()->Runing();
 }
+/**
+ * @brief Construct a new test f object
+ * ../output_files/test/bin/HuntingCameraTest
+ * --gtest_filter=HuntingCameraTest.HS_INTEGRATION_HunttingCamera_EXAMPLE_FormatSDCard
+ */
+TEST_F(HuntingCameraTest, HS_INTEGRATION_HunttingCamera_EXAMPLE_FormatSDCard)
+{
+    SetAllCamerasResult(mAllCamerasMock);
+    MockOtherSideIpcMissionReply(IpcMission::TEST);
+    MainThread::GetInstance()->Init();
+    TestManager::ResetTimeOut(1000 * 17);
+    HalTestTool::MockKeyClick("format", 1000 * 16); // Simulate pressing a button.
+    std::this_thread::sleep_for(std::chrono::milliseconds(100));
+    MainThread::GetInstance()->Runing();
+}
 /**
  * @brief Construct a new test f object
  * ../output_files/test/bin/HuntingCameraTest

test/application/HuntingCamera/src_mock/HuntingCameraTest.cpp

@@ -18,6 +18,7 @@
 #include "MainThread.h"
 #include <thread>
 const char *KEY_RESET = "reset";
+const char *KEY_FORMAT_SD_CARD = "format";
 const char *LED_DEVICE_STATUS = "device_status";
 void MainThreadTest::CustomizationInit(void)
 {
@@ -90,6 +91,8 @@ void HuntingCameraTest::CreateAllKeysMcok(void)
 {
     std::shared_ptr<VKeyHal> key = HalTestTool::MakeKeyHalTest(KEY_RESET);
     mAllKeysMock[KEY_RESET] = key;
+    std::shared_ptr<VKeyHal> key2 = HalTestTool::MakeKeyHalTest(KEY_FORMAT_SD_CARD);
+    mAllKeysMock[KEY_FORMAT_SD_CARD] = key2;
     HalTestTool::SetAllKeysResult(mAllKeysMock);
 }
 void HuntingCameraTest::DestroyAllKeysMock(void)