【修改内容】增加物模型的数据解析

【提交人】陈伟灿

src/midware/dm/kk_dm_mng.c

+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "kk_dm_mng.h"
+#include "kk_dm_msg.h"
+#include "solo_tsl.data"
+
+static dm_mgr_ctx g_dm_mgr = {0};
+
+static dm_mgr_ctx *_dm_mgr_get_ctx(void)
+{
+    return &g_dm_mgr;
+}
+
+static void _dm_mgr_mutex_lock(void)
+{
+    dm_mgr_ctx *ctx = _dm_mgr_get_ctx();
+    if (ctx->mutex) {
+        kk_MutexLock(ctx->mutex);
+    }
+}
+
+static void _dm_mgr_mutex_unlock(void)
+{
+    dm_mgr_ctx *ctx = _dm_mgr_get_ctx();
+    if (ctx->mutex) {
+        kk_MutexUnLock(ctx->mutex);
+    }
+}
+
+int dm_mgr_search_dev_by_devid(_IN_ int devid, _OU_ dm_mgr_dev_node_t **node)
+{
+    dm_mgr_ctx *ctx = _dm_mgr_get_ctx();
+    dm_mgr_dev_node_t *search_node = NULL;
+
+    list_for_each_entry(search_node, &ctx->dev_list, linked_list, dm_mgr_dev_node_t) {
+        if (search_node->devid == devid) {
+            /* dm_log_debug("Device Found, devid: %d", devid); */
+            if (node) {
+                *node = search_node;
+            }
+            return SUCCESS_RETURN;
+        }
+    }
+
+    printf("Device Not Found, devid: %d", devid);
+    return FAIL_RETURN;
+}
+static int _dm_mgr_search_dev_by_pkdn(_IN_ char product_key[PRODUCT_KEY_MAXLEN],
+                                      _IN_ char device_name[DEVICE_NAME_MAXLEN], _OU_ dm_mgr_dev_node_t **node)
+{
+    dm_mgr_ctx *ctx = _dm_mgr_get_ctx();
+    dm_mgr_dev_node_t *search_node = NULL;
+
+    list_for_each_entry(search_node, &ctx->dev_list, linked_list, dm_mgr_dev_node_t) {
+        if ((strlen(search_node->product_key) == strlen(product_key)) &&
+            (memcmp(search_node->product_key, product_key, strlen(product_key)) == 0) &&
+            (strlen(search_node->device_name) == strlen(device_name)) &&
+            (memcmp(search_node->device_name, device_name, strlen(device_name)) == 0)) {
+            /* dm_log_debug("Device Found, Product Key: %s, Device Name: %s", product_key, device_name); */
+            if (node) {
+                *node = search_node;
+            }
+            return SUCCESS_RETURN;
+        }
+    }
+
+    printf("Device Not Found, Product Key: %s, Device Name: %s", product_key, device_name);
+    return FAIL_RETURN;
+}
+static int _dm_mgr_next_devid(void)
+{
+    dm_mgr_ctx *ctx = _dm_mgr_get_ctx();
+
+    return ctx->global_devid++;
+}
+
+int dm_mgr_device_create(_IN_ int dev_type, _IN_ char product_key[PRODUCT_KEY_MAXLEN],
+                         _IN_ char device_name[DEVICE_NAME_MAXLEN], _IN_ char device_secret[DEVICE_SECRET_MAXLEN], _OU_ int *devid)
+{
+    int res = 0;
+    dm_mgr_ctx *ctx = _dm_mgr_get_ctx();
+    dm_mgr_dev_node_t *node = NULL;
+
+    if (product_key == NULL || device_name == NULL ||
+        strlen(product_key) >= PRODUCT_KEY_MAXLEN ||
+        strlen(device_name) >= DEVICE_NAME_MAXLEN) {
+        return INVALID_PARAMETER;
+    }
+
+    if (device_secret != NULL && strlen(device_secret) >= DEVICE_SECRET_MAXLEN) {
+        return INVALID_PARAMETER;
+    }
+
+    res = _dm_mgr_search_dev_by_pkdn(product_key, device_name, &node);
+    if (res == SUCCESS_RETURN) {
+        if (devid) {
+            *devid = node->devid;
+        }
+        return FAIL_RETURN;
+    }
+
+    node = malloc(sizeof(dm_mgr_dev_node_t));
+    if (node == NULL) {
+        return MEMORY_NOT_ENOUGH;
+    }
+    memset(node, 0, sizeof(dm_mgr_dev_node_t));
+
+	if(dev_type == KK_DM_DEVICE_GATEWAY)
+    	node->devid = 1;
+	else
+		node->devid = _dm_mgr_next_devid();
+    node->dev_type = dev_type;
+    node->dev_shadow = NULL;
+    memcpy(node->product_key, product_key, strlen(product_key));
+    memcpy(node->device_name, device_name, strlen(device_name));
+    if (device_secret != NULL) {
+        memcpy(node->device_secret, device_secret, strlen(device_secret));
+    }
+    //node->dev_status = IOTX_DM_DEV_STATUS_AUTHORIZED;
+	if(dev_type == KK_DM_DEVICE_SUBDEV){
+		res = kk_tsl_create(TSL_STRING,strlen(TSL_STRING),&node->dev_shadow);
+		if(res != 0)
+		{
+			return FAIL_RETURN;
+		}
+	}
+    INIT_LIST_HEAD(&node->linked_list);
+    list_add_tail(&node->linked_list, &ctx->dev_list);
+
+    if (devid) {
+        *devid = node->devid;
+    }
+
+    return SUCCESS_RETURN;
+}
+int dm_mgr_search_device_by_pkdn(_IN_ char product_key[PRODUCT_KEY_MAXLEN], _IN_ char device_name[DEVICE_NAME_MAXLEN],
+                                 _OU_ int *devid)
+{
+    int res = 0;
+    dm_mgr_dev_node_t *node = NULL;
+
+    if (product_key == NULL || device_name == NULL) {
+        return INVALID_PARAMETER;
+    }
+
+    res = _dm_mgr_search_dev_by_pkdn(product_key, device_name, &node);
+    if (res != SUCCESS_RETURN) {
+        return FAIL_RETURN;
+    }
+
+    if (devid) {
+        *devid = node->devid;
+    }
+
+    return SUCCESS_RETURN;
+}
+
+int dm_mgr_init(void)
+{
+    int res = 0;
+    dm_mgr_ctx *ctx = _dm_mgr_get_ctx();
+    char product_key[PRODUCT_KEY_MAXLEN] = {0};
+    char device_name[DEVICE_NAME_MAXLEN] = {0};
+	char device_secret[DEVICE_SECRET_MAXLEN]= {0};
+	int devId = 0;
+    memset(ctx, 0, sizeof(dm_mgr_ctx));
+
+    /* Create Mutex */
+    ctx->mutex = kk_MutexCreate();
+    if (ctx->mutex == NULL) {
+        goto ERROR;
+    }
+    /* Init Device Id*/
+    ctx->global_devid = 1;
+
+    /* Init Device List */
+    INIT_LIST_HEAD(&ctx->dev_list);
+
+    /*----------to do************************ */
+    //HAL_GetProductKey(product_key);
+    //HAL_GetDeviceName(device_name);
+
+    //_dm_mgr_legacy_thing_created(IOTX_DM_LOCAL_NODE_DEVID);
+	res = dm_mgr_device_create(KK_DM_DEVICE_SUBDEV,product_key,product_key,device_secret,&devId);
+	if (res != SUCCESS_RETURN) {
+		goto ERROR;
+	}
+    return SUCCESS_RETURN;
+
+ERROR:
+    if (ctx->mutex) {
+        kk_MutexDestroy(ctx->mutex);
+    }
+    memset(ctx, 0, sizeof(dm_mgr_ctx));
+    return FAIL_RETURN;
+}
+static int _dm_mgr_upstream_request_assemble(_IN_ int msgid, _IN_ int devid, _IN_ const char *service_prefix,
+        _IN_ const char *service_name,
+        _IN_ char *params, _IN_ int params_len, _IN_ char *method, _OU_ dm_msg_request_t *request)
+{
+    int res = 0;
+    dm_mgr_dev_node_t *node = NULL;
+
+    res = dm_mgr_search_dev_by_devid(devid, &node);
+    if (res != SUCCESS_RETURN) {
+        return FAIL_RETURN;
+    }
+
+    request->msgid = msgid;
+    request->devid = devid;
+    request->service_prefix = service_prefix;
+    request->service_name = service_name;
+    memcpy(request->product_key, node->product_key, strlen(node->product_key));
+    memcpy(request->device_name, node->device_name, strlen(node->device_name));
+    request->params = params;
+    request->params_len = params_len;
+    request->method = method;
+
+    return SUCCESS_RETURN;
+}
+static unsigned int g_report_id = 0;
+
+int iotx_report_id(void)
+{
+    return g_report_id++;
+}
+
+int dm_mgr_upstream_thing_property_post(_IN_ int devid, _IN_ char *payload, _IN_ int payload_len)
+{
+    int res = 0;
+    dm_msg_request_t request;
+
+    if (devid < 0 || payload == NULL || payload_len <= 0) {
+        return INVALID_PARAMETER;
+    }
+
+    memset(&request, 0, sizeof(dm_msg_request_t));
+    res = _dm_mgr_upstream_request_assemble(iotx_report_id(), devid, DM_URI_SYS_PREFIX, DM_URI_THING_EVENT_PROPERTY_POST,
+                                            payload, payload_len, "thing.event.property.post", &request);
+    if (res != SUCCESS_RETURN) {
+        return FAIL_RETURN;
+    }
+
+    /* Callback */
+    //request.callback = dm_client_thing_event_post_reply;
+
+    /* Send Message To Cloud */
+    res = dm_msg_request(&request);
+    return res;
+}
+

