renamed src file for linux dev env

src/IRbabyIRIS.cpp

@@ -0,0 +1,238 @@
+/**
+ *
+ * Copyright (c) 2020-2022 IRbaby-IRext
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#include <Esp.h>
+#include <WString.h>
+
+#include "defines.h"
+#include "IRbabyGlobal.h"
+#include "IRbabySerial.h"
+#include "IRbabyAlink.h"
+#include "IRbabyHttp.h"
+
+#include "IRbabyIRIS.h"
+
+
+extern StaticJsonDocument<1024> http_request_doc;
+extern StaticJsonDocument<1024> http_response_doc;
+extern StaticJsonDocument<1024> iris_msg_doc;
+extern StaticJsonDocument<1024> iris_ind_doc;
+
+extern String g_product_key;
+extern String g_device_name;
+extern String g_upstream_topic;
+extern int g_app_id;
+
+char iris_credential_token[CREDENTIAL_MAX] = { 0 };
+char iris_server_address[URL_SHORT_MAX] = { 0 };
+
+
+// private function declarations
+static int processEvent(const char* event_name, const char* payload, int length);
+static String buildConnect();
+static String buildHeartBeat();
+static int handleHartBeat(const char* payload, int length);
+static int handleEmit(const char* payload, int length);
+
+// private variable definitions
+event_handler_t event_handler_table[] = {
+    {
+        "__hb_response",
+        handleHartBeat,
+    },
+    {
+        "__emitCode",
+        handleEmit,
+    }
+};
+
+// public function definitions
+int getIRISKitVersion(char *buffer, int buffer_size) {
+    if (NULL == buffer) {
+        return -1;
+    }
+    memset(buffer, 0, buffer_size);
+    snprintf(buffer, buffer_size - 1, "%s_r%d", FIRMWARE_VERSION, VERSION_CODE);
+    return strlen(buffer);
+}
+
+int getDeviceID(char* buffer, int buffer_size) {
+    if (NULL == buffer) {
+        return -1;
+    }
+    String chipId = String(ESP.getChipId(), HEX);
+    memset(buffer, 0, buffer_size);
+    snprintf(buffer, buffer_size - 1, "%s", chipId.c_str());
+    return strlen(buffer);
+}
+
+int fetchIrisCredential(String credential_token,
+                        String& product_key,
+                        String& device_name,
+                        String& device_secret,
+                        int& app_id) {
+    int ret = -1;
+    int tsi = -1;
+    bool protocol_prefix = false;
+    String fetch_credential_url;
+    String request_data = "";
+    String response_data = "";
+    String device_id("IRbaby_");
+    http_error_t http_ret = HTTP_ERROR_GENERIC;
+
+    if (NULL != strstr(iris_server_address, "http://")) {
+        protocol_prefix = true;
+    }
+    if (protocol_prefix) {
+        fetch_credential_url = String(iris_server_address);
+    } else {
+        fetch_credential_url = String("http://");
+        fetch_credential_url.concat(iris_server_address);
+    }
+    fetch_credential_url.concat(String(FETCH_CREDENTIAL_SUFFIX));
+    device_id.concat(String(ESP.getChipId(), HEX));
+
+    INFOF("fetch credential URL = %s\n", fetch_credential_url.c_str());
+    if (credential_token.isEmpty()) {
+        ERRORLN("credential token is empty");
+        return -1;
+    }
+    tsi = credential_token.indexOf(",");
+    if (-1 == tsi) {
+        ERRORLN("credential token format error");
+        return -1;
+    }
+    product_key = credential_token.substring(0, tsi);
+    device_name = credential_token.substring(tsi + 1);
+    http_request_doc.clear();
+    http_request_doc["deviceID"] = device_id;
+    http_request_doc["credentialToken"] = credential_token;
+    serializeJson(http_request_doc, request_data);
+
+    http_ret = httpPost(fetch_credential_url, request_data, response_data);
+
+    if (HTTP_ERROR_SUCCESS == http_ret) {
+        http_response_doc.clear();
+        if (OK == deserializeJson(http_response_doc, response_data.c_str())) {
+            int resultCode = http_response_doc["status"]["code"];
+            if (0 == resultCode) {
+                INFOLN("response valid, try getting entity");
+                device_secret = (String) http_response_doc["entity"]["deviceSecret"];
+                app_id = (int) http_response_doc["entity"]["appId"];
+                INFOF("HTTP response deserialized, PK = %s, DN = %s, DS = %s\n",
+                    product_key.c_str(), device_name.c_str(), device_secret.c_str());
+                ret = 0;
+            } else {
+                INFOF("response invalid, code = %d\n", resultCode);
+            }
+        }
+    }
+
+    return ret;
+}
+
+void sendIrisKitConnect() {
+    String connectMessage = buildConnect();
+    sendRawData(g_upstream_topic.c_str(), (uint8_t*) connectMessage.c_str(), connectMessage.length());
+}
+
+void sendIrisKitHeartBeat() {
+    String heartBeatMessage = buildHeartBeat();
+    sendRawData(g_upstream_topic.c_str(), (uint8_t*) heartBeatMessage.c_str(), heartBeatMessage.length());
+}
+
+void handleIrisKitMessage(const char* data, int length) {
+    int ret = 0;
+    char* payload = (char*) malloc(length + 1);
+    if (NULL != payload) {
+        strncpy(payload, data, length);
+        payload[length] = '\0';
+        INFOF("--> %s\n", payload);
+        if (OK == deserializeJson(iris_ind_doc, payload)) {
+            String event_name = iris_ind_doc["eventName"];
+            INFOF("received ind : %s\n", event_name.c_str());
+            ret = processEvent(event_name.c_str(), payload, length);
+            INFOF("event handle result = %d\n", ret);
+        }
+    }
+
+    if (NULL != payload) {
+        free(payload);
+    }
+}
+
+
+// private function definitions
+static int processEvent(const char* event_name, const char* payload, int length) {
+    int event_table_length = sizeof(event_handler_table) / sizeof(event_handler_table[0]);
+    for (int i = 0; i < event_table_length; i++) {
+        if (0 == strcmp(event_name, event_handler_table[i].event_name)) {
+            return event_handler_table[i].handler(payload, length);
+        }
+    }
+    return -1;
+}
+
+static String buildConnect() {
+    String connectMessage = "";
+
+    iris_msg_doc.clear();
+    iris_msg_doc["eventName"] = String(EVENT_NAME_CONNECT);
+    iris_msg_doc["productKey"] = g_product_key;
+    iris_msg_doc["deviceName"] = g_device_name;
+    serializeJson(iris_msg_doc, connectMessage);
+
+    return connectMessage;
+}
+
+static String buildHeartBeat() {
+    String heartBeatMessage = "";
+
+    iris_msg_doc.clear();
+    iris_msg_doc["eventName"] = String(EVENT_HEART_BEAT_REQ);
+    iris_msg_doc["productKey"] = g_product_key;
+    iris_msg_doc["deviceName"] = g_device_name;
+    iris_msg_doc["appId"] = g_app_id;
+    serializeJson(iris_msg_doc, heartBeatMessage);
+
+    return heartBeatMessage;
+}
+
+static int handleHartBeat(const char* payload, int length) {
+    // TODO:
+    // do nothing currently
+    (void) payload;
+    (void) length;
+    return 0;
+}
+
+static int handleEmit(const char* payload, int length) {
+    // TODO:
+    (void) payload;
+    (void) length;
+    return 0;
+}