Backup.

application/HunttingCamera/build/huntting_camera.cmake

@@ -5,8 +5,9 @@ set(HUNTTING_MAIN_INCLUDE_PATH     "${HUNTTING_MAIN_INCLUDE_PATH};${MIDDLEWARE_S
 set(HUNTTING_MAIN_INCLUDE_PATH     "${HUNTTING_MAIN_INCLUDE_PATH};${MIDDLEWARE_SOURCE_PATH}/AppManager/include")
 set(HUNTTING_MAIN_INCLUDE_PATH     "${HUNTTING_MAIN_INCLUDE_PATH};${MIDDLEWARE_SOURCE_PATH}/MediaManager/include")
 set(HUNTTING_MAIN_INCLUDE_PATH     "${HUNTTING_MAIN_INCLUDE_PATH};${MIDDLEWARE_SOURCE_PATH}/FilesManager/include")
+set(HUNTTING_MAIN_INCLUDE_PATH     "${HUNTTING_MAIN_INCLUDE_PATH};${MIDDLEWARE_SOURCE_PATH}/StorageManager/include")
 set(HUNTTING_MAIN_INCLUDE_PATH     "${HUNTTING_MAIN_INCLUDE_PATH};${UTILS_SOURCE_PATH}/StatusCode/include")
 set(HUNTTING_MAIN_INCLUDE_PATH     "${HUNTTING_MAIN_INCLUDE_PATH};${UTILS_SOURCE_PATH}/Log/include")
 set(HUNTTING_MAIN_INCLUDE_PATH     "${HUNTTING_MAIN_INCLUDE_PATH};${HAL_SOURCE_PATH}/include")
 
-set(HUNTTING_LINK_LIB McuManager MissionManager StateMachine AppManager FilesManager StatusCode Log Hal pthread dl)
+set(HUNTTING_LINK_LIB McuManager MissionManager StateMachine AppManager FilesManager StorageManager StatusCode Log Hal pthread dl)

application/HunttingCamera/src/MainThread.cpp

@@ -21,6 +21,7 @@
 #include "IMediaManager.h"
 #include "IMissionManager.h"
 #include "IStateMachine.h"
+#include "IStorageManager.h"
 #include <signal.h>
 #include <thread>
 static void sigHandler(int signo)
@@ -63,6 +64,7 @@ StatusCode MainThread::Init(void)
     CreateAllModules();
     IHalCpp::GetInstance()->Init();
     IMcuManager::GetInstance()->Init();
+    IStorageManager::GetInstance()->Init();
     IMediaManager::GetInstance()->Init();
     IMissionManager::GetInstance()->Init();
     return CreateStatusCode(STATUS_CODE_OK);
@@ -71,6 +73,7 @@ StatusCode MainThread::UnInit(void)
 {
     IMissionManager::GetInstance()->UnInit();
     IMediaManager::GetInstance()->UnInit();
+    IStorageManager::GetInstance()->UnInit();
     IMcuManager::GetInstance()->UnInit();
     IHalCpp::GetInstance()->UnInit();
     DestoryAllModules();
@@ -81,6 +84,7 @@ StatusCode MainThread::CreateAllModules(void)
 {
     CreateHalCppModule();
     CreateMcuManager();
+    CreateStorageManagerModule();
     CreateFilesManagerModule();
     CreateMissionManagerModule();
     CreateStateMachine();
@@ -95,6 +99,7 @@ void MainThread::DestoryAllModules(void)
     DestroyStateMachine();
     DestroyMissionManagerModule();
     DestroyFilesManagerModule();
+    DestroyStorageManagerModule();
     DestroyMcuManager();
     DestroyHalCppModule();
 }

application/MissionManager/src/StorageHandleState.cpp

@@ -42,4 +42,5 @@ void StorageHandleState::UnInit(void)
 }
 void StorageHandleState::ReportEvent(const StorageEvent &event)
 {
+    LogInfo("StorageHandleState::ReportEvent.\n");
 }

build/cmake/toolchain/linux.toolchain.cmake

@@ -76,5 +76,5 @@ set(APP_MANAGER_TCP_SERVER_PORT                          "9876")
 
 # ------------ build sd card ------------ #
 set(SD_CARD_DEV                   "/dev/test")
-set(SD_CARD_MOUNT_PATH            "/mnt/test")
+set(SD_CARD_MOUNT_PATH            "./sdcard")
 # ------------ build sd card end ------------ #

hal/abstract/IHalCpp.cpp

@@ -64,6 +64,10 @@ std::shared_ptr<IHalCpp> &IHalCpp::GetInstance(std::shared_ptr<IHalCpp> *impl)
 void VSdCardHal::SetSdCardMonitor(std::shared_ptr<VSdCardHalMonitor> &monitor)
 {
 }
+SdCardHalStatus VSdCardHal::GetSdCardStatus(void)
+{
+    return SdCardHalStatus::END;
+}
 StatusCode IHalCpp::Init(void)
 {
     return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);

hal/include/IHalCpp.h

@@ -112,6 +112,7 @@ public:
     VSdCardHal() = default;
     virtual ~VSdCardHal() = default;
     virtual void SetSdCardMonitor(std::shared_ptr<VSdCardHalMonitor> &monitor);
+    virtual SdCardHalStatus GetSdCardStatus(void);
 };
 class IHalCpp
 {

hal/src/SdCardHal.cpp

@@ -27,10 +27,17 @@ const char *SD_CARD_DEVICE = SD_CARD_DEV;
 SdCardHal::SdCardHal()
 {
     mThreadRuning = false;
+    mStatus = SdCardHalStatus::END;
 }
 void SdCardHal::SetSdCardMonitor(std::shared_ptr<VSdCardHalMonitor> &monitor)
 {
+    LogInfo("SetSdCardMonitor.\n");
     mMonitor = monitor;
+    monitor->ReportEvent(mStatus);
+}
+SdCardHalStatus SdCardHal::GetSdCardStatus(void)
+{
+    return mStatus;
 }
 void SdCardHal::Init(void)
 {
@@ -49,42 +56,42 @@ void SdCardHal::UnInit(void)
 }
 void SdCardHal::DevDetectingThread(void)
 {
-    constexpr int SLEEP_TIME_MS = 1000;
+    constexpr int SLEEP_TIME_MS = 100;
-    SdCardHalStatus status = SdCardHalStatus::END;
+    // 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 (fd < 0) {
-            LogInfo("sdCardHal: %s open failed.\n", SD_CARD_DEVICE);
+            // LogInfo("sdCardHal: %s open failed.\n", SD_CARD_DEVICE);
-            if (SdCardHalStatus::PULL_OUT != status) {
+            if (SdCardHalStatus::PULL_OUT != mStatus) {
-                status = SdCardHalStatus::PULL_OUT;
+                mStatus = SdCardHalStatus::PULL_OUT;
-                ReportDetecedChangedResult(status);
+                ReportDetecedChangedResult(mStatus);
             }
             goto CONTINUE;
         }
         struct stat sdStat;
         if (fx_fstat(fd, &sdStat) < 0) {
-            LogInfo("sdCardHal: %s fstat failed.\n", SD_CARD_DEVICE);
+            // LogInfo("sdCardHal: %s fstat failed.\n", SD_CARD_DEVICE);
-            if (SdCardHalStatus::ERROR != status) {
+            if (SdCardHalStatus::ERROR != mStatus) {
-                status = SdCardHalStatus::ERROR;
+                mStatus = SdCardHalStatus::ERROR;
-                ReportDetecedChangedResult(status);
+                ReportDetecedChangedResult(mStatus);
             }
             goto CONTINUE;
         }
         if (!S_ISBLK(sdStat.st_mode)) {
-            LogInfo("sdCardHal: %s is not block device.\n", SD_CARD_DEVICE);
+            // LogInfo("sdCardHal: %s is not block device.\n", SD_CARD_DEVICE);
-            if (SdCardHalStatus::PULL_OUT != status) {
+            if (SdCardHalStatus::PULL_OUT != mStatus) {
-                status = SdCardHalStatus::PULL_OUT;
+                mStatus = SdCardHalStatus::PULL_OUT;
-                ReportDetecedChangedResult(status);
+                ReportDetecedChangedResult(mStatus);
             }
         }
         else {
-            LogInfo("sdCardHal: %s is inserted.\n", SD_CARD_DEVICE);
+            // LogInfo("sdCardHal: %s is inserted.\n", SD_CARD_DEVICE);
-            if (SdCardHalStatus::INSERTED != status) {
+            if (SdCardHalStatus::INSERTED != mStatus) {
-                status = SdCardHalStatus::INSERTED;
+                mStatus = SdCardHalStatus::INSERTED;
-                ReportDetecedChangedResult(status);
+                ReportDetecedChangedResult(mStatus);
             }
         }
     CONTINUE:
@@ -93,6 +100,7 @@ void SdCardHal::DevDetectingThread(void)
 }
 void SdCardHal::ReportDetecedChangedResult(const SdCardHalStatus &status)
 {
+    LogInfo("SdCardHalStatus changed: %s.\n", PrintfStatusString(status));
     auto monitor = mMonitor.lock();
     if (mMonitor.expired()) {
         LogWarning("SdCardHal: monitor is expired.\n");
@@ -106,4 +114,21 @@ void SdCardHal::ReportDetecedChangedResult(const SdCardHalStatus &status)
         snprintf(cmd, BUF_LENGTH, "mount %s %s", SD_CARD_DEV, SD_CARD_MOUNT_PATH);
         fx_system(cmd);
     }
+}
+const char *SdCardHal::PrintfStatusString(const SdCardHalStatus &status)
+{
+    switch (status) {
+    case SdCardHalStatus::MOUNTED:
+        return "MOUNTE\n";
+    case SdCardHalStatus::UNMOUNTED:
+        return "UNMOUNTED.";
+    case SdCardHalStatus::INSERTED:
+        return "INSERTED.";
+    case SdCardHalStatus::PULL_OUT:
+        return "PULL_OUT.";
+    case SdCardHalStatus::END:
+        return "END.";
+    default:
+        return "UNDEFINE.";
+    }
 }

hal/src/SdCardHal.h

@@ -22,14 +22,17 @@ public:
     SdCardHal();
     virtual ~SdCardHal() = default;
     void SetSdCardMonitor(std::shared_ptr<VSdCardHalMonitor> &monitor) override;
+    SdCardHalStatus GetSdCardStatus(void) override;
     void Init(void);
     void UnInit(void);
     void DevDetectingThread(void);
 
 private:
     void ReportDetecedChangedResult(const SdCardHalStatus &status);
+    const char *PrintfStatusString(const SdCardHalStatus &status);
 
 private:
+    SdCardHalStatus mStatus;
     bool mThreadRuning;
     std::thread mDevDetectingThread;
     std::weak_ptr<VSdCardHalMonitor> mMonitor;

middleware/StorageManager/CMakeLists.txt

@@ -1,5 +1,6 @@
 
 include(${CMAKE_SOURCE_DIR_IPCSDK}/build/global_config.cmake)
+include(${HAL_SOURCE_PATH}/build/hal.cmake)
 set(EXECUTABLE_OUTPUT_PATH ${EXEC_OUTPUT_PATH})
 set(LIBRARY_OUTPUT_PATH ${LIBS_OUTPUT_PATH})
 
@@ -12,6 +13,7 @@ include_directories(
     ${UTILS_SOURCE_PATH}/Log/include
     ${UTILS_SOURCE_PATH}/McuProtocol/include
     ${UTILS_SOURCE_PATH}/UartDevice/include
+    ${UTILS_SOURCE_PATH}/LinuxApi/include
 )
 #do not rely on any other library
 #link_directories(

middleware/StorageManager/include/IStorageManager.h

@@ -22,6 +22,7 @@ enum class StorageEvent
 {
     SD_CARD_INSERT = 0,
     SD_CARD_REMOVE,
+    SD_ABNORMAL,
     EMMC_NORMAL,
     END
 };

middleware/StorageManager/src/IStorageManager.cpp

@@ -45,6 +45,5 @@ StatusCode IStorageManager::SetMonitor(std::shared_ptr<VStorageMoniter> &monitor
 }
 StatusCode IStorageManager::SaveFile(const std::string &sourceFile, const std::string &savePaht)
 {
-    LogInfo("SaveFile: %s to %s\n", sourceFile.c_str(), savePaht.c_str());
     return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
 }

middleware/StorageManager/src/SdCardHandle.cpp

@@ -14,6 +14,17 @@
  */
 #include "SdCardHandle.h"
 #include "ILog.h"
+#include "LinuxApi.h"
+void SdCardHandle::ReportEvent(const SdCardHalStatus &status)
+{
+    LogInfo("SdCardHal: ReportEvent.\n");
+    auto monitor = mStorageMonitor.lock();
+    if (mStorageMonitor.expired()) {
+        LogWarning("SdCardHal: monitor is expired.\n");
+        return;
+    }
+    monitor->ReportEvent(StorageEventConvert(status));
+}
 void SdCardHandle::Init(void)
 {
     IHalCpp::GetInstance()->GetSdCardHal(mSdCardHal);
@@ -32,4 +43,35 @@ void SdCardHandle::Init(void)
 void SdCardHandle::UnInit(void)
 {
     mSdCardHal.reset();
+}
+StatusCode SdCardHandle::SdSaveFile(const std::string &sourceFile, const std::string &savePaht)
+{
+    LogInfo("SaveFile: %s -> %s", sourceFile.c_str(), savePaht.c_str());
+    constexpr int CMD_BUF_SIZE = 128;
+    char cmd[CMD_BUF_SIZE] = {0};
+    bool directoryExist = StorageBase::CheckDirectory((SD_CARD_MOUNT_PATH + savePaht).c_str());
+    if (false == directoryExist) {
+        LogInfo("Directory not exist.\n");
+        return CreateStatusCode(STATUS_CODE_NOT_OK);
+    }
+    snprintf(cmd, CMD_BUF_SIZE, "cp %s %s", sourceFile.c_str(), savePaht.c_str());
+    fx_system(cmd);
+    return CreateStatusCode(STATUS_CODE_OK);
+}
+StorageEvent SdCardHandle::StorageEventConvert(const SdCardHalStatus &status)
+{
+    switch (status) {
+    case SdCardHalStatus::MOUNTED:
+        return StorageEvent::SD_CARD_INSERT;
+    case SdCardHalStatus::UNMOUNTED:
+        return StorageEvent::SD_CARD_REMOVE;
+    case SdCardHalStatus::INSERTED:
+        return StorageEvent::SD_ABNORMAL;
+    case SdCardHalStatus::PULL_OUT:
+        return StorageEvent::SD_CARD_REMOVE;
+    case SdCardHalStatus::ERROR:
+        return StorageEvent::SD_ABNORMAL;
+    default:
+        return StorageEvent::SD_ABNORMAL;
+    }
 }

middleware/StorageManager/src/SdCardHandle.h

@@ -23,9 +23,16 @@ class SdCardHandle : public VSdCardHalMonitor, virtual public StorageBase
 public:
     SdCardHandle() = default;
     virtual ~SdCardHandle() = default;
+    void ReportEvent(const SdCardHalStatus &status) override;
     void Init(void);
     void UnInit(void);
 
+protected:
+    StatusCode SdSaveFile(const std::string &sourceFile, const std::string &savePaht);
+
+private:
+    StorageEvent StorageEventConvert(const SdCardHalStatus &status);
+
 protected:
     std::shared_ptr<VSdCardHal> mSdCardHal;
 };

middleware/StorageManager/src/StorageBase.cpp

@@ -12,4 +12,44 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include "StorageBase.h"
+#include "StorageBase.h"
+#include "ILog.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+bool StorageBase::CheckDirectory(const char *filepath)
+{
+    char *path = nullptr;
+    char *sep = nullptr;
+    struct stat st = {0};
+
+    path = strdup(filepath);
+    if (!path) {
+        LogError("strdup\n");
+        return false;
+    }
+
+    for (sep = strchr(path, '/'); sep != NULL; sep = strchr(sep + 1, '/')) {
+        *sep = '\0';
+        if (stat(path, &st) == -1) {
+            if (errno == ENOENT) {
+                if (mkdir(path, 0755) == -1) {
+                    LogError("mkdir\n");
+                    free(path);
+                    return false;
+                }
+            }
+            else {
+                LogError("stat\n");
+                free(path);
+                return false;
+            }
+        }
+
+        *sep = '/';
+    }
+    free(path);
+    return true;
+}

middleware/StorageManager/src/StorageBase.h

@@ -21,6 +21,7 @@ class StorageBase : public std::enable_shared_from_this<StorageBase>
 public:
     StorageBase() = default;
     virtual ~StorageBase() = default;
+    bool CheckDirectory(const char *filepath);
 
 protected:
     std::weak_ptr<VStorageMoniter> mStorageMonitor;

middleware/StorageManager/src/StorageManagerImpl.cpp

@@ -13,6 +13,7 @@
  * limitations under the License.
  */
 #include "StorageManagerImpl.h"
+#include "ILog.h"
 StatusCode StorageManagerImpl::Init(void)
 {
     SdCardHandle::Init();
@@ -26,12 +27,10 @@ StatusCode StorageManagerImpl::UnInit(void)
 StatusCode StorageManagerImpl::SetMonitor(std::shared_ptr<VStorageMoniter> &monitor)
 {
     mStorageMonitor = monitor;
+    SdCardHandle::ReportEvent(mSdCardHal->GetSdCardStatus());
     return CreateStatusCode(STATUS_CODE_OK);
 }
 StatusCode StorageManagerImpl::SaveFile(const std::string &sourceFile, const std::string &savePaht)
 {
-    constexpr int CMD_BUF_SIZE = 128;
+    return SdCardHandle::SdSaveFile(sourceFile, savePaht);
-    char cmd[CMD_BUF_SIZE] = {0};
-    snprintf(cmd, CMD_BUF_SIZE, "cp %s %s", sourceFile.c_str(), savePaht.c_str());
-    return CreateStatusCode(STATUS_CODE_OK);
 }