src/midware/dm/kk_dm_mng.h

+#ifndef __KK_DM_MNG__
+#define __KK_DM_MNG__
+#include "kk_tsl_common.h"
+#include "klist.h"
+
+#define KK_DM_DEVICE_SINGLE  (0x01)
+#define KK_DM_DEVICE_SUBDEV  (0x02)
+#define KK_DM_DEVICE_GATEWAY (0x04)
+
+typedef struct {
+    int devid;
+    int dev_type;
+    kk_tsl_t *dev_shadow;
+    char product_key[PRODUCT_KEY_MAXLEN];
+    char device_name[DEVICE_NAME_MAXLEN];
+    char device_secret[DEVICE_SECRET_MAXLEN];
+    //iotx_dm_dev_avail_t status;
+    //iotx_dm_dev_status_t dev_status;
+    struct list_head linked_list;
+} dm_mgr_dev_node_t;
+
+typedef struct {
+    void *mutex;
+    int global_devid;
+    struct list_head dev_list;
+} dm_mgr_ctx;
+
+typedef struct {
+    int msgid;
+    int devid;
+    const char *service_prefix;
+    const char *service_name;
+    char product_key[PRODUCT_KEY_MAXLEN];
+    char device_name[DEVICE_NAME_MAXLEN];
+    char *params;
+    int params_len;
+    char *method;
+    //iotx_cm_data_handle_cb callback;
+} dm_msg_request_t;
+
+#endif

