Improve:wifi hal init ap mode.

hal/abstract/IHalCpp.cpp

@@ -36,6 +36,10 @@ StatusCode VWifiHal::OpenApMode(void)
 {
     return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
 }
+StatusCode VWifiHal::CloseApMode(void)
+{
+    return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
+}
 void VCameraHalMonitor::ReportEvent(const CameraReportEvent &event)
 {
 }

hal/include/IHalCpp.h

@@ -74,6 +74,7 @@ public:
     VWifiHal() = default;
     virtual ~VWifiHal() = default;
     virtual StatusCode OpenApMode(void);
+    virtual StatusCode CloseApMode(void);
 };
 class VCameraHalMonitor
 {

hal/src/WifiHal.cpp

@@ -20,12 +20,16 @@
 #include <stdlib.h>
 #include <string.h>
 #include <thread>
+WifiHal::WifiHal() : mInitRunning(false)
+{
+}
 StatusCode WifiHal::OpenApMode(void)
 {
     LogInfo("OpenApMode. \n");
     constexpr int SLEEP_TIME_MS = 5;
     constexpr int WAITING_TIME_MS = 1000 * 10;
     unsigned int sleepingTime_ms = 0;
+    mInitRunning = true;
     while (CheckWlan0IfExist() == false) {
         std::this_thread::sleep_for(std::chrono::milliseconds(SLEEP_TIME_MS));
         sleepingTime_ms += SLEEP_TIME_MS;
@@ -33,6 +37,10 @@ StatusCode WifiHal::OpenApMode(void)
             LogError("wlan0 not found. \n");
             return CreateStatusCode(STATUS_CODE_NOT_OK);
         }
+        if (false == mInitRunning) {
+            LogError("Open ap mode stop. \n");
+            return CreateStatusCode(STATUS_CODE_NOT_OK);
+        }
     }
     LogInfo("wlan0 ok. \n");
     fx_system("ifconfig wlan0 192.168.169.1 netmask 255.255.255.0");
@@ -41,6 +49,17 @@ StatusCode WifiHal::OpenApMode(void)
     fx_system("udhcpd -f /etc/udhcpd.conf &");
     return CreateStatusCode(STATUS_CODE_OK);
 }
+StatusCode WifiHal::CloseApMode(void)
+{
+    mInitRunning = false;
+    return CreateStatusCode(STATUS_CODE_OK);
+}
+void WifiHal::Init(void)
+{
+}
+void WifiHal::UnInit(void)
+{
+}
 bool WifiHal::CheckWlan0IfExist(void)
 {
     DIR *dir;

hal/src/WifiHal.h

@@ -18,11 +18,17 @@
 class WifiHal : public VWifiHal
 {
 public:
-    WifiHal() = default;
+    WifiHal();
     virtual ~WifiHal() = default;
     StatusCode OpenApMode(void) override;
+    StatusCode CloseApMode(void) override;
+    void Init(void);
+    void UnInit(void);
 
 private:
     bool CheckWlan0IfExist(void);
+
+private:
+    bool mInitRunning;
 };
 #endif

middleware/AppManager/src/AppManager.cpp

@@ -19,28 +19,34 @@
 #include "ILog.h"
 #include "TcpModule.h"
 #include "WebServer.h"
-AppManager::AppManager()
+AppManager::AppManager() : mTcpServer(nullptr), mInitRuning(false)
 {
-    mTcpServer = nullptr;
 }
 const StatusCode AppManager::Init(const AppParam &param)
 {
-    std::shared_ptr<VWifiHal> wifi;
-    IHalCpp::GetInstance()->GetWifiHal(wifi);
-    if (!wifi) {
-        LogError("Get wifi hal failed.\n");
-        return CreateStatusCode(STATUS_CODE_NOT_OK);
-    }
-    wifi->OpenApMode();
-    std::shared_ptr<IAppProtocolHandle> protocolHandle;
-    AppManagerMakePtr::GetInstance()->CreateProtocolHandle(protocolHandle);
-    IAppProtocolHandle::GetInstance(&protocolHandle);
-    HttpServerStart(param);
-    TcpServerStart(param);
+    auto initThread = [](std::shared_ptr<AppManager> appManager, const AppParam param) {
+        LogInfo("WifiApModeInit started.\n");
+        appManager->WifiApModeInit(param);
+    };
+    mInitThread = std::thread(initThread, shared_from_this(), param);
     return CreateStatusCode(STATUS_CODE_OK);
 }
 const StatusCode AppManager::UnInit(void)
 {
+    if (true == mInitRuning) {
+        std::shared_ptr<VWifiHal> wifi;
+        IHalCpp::GetInstance()->GetWifiHal(wifi);
+        if (!wifi) {
+            LogWarning("Get wifi hal failed.\n");
+            goto GOAHEAD;
+        }
+        wifi->CloseApMode();
+    }
+GOAHEAD:
+    mInitRuning = false;
+    if (mInitThread.joinable()) {
+        mInitThread.join();
+    }
     HttpServerStop();
     TcpServerStop();
     std::shared_ptr<IAppProtocolHandle> protocolHandle = std::make_shared<IAppProtocolHandle>();
@@ -156,4 +162,28 @@ void AppManager::TcpServerStop(void)
     if (nullptr != mTcpServer) {
         FreeTcpServer(mTcpServer);
     }
+}
+void AppManager::WifiApModeInit(const AppParam &param)
+{
+    mInitRuning = true;
+    std::shared_ptr<VWifiHal> wifi;
+    IHalCpp::GetInstance()->GetWifiHal(wifi);
+    if (!wifi) {
+        LogError("Get wifi hal failed.\n");
+        return;
+    }
+    /**
+     * @brief This interface depends on hardware and may block. It is necessary to ensure that hardware interface
+     * blocking does not cause the main thread to block.
+     */
+    wifi->OpenApMode();
+    if (false == mInitRuning) {
+        LogWarning("AppManager init stop.\n");
+        return;
+    }
+    std::shared_ptr<IAppProtocolHandle> protocolHandle;
+    AppManagerMakePtr::GetInstance()->CreateProtocolHandle(protocolHandle);
+    IAppProtocolHandle::GetInstance(&protocolHandle);
+    HttpServerStart(param);
+    TcpServerStart(param);
 }

middleware/AppManager/src/AppManager.h

@@ -41,12 +41,17 @@ private:
     void TcpServerStart(const AppParam &param);
     void TcpServerStop(void);
 
+private:
+    void WifiApModeInit(const AppParam &param);
+
 private:
     std::thread mHttpSever;
     std::shared_ptr<IAppProtocolHandle> mProtocolHandle;
     void *mTcpServer;
     std::shared_ptr<VAppMonitor> mAppMonitor;
     std::map<void *, std::shared_ptr<VAppClient>> mAppClients;
+    bool mInitRuning;
+    std::thread mInitThread;
 };
 
 #endif