update

appsrc/baseservice/front_msg_processer/front_msg_processer.hpp

@@ -84,4 +84,5 @@ static inline T jsonGet(json j) {
 #define BIND(func) bind(&func, shared_from_this(), placeholders::_1)
 
 }  // namespace iflytop
-#define REGFN(className, fn) GET_SERVICE(FrontMsgProcesser)->registerMsgProcesser(#className, #fn, BIND(className::fn))
+#define REGFN(className, fn)   GET_SERVICE(FrontMsgProcesser)->registerMsgProcesser(#className, #fn, BIND(className::fn))
+#define REGFNV2(className, fn) GET_SERVICE(FrontMsgProcesser)->registerMsgProcesser(#className, #fn, BIND(className::fn_##fn))

appsrc/service/app/add_liquid_service.cpp

@@ -0,0 +1,30 @@
+#include "add_liquid_service.hpp"
+using namespace iflytop;
+void AddLiquidService::initialize() {
+  logger->info("AddLiquidService initialize");
+  REGFNV2(AddLiquidService, start);
+  REGFNV2(AddLiquidService, stop);
+  REGFNV2(AddLiquidService, getState);
+  REGFNV2(AddLiquidService, getServiceConfig);
+}
+
+void                      AddLiquidService::start(int stopatg) {}
+void                      AddLiquidService::stop() {}
+AddLiquidService::state_t AddLiquidService::getWorkstate() { return kidle; }
+
+void AddLiquidService::fn_start(shared_ptr<MsgProcessContext> cxt) {  //
+  int stopatg = jsonGet<int>(cxt->params["stopatg"]);
+  start(stopatg);
+}
+void AddLiquidService::fn_stop(shared_ptr<MsgProcessContext> cxt) { stop(); }
+void AddLiquidService::fn_getState(shared_ptr<MsgProcessContext> cxt) {  //
+  cxt->content["workState"] = state2str(getWorkstate());
+  cxt->content["nowLiquid"] = 1000;
+}
+
+void AddLiquidService::fn_getServiceConfig(shared_ptr<MsgProcessContext> cxt) {
+  json cfg;
+  cfg["maxLiquid"] = 4950;
+  cfg["show"]    = true;
+  cxt->content = cfg;
+}

appsrc/service/app/add_liquid_service.hpp

@@ -0,0 +1,59 @@
+#pragma once
+#include <fstream>
+#include <iostream>
+#include <list>
+#include <map>
+#include <memory>
+#include <set>
+#include <sstream>
+#include <string>
+#include <vector>
+//
+#include "baseservice/baseservice.hpp"
+namespace iflytop {
+class AddLiquidService : public enable_shared_from_this<AddLiquidService> {
+  ENABLE_LOGGER(AddLiquidService);
+
+ public:
+  typedef enum {
+    kidle            = 0,
+    kaddingLiquid    = 1,
+    kemptyLineLiquid = 2,
+  } state_t;
+
+  static const char* state2str(state_t state) {
+    switch (state) {
+      case kidle:
+        return "idle";
+      case kaddingLiquid:
+        return "addingLiquid";
+      case kemptyLineLiquid:
+        return "emptyLineLiquid";
+      default:
+        return "unknown";
+    }
+  }
+
+ private:
+  shared_ptr<DBService>          m_db;
+  shared_ptr<DeviceStateService> m_ds;
+  shared_ptr<GConfig>            m_gConfig;
+
+  state_t m_workstate = kidle;
+
+ public:
+  void initialize();
+
+  void    start(int stopatg);
+  void    stop();
+  state_t getWorkstate();
+
+  void fn_start(shared_ptr<MsgProcessContext> cxt);
+  void fn_stop(shared_ptr<MsgProcessContext> cxt);
+  void fn_getState(shared_ptr<MsgProcessContext> cxt);
+  void fn_getServiceConfig(shared_ptr<MsgProcessContext> cxt);
+
+ private:
+};
+
+}  // namespace iflytop

appsrc/service/app/air_tightness_test.cpp

@@ -0,0 +1,4 @@
+#include "air_tightness_test.hpp"
+
+using namespace iflytop;
+void AirTightnessTest::initialize() { logger->info("AirTightnessTest initialize"); }