src/midware/dm/kk_dm_msg.c

+#include "kk_dm_msg.h"
+#include "kk_dm_mng.h"
+#include "lite-cjson.h"
+
+const char DM_URI_SYS_PREFIX[]                        DM_READ_ONLY = "/sys/%s/%s/";
+const char DM_URI_THING_EVENT_PROPERTY_POST[]		  DM_READ_ONLY = "thing/event/property/post";
+
+
+const char DM_MSG_REQUEST[] DM_READ_ONLY = "{\"id\":\"%d\",\"version\":\"%s\",\"params\":%.*s,\"method\":\"%s\"}";
+int dm_msg_request (_IN_ dm_msg_request_t *request)
+{
+    int res = 0, payload_len = 0;
+    char *payload = NULL, *uri = NULL;
+    lite_cjson_t lite;
+
+    if (request == NULL || request->params == NULL || request->method == NULL) {
+        return INVALID_PARAMETER;
+    }
+
+    /* Request URI */
+    res = kk_utils_service_name(request->service_prefix, request->service_name,
+                                request->product_key, request->device_name, &uri);
+    if (res != SUCCESS_RETURN) {
+        return FAIL_RETURN;
+    }
+
+    payload_len = strlen(DM_MSG_REQUEST) + 10 + strlen(DM_MSG_VERSION) + request->params_len + strlen(
+                              request->method) + 1;
+    payload = malloc(payload_len);
+    if (payload == NULL) {
+        free(uri);
+        return MEMORY_NOT_ENOUGH;
+    }
+    memset(payload, 0, payload_len);
+    snprintf(payload, payload_len, DM_MSG_REQUEST, request->msgid,
+                 DM_MSG_VERSION, request->params_len, request->params, request->method);
+
+    memset(&lite, 0, sizeof(lite_cjson_t));
+    res = lite_cjson_parse(payload, payload_len, &lite);
+    if (res < SUCCESS_RETURN) {
+        printf("Wrong JSON Format, URI: %s, Payload: %s", uri, payload);
+        free(uri);
+        free(payload);
+        return FAIL_RETURN;
+    }
+
+    printf("DM Send Message, URI: %s, Payload: %s", uri, payload);
+
+    //if (type & DM_MSG_DEST_CLOUD) {
+     //dm_client_publish(uri, (unsigned char *)payload, strlen(payload), request->callback);
+    //}
+    free(uri);
+    free(payload);
+    return SUCCESS_RETURN;
+}
+

src/midware/dm/kk_dm_msg.h

+#ifndef __KK_DM_MSG__
+#define __KK_DM_MSG__
+#include "kk_tsl_common.h"
+
+typedef enum {
+    IOTX_DM_EVENT_CLOUD_CONNECTED  = 0,
+    IOTX_DM_EVENT_CLOUD_DISCONNECT,
+    IOTX_DM_EVENT_CLOUD_RECONNECT,
+    IOTX_DM_EVENT_LOCAL_CONNECTED,
+    IOTX_DM_EVENT_LOCAL_DISCONNECT,
+    IOTX_DM_EVENT_LOCAL_RECONNECT,
+    IOTX_DM_EVENT_FOUND_DEVICE,
+    IOTX_DM_EVENT_REMOVE_DEVICE,
+    IOTX_DM_EVENT_REGISTER_RESULT,
+    IOTX_DM_EVENT_UNREGISTER_RESULT,
+    IOTX_DM_EVENT_INITIALIZED,
+    IOTX_DM_EVENT_SEND_RESULT,
+    IOTX_DM_EVENT_ADD_SERVICE_RESULT,
+    IOTX_DM_EVENT_REMOVE_SERVICE_RESULT,
+    IOTX_DM_EVENT_NEW_DATA_RECEIVED,
+    IOTX_DM_EVENT_PROPERTY_SET,
+    IOTX_DM_EVENT_PROPERTY_GET,
+    IOTX_DM_EVENT_TOPO_ADD_NOTIFY,
+    IOTX_DM_EVENT_THING_SERVICE_REQUEST,
+    IOTX_DM_EVENT_THING_DISABLE,
+    IOTX_DM_EVENT_THING_ENABLE,
+    IOTX_DM_EVENT_THING_DELETE,
+    IOTX_DM_EVENT_MODEL_DOWN_RAW,
+    IOTX_DM_EVENT_GATEWAY_PERMIT,
+    IOTX_DM_EVENT_SUBDEV_REGISTER_REPLY,
+    IOTX_DM_EVENT_SUBDEV_UNREGISTER_REPLY,
+    IOTX_DM_EVENT_TOPO_ADD_REPLY,
+    IOTX_DM_EVENT_TOPO_DELETE_REPLY,
+    IOTX_DM_EVENT_TOPO_GET_REPLY,
+    IOTX_DM_EVENT_TOPO_ADD_NOTIFY_REPLY,
+    IOTX_DM_EVENT_EVENT_PROPERTY_POST_REPLY,
+    IOTX_DM_EVENT_EVENT_SPECIFIC_POST_REPLY,
+    IOTX_DM_EVENT_DEVICEINFO_UPDATE_REPLY,
+    IOTX_DM_EVENT_DEVICEINFO_DELETE_REPLY,
+    IOTX_DM_EVENT_DSLTEMPLATE_GET_REPLY,
+    IOTX_DM_EVENT_COMBINE_LOGIN_REPLY,
+    IOTX_DM_EVENT_COMBINE_LOGOUT_REPLY,
+    IOTX_DM_EVENT_MODEL_UP_RAW_REPLY,
+    IOTX_DM_EVENT_LEGACY_THING_CREATED,
+    IOTX_DM_EVENT_COTA_NEW_CONFIG,
+    IOTX_DM_EVENT_FOTA_NEW_FIRMWARE,
+    IOTX_DM_EVENT_NTP_RESPONSE,
+    IOTX_DM_EVENT_RRPC_REQUEST,
+    IOTX_DM_EVENT_MAX
+} iotx_dm_event_types_t;
+
+#ifndef DM_READ_ONLY
+    #define DM_READ_ONLY
+#endif
+#define DM_MSG_VERSION                  "1.0"
+
+extern const char DM_URI_SYS_PREFIX[]          DM_READ_ONLY;
+extern const char DM_URI_THING_EVENT_PROPERTY_POST[]		 DM_READ_ONLY;
+
+#endif

