fix C compatibility

Author: Matthias Akstaller

src/MicroOcpp.cpp

@@ -136,13 +136,12 @@ bool mo_setWebsocketUrl(const char *backendUrl, const char *chargeBoxId, const c
 }
 #endif
 
-#ifdef __cplusplus
 // Set a WebSocket Client
-void mo_setConnection(MicroOcpp::Connection *connection) {
+void mo_setConnection(MO_Connection *connection) {
     mo_setConnection2(mo_getApiContext(), connection);
 }
 
-void mo_setConnection2(MO_Context *ctx, MicroOcpp::Connection *connection) {
+void mo_setConnection2(MO_Context *ctx, MO_Connection *connection) {
     if (!ctx) {
         MO_DBG_ERR("OCPP uninitialized"); //need to call mocpp_initialize before
         return;
@@ -151,7 +150,17 @@ void mo_setConnection2(MO_Context *ctx, MicroOcpp::Connection *connection) {
 
     context->setConnection(connection);
 }
-#endif
+
+#if MO_ENABLE_MOCK_SERVER
+void mo_useMockServer() {
+    if (!g_context) {
+        MO_DBG_ERR("OCPP uninitialized"); //need to call mocpp_initialize before
+        return;
+    }
+    auto context = g_context;
+    context->useMockServer();
+}
+#endif //MO_ENABLE_MOCK_SERVER
 
 //Set the OCPP version
 void mo_setOcppVersion(int ocppVersion) {
@@ -1539,7 +1548,12 @@ bool mo_isConnected2(MO_Context *ctx) {
     auto context = mo_getContext2(ctx);
 
     if (auto connection = context->getConnection()) {
-        return connection->isConnected();
+        if (connection->isConnected) {
+            return connection->isConnected(connection);
+        } else {
+            // MO_Connection driver does not implement `isConnected()`. Default to true
+            return true;
+        }
     } else {
         MO_DBG_ERR("WebSocket not set up");
         return false;

src/MicroOcpp.h

@@ -63,23 +63,59 @@ bool mo_setWebsocketUrl(
         const char *CA_cert);         //TLS certificate. Can be NULL. Zero-copy, must outlive MO. Set this to enable OCPP Security Profile 2
 #endif
 
-#ifdef __cplusplus
 /* Set a WebSocket Client. Required if ArduinoWebsockets is not supported. This library requires
  * that you handle establishing the connection and keeping it alive. MO does not take ownership
  * of the passed `connection` object, i.e. it must be destroyed after `mo_deinitialize()` Please
  * refer to https://github.com/matth-x/MicroOcpp/tree/main/examples/ESP-TLS for an example how to
  * use it.
  *
- * This GitHub project also delivers an Connection implementation based on links2004/WebSockets. If
- * you need another WebSockets implementation, you can subclass the Connection class and pass it to
- * this initialize() function. Please refer to
+ * This GitHub project also delivers an MO_Connection implementation based on links2004/WebSockets.
+ * If you need another WebSockets implementation, you can implement the MO_Connection driver and
+ * pass it to`mo_setConnection()` function. Please refer to
  * https://github.com/OpenEVSE/ESP32_WiFi_V4.x/blob/master/src/MongooseConnectionClient.cpp for
- * an example.
+ * an example. Need to set MO_Connection after `mo_initialize()` and before `mo_setup()`.
+ * 
+ * If migrating from MO v1, use `makeCppConnectionAdapter()` to adapt the C++ `Connection`
+ * class to the C-style `MO_Connection` handle:
+ * ```
+ *     mo_initialize();
+ *     MyConnectionClass *cppConnection = <legacy MO v1 WebSocket implementation>;
+ *     MO_Connection *connection = MicroOcpp::makeCppConnectionAdapter(cppConnection); //Does not take ownership of `cppConnection`
+ *     mo_setConnection(connection);
+ *     mo_setup();
+ * 
+ *     // ...
+ * 
+ *     mo_deinitialize();
+ *     MicroOcpp::freeCppConnectionAdapter(connection);
+ *     delete cppConnection;
+ * ```
+ * 
+ * Note: MO v2 does not reset the `Context` pointer in the C++ `Connection` anymore during
+ * `mo_deinitialize()`. It's recommended to check `ctx` in `MO_Connection`, or `mo_getContext()`.
  */
-void mo_setConnection(MicroOcpp::Connection *connection);
-void mo_setConnection2(MO_Context *ctx, MicroOcpp::Connection *connection);
+void mo_setConnection(MO_Connection *connection);
+void mo_setConnection2(MO_Context *ctx, MO_Connection *connection);
+
+#ifdef __cplusplus
+/* Same as `mo_setConnection()`, but accepts the C++ `Connection` class from MO v1. Does not
+ * transfer ownership of `cppConnection`. */
+bool mo_setCppConnection(MicroOcpp::Connection *cppConnection);
 #endif
 
+#if MO_ENABLE_MOCK_SERVER
+/* Setup MicroOCPP with a mock OCPP server and don't connect to a real server. The mock server is
+ * a minimal server-side implementation of the OCPP operations. If enabled, MO will reply to its
+ * own OCPP messages. It's an alternative to providing MO with an OCPP URL or setting a Connection
+ * handle.
+ * 
+ * Tip: when integrating MO into a new platform, it is more convenient to first use the mock server,
+ * and then switch to a real WebSocket connection. Also, it can be useful to narrow down connection
+ * issues, or to develop offline, with no OCPP server in reach. 
+*/
+void mo_useMockServer();
+#endif //MO_ENABLE_MOCK_SERVER
+
 //Set the OCPP version `MO_OCPP_V16` or `MO_OCPP_V201`. Works only if build flags `MO_ENABLE_V16` or
 //`MO_ENABLE_V201` are set to 1
 void mo_setOcppVersion(int ocppVersion);

src/MicroOcpp/Context.cpp

@@ -133,39 +133,73 @@ bool Context::setConnectionConfig(MO_ConnectionConfig connectionConfig) {
 }
 #endif //MO_WS_USE != MO_WS_CUSTOM
 
-void Context::setConnection(Connection *connection) {
+void Context::setConnection(MO_Connection *connection) {
+    if (this->connection != nullptr && connection != nullptr) {
+        MO_DBG_ERR("switching connection during runtime not supported");
+        return;
+    }
+
     if (this->connection) {
-        this->connection->setContext(nullptr);
+        this->connection->ctx = nullptr;
+    }
+#if MO_ENABLE_MOCK_SERVER
+    if (this->connection && useMockConnection) {
+        mo_loopback_free(this->connection);
+        this->connection = nullptr;
+        useMockConnection = false;
     }
+#endif //MO_ENABLE_MOCK_SERVER
 #if MO_WS_USE != MO_WS_CUSTOM
-    if (this->connection && isConnectionOwner) {
-        freeDefaultConnection(this->connection);
+    if (this->connection && useDefaultConnection) {
+        mo_freeDefaultConnection(this->connection);
         this->connection = nullptr;
-        isConnectionOwner = false;
+        useDefaultConnection = false;
     }
 #endif //MO_WS_USE != MO_WS_CUSTOM
     this->connection = connection;
     if (this->connection) {
-        this->connection->setContext(this);
+        this->connection->ctx = reinterpret_cast<MO_Context*>(this);
     }
 }
 
-Connection *Context::getConnection() {
+MO_Connection *Context::getConnection() {
+    #if MO_ENABLE_MOCK_SERVER
+    if (!connection && useMockConnection) {
+        auto loopback = mo_loopback_make();
+        if (!loopback) {
+            MO_DBG_ERR("OOM");
+            return nullptr;;
+        }
+        setConnection(loopback);
+    }
+    #endif //MO_ENABLE_MOCK_SERVER
     #if MO_WS_USE != MO_WS_CUSTOM
     if (!connection && connectionConfigDefined) {
         // init default Connection implementation
-        connection = static_cast<Connection*>(makeDefaultConnection(connectionConfig, ocppVersion));
-        if (!connection) {
+        auto defaultConnection = mo_makeDefaultConnection(connectionConfig, ocppVersion);
+        if (!defaultConnection) {
             MO_DBG_ERR("OOM");
             return nullptr;
         }
-        isConnectionOwner = true;
+        setConnection(defaultConnection);
+        useDefaultConnection = true;
         mo_connectionConfig_deinit(&connectionConfig);
+        connectionConfigDefined = false;
     }
     #endif //MO_WS_USE != MO_WS_CUSTOM
     return connection;
 }
 
+#if MO_ENABLE_MOCK_SERVER
+void Context::useMockServer() {
+    if (connection) {
+        MO_DBG_ERR("switching to mock server mode after setting connection not supported");
+        return;
+    }
+    useMockConnection = true;
+}
+#endif //MO_ENABLE_MOCK_SERVER
+
 #if MO_ENABLE_MBEDTLS
 void Context::setFtpConfig(MO_FTPConfig ftpConfig) {
     this->ftpConfig = ftpConfig;
@@ -381,8 +415,8 @@ bool Context::setup() {
 }
 
 void Context::loop() {
-    if (connection) {
-        connection->loop();
+    if (connection && connection->loop) {
+        connection->loop(connection);
     }
     clock.loop();
     msgService.loop();

src/MicroOcpp/Context.h

@@ -42,13 +42,16 @@ class Context : public MemoryManaged {
     bool isFilesystemOwner = false;
 #endif //MO_USE_FILEAPI != MO_CUSTOM_FS
     MO_FilesystemAdapter *filesystem = nullptr;
-
+    
+#if MO_ENABLE_MOCK_SERVER
+    bool useMockConnection = false;
+#endif //MO_ENABLE_MOCK_SERVER
 #if MO_WS_USE != MO_WS_CUSTOM
     MO_ConnectionConfig connectionConfig;
     bool connectionConfigDefined = false;
-    bool isConnectionOwner = false;
+    bool useDefaultConnection = false;
 #endif //MO_WS_USE != MO_WS_CUSTOM
-    Connection *connection = nullptr;
+    MO_Connection *connection = nullptr;
 
 #if MO_ENABLE_MBEDTLS
     MO_FTPConfig ftpConfig;
@@ -93,8 +96,12 @@ class Context : public MemoryManaged {
 #if MO_WS_USE != MO_WS_CUSTOM
     bool setConnectionConfig(MO_ConnectionConfig connectionConfig);
 #endif //MO_WS_USE != MO_WS_CUSTOM
-    void setConnection(Connection *connection);
-    Connection *getConnection();
+    void setConnection(MO_Connection *connection);
+    MO_Connection *getConnection();
+
+#if MO_ENABLE_MOCK_SERVER
+    void useMockServer();
+#endif //MO_ENABLE_MOCK_SERVER
 
 #if MO_ENABLE_MBEDTLS
     void setFtpConfig(MO_FTPConfig ftpConfig);