appsrc/service/app/air_tightness_test.hpp

@@ -0,0 +1,27 @@
+#pragma once
+#include <fstream>
+#include <iostream>
+#include <list>
+#include <map>
+#include <memory>
+#include <set>
+#include <sstream>
+#include <string>
+#include <vector>
+//
+#include "baseservice/baseservice.hpp"
+namespace iflytop {
+class AirTightnessTest : public enable_shared_from_this<AirTightnessTest> {
+  ENABLE_LOGGER(AirTightnessTest);
+
+  shared_ptr<DBService>          m_db;
+  shared_ptr<DeviceStateService> m_ds;
+  shared_ptr<GConfig>            m_gConfig;
+
+ public:
+  void initialize();
+
+ private:
+};
+
+}  // namespace iflytop

appsrc/service/app/disinfection_service.cpp

@@ -0,0 +1,4 @@
+#include "disinfection_service.hpp"
+using namespace iflytop;
+
+void DisinfectionService::initialize() { logger->info("DisinfectionService initialize"); }

appsrc/service/app/disinfection_service.hpp

@@ -0,0 +1,27 @@
+#pragma once
+#include <fstream>
+#include <iostream>
+#include <list>
+#include <map>
+#include <memory>
+#include <set>
+#include <sstream>
+#include <string>
+#include <vector>
+//
+#include "baseservice/baseservice.hpp"
+namespace iflytop {
+class DisinfectionService : public enable_shared_from_this<DisinfectionService> {
+  ENABLE_LOGGER(DisinfectionService);
+
+  shared_ptr<DBService>          m_db;
+  shared_ptr<DeviceStateService> m_ds;
+  shared_ptr<GConfig>            m_gConfig;
+
+ public:
+  void initialize();
+
+ private:
+};
+
+}  // namespace iflytop

appsrc/service/app/drain_liquid_service.cpp

@@ -0,0 +1,4 @@
+#include "drain_liquid_service.hpp"
+
+using namespace iflytop;
+void DrainLiquidService::initialize() { logger->info("DrainLiquidService initialize"); }

appsrc/service/app/drain_liquid_service.hpp

@@ -0,0 +1,27 @@
+#pragma once
+#include <fstream>
+#include <iostream>
+#include <list>
+#include <map>
+#include <memory>
+#include <set>
+#include <sstream>
+#include <string>
+#include <vector>
+//
+#include "baseservice/baseservice.hpp"
+namespace iflytop {
+class DrainLiquidService : public enable_shared_from_this<DrainLiquidService> {
+  ENABLE_LOGGER(DrainLiquidService);
+
+  shared_ptr<DBService>          m_db;
+  shared_ptr<DeviceStateService> m_ds;
+  shared_ptr<GConfig>            m_gConfig;
+
+ public:
+  void initialize();
+
+ private:
+};
+
+}  // namespace iflytop

appsrc/service/main_control_service.cpp

@@ -10,6 +10,11 @@
 #include "service/setting_mgr_service.hpp"
 #include "service/test_page_mgr_service.hpp"
 #include "service/user_mgr_service.hpp"
+//
+#include "service/app/add_liquid_service.hpp"
+#include "service/app/air_tightness_test.hpp"
+#include "service/app/disinfection_service.hpp"
+#include "service/app/drain_liquid_service.hpp"
 
 using namespace iflytop;
 using namespace core;
@@ -46,6 +51,11 @@ void MainControlService::initialize() {
   BUILD_AND_REG_SERRVICE(OsMgrService);
   BUILD_AND_REG_SERRVICE(TestPageMgrService);
 
+  BUILD_AND_REG_SERRVICE(AddLiquidService);
+  BUILD_AND_REG_SERRVICE(AirTightnessTest);
+  BUILD_AND_REG_SERRVICE(DisinfectionService);
+  BUILD_AND_REG_SERRVICE(DrainLiquidService);
+
   //
   GET_SERVICE(IflytopFrontEndService)->startListen();
   GET_SERVICE(IflytopFrontEndService)->onMessage.connect([this](weak_ptr<WebSocket> webSocket, json& cmd, json& receipt) {