src/midware/tsl_handle/kk_dm.h

+

src/midware/tsl_handle/kk_tsl_api.h

+#ifndef _TSL_API_H__
+#define _TSL_API_H__
+#include "lite-cjson.h"
+#include "kk_tsl_common.h"
+
+
+
+#define KK_MSG_KEY_ID                   "id"
+#define KK_MSG_KEY_VERSION              "version"
+#define KK_MSG_KEY_METHOD               "method"
+#define KK_MSG_KEY_PARAMS               "params"
+#define KK_MSG_KEY_CODE                 "code"
+#define KK_MSG_KEY_DATA                 "data"
+#define KK_MSG_KEY_MESSAGE              "message"
+
+
+typedef enum {
+    IOTX_DM_ERR_CODE_SUCCESS              = 200,
+    IOTX_DM_ERR_CODE_REQUEST_ERROR        = 400,
+    IOTX_DM_ERR_CODE_REQUEST_PARAMS_ERROR = 460,
+    IOTX_DM_ERR_CODE_REQUEST_TOO_MANY     = 429,
+    IOTX_DM_ERR_CODE_NO_ACTIVE_SESSION    = 520,
+    IOTX_DM_ERR_CODE_TIMEOUT              = 100000
+} iotx_dm_error_code_t;
+
+typedef struct {
+    const char *uri;
+    unsigned char *payload;
+    unsigned int payload_len;
+    void *context;
+} kk_msg_source_t;
+
+typedef struct {
+    const char *uri_name;
+} kk_msg_dest_t;
+
+typedef struct {
+    lite_cjson_t id;
+    lite_cjson_t version;
+    lite_cjson_t method;
+    lite_cjson_t params;
+} kk_msg_request_payload_t;
+
+typedef struct {
+    lite_cjson_t id;
+    lite_cjson_t code;
+    lite_cjson_t data;
+    lite_cjson_t message;
+} kk_msg_response_payload_t;
+
+typedef struct {
+    int msgid;
+    int devid;
+    const char *service_prefix;
+    const char *service_name;
+    char product_key[PRODUCT_KEY_MAXLEN];
+    char device_name[DEVICE_NAME_MAXLEN];
+    char *params;
+    int params_len;
+    char *method;
+    //iotx_cm_data_handle_cb callback;
+} kk_msg_request_t;
+typedef struct {
+    const char *service_prefix;
+    const char *service_name;
+    char product_key[PRODUCT_KEY_MAXLEN];
+    char device_name[DEVICE_NAME_MAXLEN];
+    iotx_dm_error_code_t code;
+} kk_msg_response_t;
+
+typedef enum {
+    kk_tsl_set_property_value = 0,
+    kk_tsl_set_event_output_value,
+    kk_tsl_set_service_output_value,
+    kk_tsl_set_number,
+} kk_tsl_set_t;
+
+typedef struct {
+    void *mutex;
+    int devid;
+    lite_cjson_item_t *lite;
+} dm_api_property_t;
+
+#endif

src/midware/tsl_handle/kk_tsl_common.h

+#ifndef __KK_TSL_COM__
+#define __KK_TSL_COM__
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#ifndef _IN_
+    #define _IN_
+#endif
+
+#ifndef _OU_
+    #define _OU_
+#endif
+
+#define PRODUCT_KEY_MAXLEN          (20 + 1)
+#define DEVICE_NAME_MAXLEN          (32 + 1)
+#define DEVICE_SECRET_MAXLEN        (64 + 1)
+
+#define DM_UTILS_UINT16_STRLEN (5)
+#define DM_UTILS_UINT32_STRLEN (10)
+#define DM_UTILS_UINT64_STRLEN (20)
+
+#define KK_TSL_KEY_SCHEMA                     "schema"
+#define KK_TSL_KEY_LINK                       "link"
+#define KK_TSL_KEY_PROFILE                    "profile"
+#define KK_TSL_KEY_PROPERTIES                 "properties"
+#define KK_TSL_KEY_EVENTS                     "events"
+#define KK_TSL_KEY_SERVICES                   "services"
+#define KK_TSL_KEY_PROFILE_PK                 "productKey"
+#define KK_TSL_KEY_PROFILE_DN                 "deviceName"
+#define KK_TSL_KEY_IDENTIFIER                 "identifier"
+#define KK_TSL_KEY_NAME                       "name"
+#define KK_TSL_KEY_DESC                       "desc"
+#define KK_TSL_KEY_ACCESS_MODE                "accessMode"
+#define KK_TSL_KEY_REQUIRED                   "required"
+#define KK_TSL_KEY_METHOD                     "method"
+#define KK_TSL_KEY_CALLTYPE                   "callType"
+#define KK_TSL_KEY_OUTPUTDATA                 "outputData"
+#define KK_TSL_KEY_INPUTDATA                  "inputData"
+#define KK_TSL_KEY_DATATYPE                   "dataType"
+#define KK_TSL_KEY_TYPE                       "type"
+#define KK_TSL_KEY_SPECS                      "specs"
+#define KK_TSL_KEY_UNIT                       "unit"
+#define KK_TSL_KEY_UNITNAME                   "unitName"
+#define KK_TSL_KEY_MIN                        "min"
+#define KK_TSL_KEY_MAX                        "max"
+#define KK_TSL_KEY_LENGTH                     "length"
+#define KK_TSL_KEY_SIZE                       "size"
+#define KK_TSL_KEY_ITEM                       "item"
+#define KK_MSG_KEY_DELIMITER                  '.'
+#define KK_URI_SERVICE_DELIMITER '/'
+#define KK_URI_OFFSET 1
+
+//Special Service And Event
+#define KK_TSL_SPECIAL_SERVICE_SET_IDENTIFIER "set"
+#define KK_TSL_SPECIAL_SERVICE_SET_METHOD     "thing.service.property.set"
+#define KK_TSL_SPECIAL_SERVICE_GET_IDENTIFIER "get"
+#define KK_TSL_SPECIAL_SERVICE_GET_METHOD     "thing.service.property.get"
+#define KK_TSL_SPECIAL_EVENT_POST_IDENTIFIER  "post"
+#define KK_TSL_SPECIAL_EVENT_POST_METHOD      "thing.event.property.post"
+
+typedef enum {
+    KK_TSL_DATA_TARGET_SERVICE_INPUT_DATA,
+    KK_TSL_DATA_TARGET_SERVICE_OUTPUT_DATA
+} kk_tsl_data_target_e;
+
+typedef enum {
+    TSL_SERVICE_GET_FAILED = -13,
+    TSL_SERVICE_SET_FAILED = -12,
+    TSL_EVENT_GET_FAILED = -11,
+    TSL_EVENT_SET_FAILED = -10,
+    TSL_PROPERTY_GET_FAILED = -9,
+    TSL_PROPERTY_SET_FAILED = -8,
+    TSL_EVENT_NOT_EXIST = -7,
+    TSL_PROPERTY_NOT_EXIST = -6,
+    TSL_SERVICE_NOT_EXIST = -5,
+    JSON_PARSE_FAILED = -4,
+    MEMORY_NOT_ENOUGH = -3,
+    INVALID_PARAMETER = -2,
+    FAIL_RETURN = -1,
+    SUCCESS_RETURN = 0,
+} kk_tsl_error_code_t;
+
+typedef enum {
+    KK_TSL_DATA_TYPE_NONE,                    //none
+    KK_TSL_DATA_TYPE_INT,                     //int
+    KK_TSL_DATA_TYPE_FLOAT,                   //float
+    KK_TSL_DATA_TYPE_DOUBLE,                  //double
+    KK_TSL_DATA_TYPE_TEXT,                    //string
+    KK_TSL_DATA_TYPE_ENUM,                    //int
+    KK_TSL_DATA_TYPE_DATE,                    //string
+    KK_TSL_DATA_TYPE_BOOL,                    //bool,0 or 1
+    KK_TSL_DATA_TYPE_ARRAY,                   //support int, float, double, text
+    KK_TSL_DATA_TYPE_STRUCT,                  //support above 8 data types
+} kk_tsl_data_type_e;
+typedef struct {
+    kk_tsl_data_type_e type;
+    int size;
+    void *value;
+} kk_tsl_data_value_complex_t;
+
+typedef struct {
+	kk_tsl_data_type_e type;
+	union {
+		int value_int;
+		float value_float;
+		double value_double;
+		void *value;							 //string or complex type accroding to data type
+	};
+} kk_tsl_data_value_t;
+
+
+typedef struct {
+    char *identifier;
+    kk_tsl_data_value_t data_value;
+} kk_tsl_data_t;
+
+typedef struct {
+    char *identifier;
+    int input_data_number;                       //input_data Number
+    kk_tsl_data_t *input_datas;               //input_data array, type is dm_shw_data_t
+    int output_data_number;                      //ouput_data Number
+    kk_tsl_data_t *output_datas;              //output_data array, type is dm_shw_data_t
+} kk_tsl_event_t;
+
+typedef struct {
+    char *identifier;                            //synchronized or asynchronized
+    int input_data_number;                       //input_data_number
+    kk_tsl_data_t *input_datas;               //input_data array, type is dm_shw_data_t
+    int output_data_number;                      //ouput_data Number
+    kk_tsl_data_t *output_datas;              //output_data array, type is dm_shw_data_t
+} kk_tsl_service_t;
+
+
+typedef struct {
+    int property_number;
+    kk_tsl_data_t *properties;                //property array, type is dm_shw_data_t
+    int event_number;
+    kk_tsl_event_t *events;                   //event array, type is dm_shw_event_t
+    int service_number;
+    kk_tsl_service_t *services;               //service array, type is dm_shw_service_t
+} kk_tsl_t;
+
+#endif

src/midware/tsl_handle/kk_tsl_load.h

+#ifndef _DM_SHADOW_H_
+#define _DM_SHADOW_H_
+#include "kk_tsl_common.h"
+
+int kk_tsl_create(_IN_ const char *tsl, _IN_ int tsl_len, _OU_ kk_tsl_t **shadow);
+
+#endif

src/midware/tsl_handle/kk_utils.c

+#include "kk_utils.h"
+
+int kk_utils_copy(_IN_ void *input, _IN_ int input_len, _OU_ void **output, _IN_ int output_len)
+{
+    if (input == NULL || output == NULL || *output != NULL) {
+        return INVALID_PARAMETER;
+    }
+
+    *output = malloc(output_len);
+    if (*output == NULL) {
+        return MEMORY_NOT_ENOUGH;
+    }
+    memset(*output, 0, output_len);
+    memcpy(*output, input, input_len);
+
+    return SUCCESS_RETURN;
+}
+int kk_utils_memtok(_IN_ char *input, _IN_ int input_len, _IN_ char delimiter, _IN_ int index, _OU_ int *offset)
+{
+    int item_index = 0;
+    int count = 0;
+
+    if (input == NULL || input_len <= 0 || offset == NULL) {
+        return INVALID_PARAMETER;
+    }
+
+    for (item_index = 0; item_index < input_len; item_index++) {
+        if (input[item_index] == delimiter && (item_index + 1) < input_len) {
+            count++;
+            if (count == index) {
+                *offset = item_index;
+                return SUCCESS_RETURN;
+            }
+        }
+    }
+
+    return FAIL_RETURN;
+}
+int kk_utils_strarr_index(_IN_ char *input, _IN_ int input_len,
+                          _OU_ int *partial_input_len, _OU_ int *array_input_len, _OU_ int *array_index)
+{
+    if (input == NULL || input_len <= 1 || array_index == NULL) {
+        return INVALID_PARAMETER;
+    }
+
+    int index = 0;
+    int deep = 0;
+    char *bracket_pre = NULL;
+    char *bracket_suf = NULL;
+    char array_index_str[10] = {0};
+
+    for (index = 0; index < input_len; index++) {
+        switch (input[index]) {
+            case '[': {
+                if (deep != 0) {
+                    return FAIL_RETURN;
+                }
+                deep++;
+                if (!bracket_pre) {
+                    bracket_pre = (char *)&input[index];
+                }
+            }
+            break;
+            case ']': {
+                if (deep != 1) {
+                    return FAIL_RETURN;
+                }
+                deep--;
+                if (input[index  - 1] == '[') {
+                    return FAIL_RETURN;
+                }
+                if (!bracket_suf) {
+                    bracket_suf = (char *)&input[index];
+                }
+            }
+            break;
+            default:
+                break;
+        }
+    }
+
+    if (bracket_pre && bracket_suf && ((bracket_suf - input + 1) == input_len)) {
+        if (partial_input_len) {
+            *partial_input_len = bracket_pre - input;
+        }
+        if (array_input_len) {
+            *array_input_len = bracket_suf - input + 1;
+        }
+
+        //Get Index
+        memcpy(array_index_str, bracket_pre + 1, bracket_suf - bracket_pre - 1);
+        *array_index = atoi(array_index_str);
+        return SUCCESS_RETURN;
+    }
+
+    return FAIL_RETURN;
+}
+int kk_utils_copy_direct(_IN_ void *input, _IN_ int input_len, _OU_ void **output, _IN_ int output_len)
+{
+    if (input == NULL || output == NULL || *output != NULL) {
+        return INVALID_PARAMETER;
+    }
+
+    *output = malloc(output_len);
+    if (*output == NULL) {
+        return MEMORY_NOT_ENOUGH;
+    }
+    memset(*output, 0, output_len);
+    memcpy(*output, input, input_len);
+
+    return SUCCESS_RETURN;
+}
+
+int kk_utils_itoa(_IN_ int input, _OU_ char **output)
+{
+    int res = 0;
+    char temp_output[10 + 1] = {0};
+
+    if (output == NULL || *output != NULL) {
+        return INVALID_PARAMETER;
+    }
+
+    res = snprintf(temp_output, 10, "%d", input);
+    if (res < 0) {
+        return FAIL_RETURN;
+    }
+
+    *output = malloc(strlen(temp_output) + 1);
+    if (*output == NULL) {
+        return MEMORY_NOT_ENOUGH;
+    }
+    memset(*output, 0, strlen(temp_output) + 1);
+    memcpy(*output, temp_output, strlen(temp_output));
+
+    return SUCCESS_RETURN;
+}
+void *kk_MutexCreate(void)
+{
+    int err_num;
+    pthread_mutex_t *mutex = (pthread_mutex_t *)malloc(sizeof(pthread_mutex_t));
+    if (NULL == mutex) 
+	{
+        return NULL;
+    }
+
+    if (0 != (err_num = pthread_mutex_init(mutex, NULL))) 
+	{
+        printf("create mutex failed\n");
+        free(mutex);
+        return NULL;
+    }
+
+    return mutex;
+}
+void kk_MutexLock(void *mutex)
+{
+    int err_num;
+    if (0 != (err_num = pthread_mutex_lock((pthread_mutex_t *)mutex))) 
+	{
+        printf("lock mutex failed: - '%s' (%d)\n", strerror(err_num), err_num);
+    }
+}
+
+void kk_MutexUnLock(void *mutex)
+{
+    int err_num;
+    if (0 != (err_num = pthread_mutex_unlock((pthread_mutex_t *)mutex))) 
+	{
+        printf("unlock mutex failed - '%s' (%d)\n", strerror(err_num), err_num);
+    }
+}
+
+void kk_MutexDestroy(void *mutex)
+{
+    int err_num;
+
+    if (!mutex) 
+	{
+        printf("mutex want to destroy is NULL!\n");
+        return;
+    }
+    if (0 != (err_num = pthread_mutex_destroy((pthread_mutex_t *)mutex))) 
+	{
+        printf("destroy mutex failed\n");
+    }
+
+    free(mutex);
+}
+int kk_utils_service_name(_IN_ const char *prefix, _IN_ const char *name, _IN_ char product_key[PRODUCT_KEY_MAXLEN],
+                          _IN_ char device_name[DEVICE_NAME_MAXLEN], _OU_ char **service_name)
+{
+    int prefix_len = (prefix == NULL) ? (0) : (strlen(prefix));
+    int name_len = (name == NULL) ? (0) : (strlen(name));
+    int service_name_len = 0;
+    if ((prefix == NULL && name == NULL) || product_key == NULL || device_name == NULL ||
+        service_name == NULL || *service_name != NULL) {
+        return INVALID_PARAMETER;
+    }
+
+    service_name_len = prefix_len + name_len + strlen(product_key) + strlen(device_name) + 1;
+    *service_name = malloc(service_name_len);
+    if (*service_name == NULL) {
+        return MEMORY_NOT_ENOUGH;
+    }
+    memset(*service_name, 0, service_name_len);
+
+    if (prefix != NULL) {
+        snprintf(*service_name, service_name_len, prefix, product_key, device_name);
+    }
+
+    if (name != NULL) {
+        memcpy(*service_name + strlen(*service_name), name, name_len);
+    }
+
+    return SUCCESS_RETURN;
+}
+
+

src/midware/tsl_handle/kk_utils.h

+#ifndef __KK_UTILS_H__
+#define __KK_UTILS_H__
+#include "kk_tsl_common.h"
+
+
+int kk_utils_copy(_IN_ void *input, _IN_ int input_len, _OU_ void **output, _IN_ int output_len);
+int kk_utils_strarr_index(_IN_ char *input, _IN_ int input_len,_OU_ int *partial_input_len, _OU_ int *array_input_len, _OU_ int *array_index);
+int kk_utils_copy_direct(_IN_ void *input, _IN_ int input_len, _OU_ void **output, _IN_ int output_len);
+int kk_utils_itoa(_IN_ int input, _OU_ char **output);
+int kk_utils_memtok(_IN_ char *input, _IN_ int input_len, _IN_ char delimiter, _IN_ int index, _OU_ int *offset);
+void *kk_MutexCreate(void);
+void kk_MutexLock(void *mutex);
+void kk_MutexUnLock(void *mutex);
+void kk_MutexDestroy(void *mutex);
+
+#endif

src/midware/tsl_handle/lite-cjson.h

+/*
+ * Copyright (C) 2015-2018 Alibaba Group Holding Limited
+ */
+
+#ifndef __LITE_CJSON_H__
+#define __LITE_CJSON_H__
+
+#ifndef _IN_
+    #define _IN_
+#endif
+
+#ifndef _OU_
+    #define _OU_
+#endif
+typedef unsigned int uint32_t;
+/* cJSON Types: */
+#define cJSON_Invalid (0)
+#define cJSON_False  (1 << 0)
+#define cJSON_True   (1 << 1)
+#define cJSON_NULL   (1 << 2)
+#define cJSON_Number (1 << 3)
+#define cJSON_String (1 << 4)
+#define cJSON_Array  (1 << 5)
+#define cJSON_Object (1 << 6)
+#define cJSON_Raw    (1 << 7) /* raw json */
+
+#ifndef LITE_CJSON_NESTING_LIMIT
+    #define LITE_CJSON_NESTING_LIMIT 1000
+#endif
+
+/* The cJSON structure: */
+typedef struct lite_cjson_st {
+    /* The type of the item, as above. */
+    int type;
+
+    /* The item's string, if type==cJSON_String  and type == cJSON_Raw */
+    char *value;
+    int value_length;
+
+    /* The item's size, if type == cJSON_Array and type == cJSON_Object */
+    int size;
+
+    double value_double;
+    int value_int;
+} lite_cjson_t;
+
+int lite_cjson_parse(_IN_ const char *src, _IN_ int src_len, _OU_ lite_cjson_t *lite);
+
+int lite_cjson_is_false(_IN_ lite_cjson_t *lite);
+int lite_cjson_is_true(_IN_ lite_cjson_t *lite);
+int lite_cjson_is_null(_IN_ lite_cjson_t *lite);
+int lite_cjson_is_number(_IN_ lite_cjson_t *lite);
+int lite_cjson_is_string(_IN_ lite_cjson_t *lite);
+int lite_cjson_is_array(_IN_ lite_cjson_t *lite);
+int lite_cjson_is_object(_IN_ lite_cjson_t *lite);
+
+int lite_cjson_array_item(_IN_ lite_cjson_t *lite, _IN_ int index, _OU_ lite_cjson_t *lite_item);
+int lite_cjson_object_item(
+            _IN_ lite_cjson_t *lite,
+            _IN_ const char *key,
+            _IN_ int key_len,
+            _OU_ lite_cjson_t *lite_item);
+int lite_cjson_object_item_by_index(
+            _IN_ lite_cjson_t *lite,
+            _IN_ int index,
+            _OU_ lite_cjson_t *lite_item_key,
+            _OU_ lite_cjson_t *lite_item_value);
+
+
+/*** lite_cjson create, add and print ***/
+typedef int cJSON_bool;
+
+#define cJSON_IsReference 256
+#define cJSON_StringIsConst 512
+
+/* The cJSON structure: */
+typedef struct lite_cjson_item_t {
+    struct lite_cjson_item_t *next,
+               *prev;  /* next/prev allow you to walk array/object chains. Alternatively, use GetArraySize/GetArrayItem/GetObjectItem */
+    struct lite_cjson_item_t
+        *child;        /* An array or object item will have a child pointer pointing to a chain of the items in the array/object. */
+
+    int type;                   /* The type of the item, as above. */
+
+    char *valuestring;          /* The item's string, if type==cJSON_String */
+    int valueint;               /* The item's number, if type==cJSON_Number */
+    double valuedouble;         /* The item's number, if type==cJSON_Number */
+
+    char *string;               /* The item's name string, if this item is the child of, or is in the list of subitems of an object. */
+} lite_cjson_item_t;
+
+typedef struct {
+    void *(*malloc_fn)(unsigned int sz);
+    void(*free_fn)(void *ptr);
+} lite_cjson_hooks;
+
+void lite_cjson_init_hooks(lite_cjson_hooks *hooks);
+
+/* Render a lite_cjson_item_t entity to text for transfer/storage. Free the char* when finished. */
+char  *lite_cjson_print(lite_cjson_item_t *item);
+char  *lite_cjson_print_unformatted(lite_cjson_item_t *item);
+
+/* Delete a lite_cjson_item_t entity and all subentities. */
+void lite_cjson_delete(lite_cjson_item_t *item);
+
+/* Append item to specific object */
+void lite_cjson_add_item_to_array(lite_cjson_item_t *array, lite_cjson_item_t *item);
+void lite_cjson_add_item_to_object(lite_cjson_item_t *object, const char *string, lite_cjson_item_t *item);
+
+/* These calls create a lite_cjson_item_t item of the appropriate type. */
+lite_cjson_item_t *lite_cjson_create_null(void);
+lite_cjson_item_t *lite_cjson_create_true(void);
+lite_cjson_item_t *lite_cjson_create_false(void);
+lite_cjson_item_t *lite_cjson_create_bool(int b);
+lite_cjson_item_t *lite_cjson_create_number(double num);
+lite_cjson_item_t *lite_cjson_create_string(const char *string);
+lite_cjson_item_t *lite_cjson_create_array(void);
+lite_cjson_item_t *lite_cjson_create_object(void);
+
+/* These utilities create an Array of count items. */
+lite_cjson_item_t *lite_cjson_create_intArray(const int *numbers, int count);
+lite_cjson_item_t *lite_cjson_create_floatArray(const float *numbers, int count);
+lite_cjson_item_t *lite_cjson_create_doubleArray(const double *numbers, int count);
+lite_cjson_item_t *lite_cjson_create_stringArray(const char **strings, int count);
+
+/* Macros for creating things quickly. */
+#define lite_cjson_add_null_to_object(object,name)      lite_cjson_add_item_to_object(object, name, lite_cjson_create_null())
+#define lite_cjson_add_true_to_object(object,name)      lite_cjson_add_item_to_object(object, name, lite_cjson_create_true())
+#define lite_cjson_add_false_to_object(object,name)     lite_cjson_add_item_to_object(object, name, lite_cjson_create_false())
+#define lite_cjson_add_bool_to_object(object,name,b)        lite_cjson_add_item_to_object(object, name, lite_cjson_create_bool(b))
+#define lite_cjson_add_number_to_object(object,name,n)      lite_cjson_add_item_to_object(object, name, lite_cjson_create_number(n))
+#define lite_cjson_add_string_to_object(object,name,s)      lite_cjson_add_item_to_object(object, name, lite_cjson_create_string(s))
+
+
+#endif