Merge branch 'master' of http://172.17.3.10:17001/chenweican/k-sdk

application/kcloud/kcloud_config.h

@@ -4,7 +4,7 @@
 
 #define ADDRESS     "tcp://172.25.240.31:1983"
 #define CLIENTID    "1234"
-#define TOPIC       "/sys/a1OYuSBt23u/aIqEbWno8yDdsjCX15iq/#"
+#define TOPIC       "/sys/a1OYuSBt23u/aIqEbWno8yDdsjCX15iq/thing/service/property/set"
 
 #define PAYLOAD     "Hello cwc World!"
 #define QOS         2

application/kcloud/kcloud_data_handle.c

@@ -5,54 +5,60 @@
 #include "com_api.h"
 #include "cJSON.h"
 
-static char * _kk_data_create(const char *topic,const char *data)
-{
-	cJSON *root;
-	char *out;
-	root=cJSON_CreateObject();
-	cJSON_AddStringToObject(root,"topic",topic);
-	cJSON_AddStringToObject(root,"payload",data);
-	out=cJSON_Print(root);	
-	cJSON_Delete(root);	
-	printf("[%s][%d]%s\n",__FUNCTION__,__LINE__,out);	
-	return out;
-	//free(out);	/* Print to text, Delete the cJSON, print it, release the string. */
-	
-}
-void KK_Sendto_CloudData(void *data,int len)
+#define KK_FILTER_ADD_TOPIC 		           "/thing/topo/add"
+#define KK_FILTER_ADD_TOPIC_REPLY              "/thing/topo/add_reply"
+#define KK_FILTER_DELETE_TOPIC                 "/thing/topo/delete"
+#define KK_FILTER_DELETE_TOPIC_REPLY           "/thing/topo/delete_reply"
+#define KK_FILTER_REGISTER_TOPIC               "/thing/sub/register"
+#define KK_FILTER_REGISTER_TOPIC_REPLY         "/thing/sub/register_reply"
+#define KK_FILTER_LOGIN_TOPIC                  "/thing/combine/login"
+#define KK_FILTER_LOGIN_TOPIC_REPLY            "/thing/combine/login_reply"
+#define KK_FILTER_SET_TOPIC                  "/thing/service/property/set"
+#define KK_FILTER_SET_TOPIC_REPLY            "/thing/service/property/set_reply"
+#define KK_FILTER_EVENT_POST_TOPIC            "/thing/event/property/post"
+#define KK_FILTER_EVENT_POST_REPLY            "/thing/event/property/post_reply"
+
+
+int _kk_sendto_cloud(cJSON *root)
 {
-	cJSON *root,*pTopic,*pData;
+	cJSON *pTopic,*pData;
 	char *topic = NULL;
 	char *payload = NULL;
-	root=cJSON_Parse((char*)data);
-	if(root == NULL)
-	{
-		return;
-	}
+
 	pTopic = cJSON_GetObjectItem(root, "topic");
-	if(pTopic == NULL)
-	{
+	if(pTopic == NULL){
 		return;
 	}
 	pData = cJSON_GetObjectItem(root, "payload");
-	if(pData == NULL)
-	{
+	if(pData == NULL){
 		return;
 	}
 	printf("[%s][%d] topic:%s\n",__FUNCTION__,__LINE__,pTopic->valuestring);
 	printf("[%s][%d] payload:%s\n",__FUNCTION__,__LINE__,pData->valuestring);	
-	KK_MQTT_SendMsg(pTopic->valuestring,(const char*)pData->valuestring);
+	KK_MQTT_SendMsg(pTopic->valuestring,(const char*)pData->valuestring);	
 }
-#define KK_FILTER_ADD_TOPIC 		           "/thing/topo/add"
-#define KK_FILTER_ADD_TOPIC_REPLY              "/thing/topo/add_reply"
-#define KK_FILTER_DELETE_TOPIC                 "/thing/topo/delete"
-#define KK_FILTER_DELETE_TOPIC_REPLY           "/thing/topo/delete_reply"
-#define KK_FILTER_REGISTER_TOPIC               "/thing/sub/register"
-#define KK_FILTER_REGISTER_TOPIC_REPLY         "/thing/sub/register_reply"
-#define KK_FILTER_LOGIN_TOPIC                  "/thing/combine/login"
-#define KK_FILTER_LOGIN_TOPIC_REPLY            "/thing/combine/login_reply"
 
-static int _check_invalid_topic(char* topic)
+void KK_Data_FromDev(void* str,int len)
+{
+	cJSON *root,*cmd;
+	if(str == NULL){
+		return;
+	}
+	root=cJSON_Parse((char*)str);
+	if(root == NULL){
+		return;
+	}
+	cmd = cJSON_GetObjectItem(root, "cmd");
+	if(cmd == NULL){
+		_kk_sendto_cloud(root);
+	}
+	else{
+		KK_Subdev_Subscribe(root);
+	}
+	cJSON_Delete(root);
+
+}
+static int _check_invalid_topic(const char* topic)
 {
 	if(strstr(topic, KK_FILTER_ADD_TOPIC) != NULL && \
 		strstr(topic,KK_FILTER_ADD_TOPIC_REPLY) == NULL){
@@ -70,8 +76,29 @@ static int _check_invalid_topic(char* topic)
 		strstr(topic,KK_FILTER_LOGIN_TOPIC_REPLY) == NULL){
 		return 1;
 	}	
+		else if(strstr(topic, KK_FILTER_SET_TOPIC_REPLY) != NULL){
+		return 1;
+	}		
+	else if(strstr(topic, KK_FILTER_EVENT_POST_TOPIC) != NULL && \
+		strstr(topic,KK_FILTER_LOGIN_TOPIC_REPLY) == NULL){
+		return 1;
+	}
 	return 0;
 }
+static char * _kk_data_create(const char *topic,const char *data)
+{
+	cJSON *root;
+	char *out;
+	root=cJSON_CreateObject();
+	cJSON_AddStringToObject(root,"topic",topic);
+	cJSON_AddStringToObject(root,"payload",data);
+	out=cJSON_Print(root);	
+	cJSON_Delete(root);	
+	printf("[%s][%d]%s\n",__FUNCTION__,__LINE__,out);	
+	return out;
+	//free(out);	/* Print to text, Delete the cJSON, print it, release the string. */
+}
+
 void KK_Sendto_DevData(const char *topic,const char *data)
 {
 	if(_check_invalid_topic(topic))

application/kcloud/kcloud_main.c

@@ -67,7 +67,7 @@ int main(int argc, char* argv[])
 	/*set the callback to get the device date to cloud*/
 	HAL_SetProduct_Type(PRODUCT_TPYE);
 	HAL_SetProduct_Code(PRODUCT_CODE);	
-	kk_ipc_init(IPC_APP2MID,KK_Sendto_CloudData);
+	kk_ipc_init(IPC_APP2MID,KK_Data_FromDev);
 	rc = mqtt_start();
 
 	return rc;

application/kcloud/kk_topic_mng.c

@@ -3,11 +3,46 @@
 #include <stdlib.h>
 #include <string.h>
 #include "kk_product.h"
+#include "cJSON.h"
 
 const char KK_URI_SYS_PREFIX[] = "/sys/%s/%s/#";
 
+int KK_Subdev_Subscribe(const cJSON *root)
+{
+	int res = 0;		
+	cJSON *productType = NULL;
+	cJSON *productCode = NULL;
+	cJSON *data	= NULL;
+	cJSON *cmd = NULL;	
+    int url_len = 0;	
+	
+	data = cJSON_GetObjectItem(root, "data");
+	if(data == NULL){
+		return -1;
+	}
+	productType = cJSON_GetObjectItem(data,"productType");
+	if(productType == NULL){
+		return -1;
+	}
+	productCode = cJSON_GetObjectItem(data,"productCode");
+	if(productCode == NULL){
+		return -1;
+	}	
+    url_len = strlen(KK_URI_SYS_PREFIX) + strlen(productType->valuestring) + strlen(productCode->valuestring) + 1;
+    char  *url = malloc(url_len);
+    if (url == NULL) {
+        return -1;
+    }
+    memset(url, 0, url_len);
+    snprintf(url, url_len, KK_URI_SYS_PREFIX, productType->valuestring, productCode->valuestring);
+    printf("[%s][%d] URL:%s\n",__FUNCTION__,__LINE__,url);
+    res = KK_MQTT_SubTopic(url);
+    free(url);
+	return res;
+
+}
 
-int _kk_client_subscribe(char productType[PRODUCT_TYPE_LEN], char productCode[PRODUCT_CODE_LEN])
+static int _kk_client_subscribe(char productType[PRODUCT_TYPE_LEN], char productCode[PRODUCT_CODE_LEN])
 {
     int res = 0, index = 0, fail_count = 0;
 
@@ -26,7 +61,7 @@ int _kk_client_subscribe(char productType[PRODUCT_TYPE_LEN], char productCode[PR
     res = KK_MQTT_SubTopic(url);
 
     free(url);
-    return 0;
+    return res;
 }
 
 int KK_Client_Gateway_Subscribe(void)

application/kcloud/mqtt_api.h

@@ -4,7 +4,7 @@
 #include "kcloud_log.h"
 #include "kcloud_config.h"
 
-extern void KK_Sendto_CloudData(void *data,int len);
+extern void KK_Data_FromDev(void* str,int len);
 
 extern int KK_MQTT_SubTopic(char *topicName);
 

common/api/com_api.c

@@ -3,6 +3,8 @@
 
 #define APP2MID "ipc:///tmp/app2mid.ipc"
 #define PLAT2MID "ipc:///tmp/plat2mid.ipc"
+#define MAGIC "magic12"
+
 
 typedef struct {
     int n;//nanomsg socket
@@ -14,6 +16,7 @@ typedef struct {
     struct ev_io watcher;
     ipc_cb* cb;
     ipc_type type;
+    int isconnect;
 }Bloop_ctrl_t;
 
 Bloop_ctrl_t Bloop_ctrl;
@@ -37,6 +40,16 @@ static void watcher_cb (struct ev_loop *loop ,struct ev_io *w, int revents)
         return;
     }
     printf("watcher_cb:%s recived\r\n\r\n", (char *)dat);
+    //for test ipc connect or not
+    if (loop_ctrl->isconnect == 0 ){
+        loop_ctrl->isconnect =1;
+        if (strncmp(dat,MAGIC, strlen(MAGIC)) == 0){
+            kk_ipc_send(loop_ctrl->type, dat, bytes);
+            nn_freemsg(dat);
+            return;
+        }
+    }
+    
 	if (loop_ctrl->cb != NULL){
 		loop_ctrl->cb((void *)dat, bytes);
 	}
@@ -202,3 +215,28 @@ int kk_ipc_send(ipc_type type, void* data, int len)
 	return 0;
 
 }
+
+int kk_ipc_isconnect(ipc_type type){
+    Bloop_ctrl_t* loop_ctrl;
+    
+    if (IPC_MID2PLAT == type){
+         loop_ctrl = &Mloop_ctrl;
+    }else {
+         loop_ctrl = &Bloop_ctrl;
+    }
+
+    if (loop_ctrl->isconnect == 1){
+        return 1;
+    }else{
+        
+        for(int i =0; i<20;i++){
+            kk_ipc_send(type, MAGIC, strlen(MAGIC)+1);
+            usleep(500000);
+            if (loop_ctrl->isconnect == 1){
+                break;
+            }
+        }
+        return loop_ctrl->isconnect;
+    }
+}
+

midware/midware/dm/iotx_dm.h

@@ -137,19 +137,6 @@ typedef struct {
     iotx_dm_event_callback event_callback;
 } iotx_dm_init_params_t;
 
-typedef enum {
-    IOTX_DM_DEV_AVAIL_ENABLE,
-    IOTX_DM_DEV_AVAIL_DISABLE
-} iotx_dm_dev_avail_t;
-
-typedef enum {
-    IOTX_DM_DEV_STATUS_UNAUTHORIZED,   /* Subdev Created */
-    IOTX_DM_DEV_STATUS_AUTHORIZED,     /* Receive Topo Add Notify */
-    IOTX_DM_DEV_STATUS_REGISTERED,     /* Receive Subdev Registered */
-    IOTX_DM_DEV_STATUS_ATTACHED,       /* Receive Subdev Topo Add Reply */
-    IOTX_DM_DEV_STATUS_LOGINED,        /* Receive Subdev Login Reply */
-    IOTX_DM_DEV_STATUS_ONLINE          /* After All Topic Subscribed */
-} iotx_dm_dev_status_t;
 
 typedef enum {
     DM_TSL_SERVICE_GET_FAILED = -13,
@@ -183,7 +170,6 @@ int iotx_dm_get_opt(int opt, void *data);
 #ifdef LOG_REPORT_TO_CLOUD
     int iotx_dm_log_post(_IN_ int devid, _IN_ char *payload, _IN_ int payload_len);
 #endif
-int iotx_dm_post_property(_IN_ int devid, _IN_ char *payload, _IN_ int payload_len);
 int iotx_dm_property_desired_get(_IN_ int devid, _IN_ char *payload, _IN_ int payload_len);
 int iotx_dm_property_desired_delete(_IN_ int devid, _IN_ char *payload, _IN_ int payload_len);
 int iotx_dm_post_event(_IN_ int devid, _IN_ char *identifier, _IN_ int identifier_len, _IN_ char *payload,

midware/midware/dm/kk_dm_api.c

@@ -7,7 +7,7 @@
 #include "kk_dm_api.h"
 #include "kk_tsl_common.h"
 #include "kk_dm_mng.h"
-
+#include "com_api.h"
 
 static dm_api_ctx_t g_dm_api_ctx;
 
@@ -32,52 +32,6 @@ static void _dm_api_unlock(void)
     }
 }
 
-
-int iotx_dm_post_property(_IN_ int devid, _IN_ char *payload, _IN_ int payload_len)
-{
-    int res = 0;
-
-    _dm_api_lock();
-
-    res = dm_mgr_upstream_thing_property_post(devid, payload, payload_len);
-    if (res < SUCCESS_RETURN) {
-        _dm_api_unlock();
-        return FAIL_RETURN;
-    }
-
-    _dm_api_unlock();
-    return res;
-}
-
-
-int iotx_dm_subdev_create(_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;
-
-    if (product_key == NULL || device_name == NULL ||
-        (strlen(product_key) >= PRODUCT_KEY_MAXLEN) ||
-        (strlen(device_name) >= DEVICE_NAME_MAXLEN) ||
-        devid == NULL) {
-        return INVALID_PARAMETER;
-    }
-
-    if (device_secret != NULL && strlen(device_secret) >= DEVICE_SECRET_MAXLEN) {
-        return INVALID_PARAMETER;
-    }
-
-    _dm_api_lock();
-    res = dm_mgr_device_create(IOTX_DM_DEVICE_SUBDEV, product_key, device_name, device_secret, devid);
-    if (res != SUCCESS_RETURN) {
-        _dm_api_unlock();
-        return FAIL_RETURN;
-    }
-    _dm_api_unlock();
-    return SUCCESS_RETURN;
-}
-
-
 int kk_dm_subdev_register(_IN_ int devid)
 {
     int res = 0;
@@ -244,4 +198,47 @@ int iotx_dm_connect(_IN_ iotx_dm_event_callback cb)
     return SUCCESS_RETURN;
 }
 
+int iotx_dm_subscribe(_IN_ int devid)
+{
+    int res = 0, dev_type = 0;
+    char product_key[PRODUCT_KEY_MAXLEN] = {0};
+    char device_name[DEVICE_NAME_MAXLEN] = {0};
+    char device_secret[DEVICE_SECRET_MAXLEN] = {0};
+
+    if (devid < 0) {
+        return INVALID_PARAMETER;
+    }
+
+    dm_mgr_dev_node_t *node = NULL;
+    _dm_api_lock();
+    res = dm_mgr_search_dev_by_devid(devid, &node);
+    if (res != SUCCESS_RETURN) {
+        _dm_api_unlock();
+        return FAIL_RETURN;
+    }
+    _dm_api_unlock();
+    
+    //send app to subscribe mqtt
+    const char subscribe_cmd[]  =
+            "{\"cmd\":\"subscribe\",\"data\":{\"productType\":\"%s\",\"productCode\":\"%s\"}}";
+    int len = strlen(subscribe_cmd) + strlen(node->product_key) + strlen(node->device_name) + 1;
+    void* buf = malloc(len);
+    
+    if (buf){
+        HAL_Snprintf(buf, len, subscribe_cmd, node->product_key, node->device_name);
+        kk_ipc_send(IPC_MID2APP, buf, len);
+        free(buf);
+    }else{
+        
+        printf("\n [%d][%s] malloc faild kk_ipc_send \n", __LINE__, __FUNCTION__);
+        return FAIL_RETURN;
+    }
+    printf("\n [%d][%s] [%d] send app to subscribe mqtt  \n", __LINE__, __FUNCTION__, HAL_UptimeMs());
+
+
+   
+
+    return SUCCESS_RETURN;
+}
+
 

midware/midware/dm/kk_dm_mng.h

@@ -17,8 +17,7 @@ typedef struct {
     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;
+	char device_mac[DEVICE_MAC_MAXLEN];
     struct list_head linked_list;
 } dm_mgr_dev_node_t;
 

midware/midware/dm/kk_dm_msg.c

@@ -15,8 +15,7 @@ const char DM_URI_THING_SERVICE_RESPONSE[]			  DM_READ_ONLY = "thing/service/%.*
 const char DM_URI_THING_EVENT_PROPERTY_POST_METHOD[]  DM_READ_ONLY = "thing.event.property.post";
 
 
-
-const char DM_MSG_REQUEST[] DM_READ_ONLY = "{\"id\":\"%d\",\"version\":\"%s\",\"params\":%.*s,\"method\":\"%s\"}";
+const char DM_MSG_REQUEST[] DM_READ_ONLY = "{\"msgId\":\"%d\",\"version\":\"%s\",\"params\":%.*s,\"method\":\"%s\"}";
 
 void kk_sendData2app(void *uri, void *payload){
     cJSON *root=cJSON_CreateObject();
@@ -184,6 +183,96 @@ int dm_msg_thing_topo_add(_IN_ char product_key[PRODUCT_KEY_MAXLEN],
   return SUCCESS_RETURN;
 }
 
+const char DM_MSG_THING_TOPO_DELETE_METHOD[] DM_READ_ONLY = "thing.topo.delete";
+const char DM_MSG_THING_TOPO_DELETE_PARAMS[] DM_READ_ONLY = "[{\"productKey\":\"%s\",\"deviceName\":\"%s\"}]";
+int dm_msg_thing_topo_delete(_IN_ char product_key[PRODUCT_KEY_MAXLEN],
+                             _IN_ char device_name[DEVICE_NAME_MAXLEN],
+                             _OU_ dm_msg_request_t *request)
+{
+    char *params = NULL;
+    int params_len = 0;
+
+    if (request == NULL || product_key == NULL ||
+        device_name == NULL ||
+        (strlen(product_key) >= PRODUCT_KEY_MAXLEN) ||
+        (strlen(device_name) >= DEVICE_NAME_MAXLEN) ||
+        (strlen(request->product_key) >= PRODUCT_KEY_MAXLEN) ||
+        (strlen(request->device_name) >= DEVICE_NAME_MAXLEN)) {
+        return INVALID_PARAMETER;
+    }
+
+    /* Params */
+    request->method = (char *)DM_MSG_THING_TOPO_DELETE_METHOD;
+    params_len = strlen(DM_MSG_THING_TOPO_DELETE_PARAMS) + strlen(product_key) + strlen(device_name) + 1;
+    params = malloc(params_len);
+    if (params == NULL) {
+        return MEMORY_NOT_ENOUGH;
+    }
+    memset(params, 0, params_len);
+    HAL_Snprintf(params, params_len, DM_MSG_THING_TOPO_DELETE_PARAMS, product_key, device_name);
+
+    request->params = params;
+    request->params_len = strlen(request->params);
+
+    return SUCCESS_RETURN;
+}
+
+ const char DM_MSG_THING_TOPO_GET_METHOD[] DM_READ_ONLY = "thing.topo.get";
+ const char DM_MSG_THING_TOPO_GET_PARAMS[] DM_READ_ONLY = "{}";
+ int dm_msg_thing_topo_get(_OU_ dm_msg_request_t *request)
+ {
+     char *params = NULL;
+     int params_len = 0;
+ 
+     /* Params */
+     request->method = (char *)DM_MSG_THING_TOPO_GET_METHOD;
+     params_len = strlen(DM_MSG_THING_TOPO_GET_PARAMS) + 1;
+     params = malloc(params_len);
+     if (params == NULL) {
+         return MEMORY_NOT_ENOUGH;
+     }
+     memset(params, 0, params_len);
+     memcpy(params, DM_MSG_THING_TOPO_GET_PARAMS, strlen(DM_MSG_THING_TOPO_GET_PARAMS));
+ 
+     request->params = params;
+     request->params_len = strlen(request->params);
+ 
+     return SUCCESS_RETURN;
+ }
+
+ const char DM_MSG_THING_LIST_FOUND_METHOD[] DM_READ_ONLY = "thing.list.found";
+ const char DM_MSG_THING_LIST_FOUND_PARAMS[] DM_READ_ONLY = "[{\"productKey\":\"%s\",\"deviceName\":\"%s\"}]";
+ int dm_msg_thing_list_found(_IN_ char product_key[PRODUCT_KEY_MAXLEN],
+                             _IN_ char device_name[DEVICE_NAME_MAXLEN],
+                             _OU_ dm_msg_request_t *request)
+ {
+     char *params = NULL;
+     int params_len = 0;
+ 
+     if (product_key == NULL || device_name == NULL ||
+         (strlen(product_key) >= PRODUCT_KEY_MAXLEN) ||
+         (strlen(device_name) >= DEVICE_NAME_MAXLEN) ||
+         request == NULL) {
+         return INVALID_PARAMETER;
+     }
+ 
+     /* Params */
+     request->method = (char *)DM_MSG_THING_LIST_FOUND_METHOD;
+     params_len = strlen(DM_MSG_THING_LIST_FOUND_PARAMS) + strlen(product_key) + strlen(device_name) + 1;
+     params = malloc(params_len);
+     if (params == NULL) {
+         return MEMORY_NOT_ENOUGH;
+     }
+     memset(params, 0, params_len);
+     HAL_Snprintf(params, params_len, DM_MSG_THING_LIST_FOUND_PARAMS, product_key, device_name);
+ 
+     request->params = params;
+     request->params_len = strlen(request->params);
+ 
+     return SUCCESS_RETURN;
+ }
+
+
 const char DM_MSG_COMBINE_LOGIN_SIGN_SOURCE[] DM_READ_ONLY = "clientId%sdeviceName%sproductKey%stimestamp%s";
 const char DM_MSG_COMBINE_LOGIN_METHOD[] DM_READ_ONLY = "combine.login";
 const char DM_MSG_COMBINE_LOGIN_PARAMS[] DM_READ_ONLY =
@@ -303,42 +392,7 @@ int dm_msg_combine_logout(_IN_ char product_key[PRODUCT_KEY_MAXLEN],
  
 }
 
-  const char DM_MSG_THING_TOPO_DELETE_METHOD[] DM_READ_ONLY = "thing.topo.delete";
-  const char DM_MSG_THING_TOPO_DELETE_PARAMS[] DM_READ_ONLY = "[{\"productKey\":\"%s\",\"deviceName\":\"%s\"}]";
-  int dm_msg_thing_topo_delete(_IN_ char product_key[PRODUCT_KEY_MAXLEN],
-                               _IN_ char device_name[DEVICE_NAME_MAXLEN],
-                               _OU_ dm_msg_request_t *request)
-  {
-      char *params = NULL;
-      int params_len = 0;
-  
-      if (request == NULL || product_key == NULL ||
-          device_name == NULL ||
-          (strlen(product_key) >= PRODUCT_KEY_MAXLEN) ||
-          (strlen(device_name) >= DEVICE_NAME_MAXLEN) ||
-          (strlen(request->product_key) >= PRODUCT_KEY_MAXLEN) ||
-          (strlen(request->device_name) >= DEVICE_NAME_MAXLEN)) {
-          return INVALID_PARAMETER;
-      }
-  
-      /* Params */
-      request->method = (char *)DM_MSG_THING_TOPO_DELETE_METHOD;
-      params_len = strlen(DM_MSG_THING_TOPO_DELETE_PARAMS) + strlen(product_key) + strlen(device_name) + 1;
-      params = malloc(params_len);
-      if (params == NULL) {
-          return MEMORY_NOT_ENOUGH;
-      }
-      memset(params, 0, params_len);
-      HAL_Snprintf(params, params_len, DM_MSG_THING_TOPO_DELETE_PARAMS, product_key, device_name);
-  
-      request->params = params;
-      request->params_len = strlen(request->params);
-  
-      return SUCCESS_RETURN;
-  }
-
-
-
+ 
 int dm_msg_request (_IN_ dm_msg_request_t *request)
 {
     int res = 0, payload_len = 0;
@@ -388,7 +442,7 @@ int dm_msg_request (_IN_ dm_msg_request_t *request)
 }
 
 
-const char DM_MSG_RESPONSE_WITH_DATA[] DM_READ_ONLY = "{\"id\":\"%.*s\",\"code\":%d,\"data\":%.*s}";
+const char DM_MSG_RESPONSE_WITH_DATA[] DM_READ_ONLY = "{\"msgId\":\"%.*s\",\"code\":%d,\"data\":%.*s}";
 int dm_msg_response(_IN_ kk_msg_request_payload_t *request, _IN_ kk_msg_response_t *response,
                     _IN_ char *data, _IN_ int data_len, _IN_ void *user_data)
 {
@@ -469,4 +523,74 @@ int dm_msg_response_parse(_IN_ char *payload, _IN_ int payload_len, _OU_ dm_msg_
     return SUCCESS_RETURN;
 }
 
+static int dm_msg_request_parse(_IN_ char *payload, _IN_ int payload_len, _OU_ kk_msg_request_payload_t *request)
+{
+    lite_cjson_t lite;
+
+    if (payload == NULL || payload_len <= 0 || request == NULL) {
+        return INVALID_PARAMETER;
+    }
+
+    if (lite_cjson_parse(payload, payload_len, &lite) != SUCCESS_RETURN ||
+        lite_cjson_object_item(&lite, KK_MSG_KEY_ID, strlen(KK_MSG_KEY_ID), &request->id) != SUCCESS_RETURN ||
+        lite_cjson_object_item(&lite, KK_MSG_KEY_VERSION, strlen(KK_MSG_KEY_VERSION),
+                                  &request->version) != SUCCESS_RETURN ||
+        lite_cjson_object_item(&lite, KK_MSG_KEY_METHOD, strlen(KK_MSG_KEY_METHOD),
+                                  &request->method) != SUCCESS_RETURN ||
+        lite_cjson_object_item(&lite, KK_MSG_KEY_PARAMS, strlen(KK_MSG_KEY_PARAMS),
+                                  &request->params) != SUCCESS_RETURN) {
+        return FAIL_RETURN;
+    }
+
+    printf("Current Request Message ID: %.*s", request->id.value_length, request->id.value);
+    printf("Current Request Message Version: %.*s", request->version.value_length, request->version.value);
+    printf("Current Request Message Method: %.*s", request->method.value_length, request->method.value);
+    printf("Current Request Message Params: %.*s", request->params.value_length, request->params.value);
+
+    return SUCCESS_RETURN;
+}
+
+
+int dm_msg_thing_property_set_reply(const char *topic, const char *payload, unsigned int payload_len,
+        void *context){
+        
+    kk_msg_request_payload_t request;
+    kk_msg_response_t response;
+
+    int res = 0, devid = 0;
+    char product_key[PRODUCT_KEY_MAXLEN] = {0};
+    char device_name[DEVICE_NAME_MAXLEN] = {0};
+
+    memset(&request, 0, sizeof(kk_msg_request_payload_t));
+    memset(&response, 0, sizeof(kk_msg_response_t));
+
+
+	/**************to do*******************/	
+
+    //dm_log_info(DM_URI_THING_SERVICE_PROPERTY_SET);
+
+    /* Request */
+    /* Request */
+    res =kk_msg_uri_parse_pkdn((char *)topic, strlen(topic), 2 + KK_URI_OFFSET, 4 + KK_URI_OFFSET, product_key,
+                                device_name);
+
+
+    res = dm_mgr_search_device_by_pkdn(product_key, device_name, &devid);
+    if (res < SUCCESS_RETURN) {
+        return res;
+    }
+    res = dm_msg_request_parse((char *)payload, payload_len, &request);
+    if (res < SUCCESS_RETURN) {
+        return res ;
+    }
+
+    /* Response */
+    response.service_prefix = DM_URI_SYS_PREFIX;
+    response.service_name = DM_URI_THING_SERVICE_PROPERTY_SET_REPLY;
+    memcpy(response.product_key, product_key, strlen(product_key));
+    memcpy(response.device_name, device_name, strlen(device_name));
+    response.code = (res == SUCCESS_RETURN) ? (IOTX_DM_ERR_CODE_SUCCESS) : (IOTX_DM_ERR_CODE_REQUEST_ERROR);
+	dm_msg_response(&request, &response, "{}", strlen("{}"), NULL);
+}
+
 

midware/midware/dm/kk_dm_msg.h

 #ifndef __KK_DM_MSG__
 #define __KK_DM_MSG__
 #include "kk_tsl_common.h"
+
 #include "../tsl_handle/lite-cjson.h"
 
 
@@ -26,53 +27,6 @@
 #define DM_MSG_SIGN_METHOD_HMACSHA256   "hmacSha256"
 
 
-/*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;*/
-
 typedef struct {
     lite_cjson_t id;
     lite_cjson_t code;
@@ -92,6 +46,7 @@ const char DM_URI_THING_SERVICE_PROPERTY_SET_REPLY[]  DM_READ_ONLY;
 const char DM_URI_THING_EVENT_POST[]				  DM_READ_ONLY;
 const char DM_URI_THING_SERVICE_RESPONSE[]			  DM_READ_ONLY;
 const char DM_URI_THING_EVENT_PROPERTY_POST_METHOD[]  DM_READ_ONLY;
+//const char DM_URI_SYS_PREFIX[]                        DM_READ_ONLY = "/sys/%s/%s/";
 
 
 #endif

midware/midware/dm/kk_dm_queue.c

@@ -23,6 +23,15 @@ static void _dm_queue_lock(void)
     }
 }
 
+static void _dm_queue_lock2(void)
+{
+    dm_queue_t *ctx = _dm_queue_get_ctx();
+    if (ctx->mutex2) {
+        HAL_MutexLock(ctx->mutex2);
+    }
+}
+
+
 static void _dm_queue_unlock(void)
 {
     dm_queue_t *ctx = _dm_queue_get_ctx();
@@ -30,6 +39,14 @@ static void _dm_queue_unlock(void)
         HAL_MutexUnlock(ctx->mutex);
     }
 }
+static void _dm_queue_unlock2(void)
+{
+    dm_queue_t *ctx = _dm_queue_get_ctx();
+    if (ctx->mutex2) {
+        HAL_MutexUnlock(ctx->mutex2);
+    }
+}
+
 
 int dm_queue_init(int max_size)
 {
@@ -43,9 +60,17 @@ int dm_queue_init(int max_size)
         return INVALID_PARAMETER;
     }
 
+    /* Create Mutex */
+    ctx->mutex2 = HAL_MutexCreate();
+    if (ctx->mutex2 == NULL) {
+        return INVALID_PARAMETER;
+    }
+
     /* Init List */
     ctx->msg_list.max_size = max_size;
     INIT_LIST_HEAD(&ctx->msg_list.message_list);
+    ctx->msg_list2.max_size = max_size;
+    INIT_LIST_HEAD(&ctx->msg_list2.message_list);
 
     return SUCCESS_RETURN;
 }
@@ -61,6 +86,10 @@ void dm_queue_deinit(void)
         HAL_MutexDestroy(ctx->mutex);
     }
 
+    if (ctx->mutex2) {
+        HAL_MutexDestroy(ctx->mutex2);
+    }
+
     list_for_each_entry_safe(del_node, next_node, &ctx->msg_list.message_list, linked_list, dm_queue_msg_node_t) {
         /* Free Message */
         del_msg = (dm_queue_msg_t *)del_node->data;
@@ -74,6 +103,25 @@ void dm_queue_deinit(void)
         list_del(&del_node->linked_list);
         free(del_node);
     }
+
+    del_node = NULL;
+    next_node = NULL;
+    del_msg = NULL;
+    list_for_each_entry_safe(del_node, next_node, &ctx->msg_list2.message_list, linked_list, dm_queue_msg_node_t) {
+        /* Free Message */
+        del_msg = (dm_queue_msg_t *)del_node->data;
+        if (del_msg->data) {
+            free(del_msg->data);
+        }
+        free(del_msg);
+        del_msg = NULL;
+
+        /* Free Node */
+        list_del(&del_node->linked_list);
+        free(del_node);
+    }
+
+
 }
 
 int dm_queue_msg_insert(void *data)
@@ -136,3 +184,64 @@ int dm_queue_msg_next(void **data)
     return SUCCESS_RETURN;
 }
 
+int dm_queue_msg_insert2(void *data)
+{
+    dm_queue_t *ctx = _dm_queue_get_ctx();
+    dm_queue_msg_node_t *node = NULL;
+
+    if (data == NULL) {
+        return INVALID_PARAMETER;
+    }
+
+    _dm_queue_lock2();
+    printf("dm msg list size: %d, max size: %d", ctx->msg_list2.size, ctx->msg_list2.max_size);
+    if (ctx->msg_list2.size >= ctx->msg_list2.max_size) {
+        printf("dm queue list full");
+        _dm_queue_unlock2();
+        return FAIL_RETURN;
+    }
+
+    node = malloc(sizeof(dm_queue_msg_node_t));
+    if (node == NULL) {
+        _dm_queue_unlock2();
+        return MEMORY_NOT_ENOUGH;
+    }
+    memset(node, 0, sizeof(dm_queue_msg_node_t));
+
+    node->data = data;
+    INIT_LIST_HEAD(&node->linked_list);
+    ctx->msg_list2.size++;
+    list_add_tail(&node->linked_list, &ctx->msg_list2.message_list);
+
+    _dm_queue_unlock2();
+    return SUCCESS_RETURN;
+}
+
+int dm_queue_msg_next2(void **data)
+{
+    dm_queue_t *ctx = _dm_queue_get_ctx();
+    dm_queue_msg_node_t *node = NULL;
+
+    if (data == NULL || *data != NULL) {
+        return INVALID_PARAMETER;
+    }
+
+    _dm_queue_lock2();
+
+    if (list_empty(&ctx->msg_list2.message_list)) {
+        _dm_queue_unlock2();
+        return FAIL_RETURN;
+    }
+
+    node = list_first_entry(&ctx->msg_list2.message_list, dm_queue_msg_node_t, linked_list);
+    list_del(&node->linked_list);
+    ctx->msg_list2.size--;
+
+    *data = node->data;
+    free(node);
+
+    _dm_queue_unlock2();
+    return SUCCESS_RETURN;
+}
+
+

midware/midware/dm/kk_dm_queue.h

@@ -28,7 +28,9 @@ typedef struct {
 
 typedef struct {
     void *mutex;
+    void *mutex2;
     dm_queue_msg_list_t msg_list;
+    dm_queue_msg_list_t msg_list2;
 } dm_queue_t;
 
 int dm_queue_init(int max_size);

midware/midware/dm/kk_linkkit.c

@@ -238,56 +238,58 @@ static void _iotx_linkkit_event_callback(iotx_dm_event_types_t type, char *data)
         topic = cJSON_GetObjectItem(json, "topic");
         payload = cJSON_GetObjectItem(json, "payload");
 
-    
-        printf("_iotx_linkkit_event_callback topic: [%s] ,payload= %s  \n",topic->valuestring,payload->valuestring );
-        if (strcmp(payload->valuestring, "addsub")==0){
-            kk_mid_subdev_add("a1OYuSallan","allanWno8yDdsjCX15iq","");
-        }else{
-            printf("rrr topic: [%s] ,payload= %s  \n",topic->valuestring,payload->valuestring );
-            if (strpbrk(payload->valuestring, "register_reply") != NULL){
-                //====todo======
-                //get devicececret and save it
-                dm_msg_response_payload_t response;
-                res = dm_msg_response_parse((char *)payload->valuestring, strlen(payload->valuestring)+1, &response);
-                if (res != SUCCESS_RETURN) {
-                    return FAIL_RETURN;
-                }
-                  
-                _iotx_linkkit_upstream_mutex_lock();
-                _iotx_linkkit_upstream_callback_remove(atoi(response.id.value), response.code.value_int);
-                _iotx_linkkit_upstream_mutex_unlock();
-
-           }else if (strpbrk(topic, "add_reply") != NULL){
-                //====todo======
-                //
-                dm_msg_response_payload_t response;
-                res = dm_msg_response_parse((char *)payload->valuestring, strlen(payload->valuestring)+1, &response);
-                if (res != SUCCESS_RETURN) {
-                    return FAIL_RETURN;
-                }
-                  
-                _iotx_linkkit_upstream_mutex_lock();
-                _iotx_linkkit_upstream_callback_remove(atoi(response.id.value), response.code.value_int);
-                _iotx_linkkit_upstream_mutex_unlock();
-                
-           }else if (strpbrk(topic, "login_reply") != NULL){
-                //====todo======
-                //
-                dm_msg_response_payload_t response;
-                res = dm_msg_response_parse((char *)payload->valuestring, strlen(payload->valuestring)+1, &response);
-                if (res != SUCCESS_RETURN) {
-                    return FAIL_RETURN;
-                }
-                  
-                _iotx_linkkit_upstream_mutex_lock();
-                _iotx_linkkit_upstream_callback_remove(atoi(response.id.value), response.code.value_int);
-                _iotx_linkkit_upstream_mutex_unlock();
-           }else{
-                printf("Error 222222222222222 \n");
-                //kk_tsl_service_property_set(topic->valuestring, payload->valuestring, strlen(payload->valuestring), NULL);
-           }
-           
+        printf("topic: [%s] ,payload= %s  \n",topic->valuestring,payload->valuestring );
+        if (strstr(topic->valuestring, "register_reply") != NULL){
+            //====todo======
+            //get devicececret and save it
+            printf(" topic:register_reply  \n");
+            dm_msg_response_payload_t response;
+            res = dm_msg_response_parse((char *)payload->valuestring, strlen(payload->valuestring)+1, &response);
+            if (res != SUCCESS_RETURN) {
+                return FAIL_RETURN;
+            }
+              
+            _iotx_linkkit_upstream_mutex_lock();
+            _iotx_linkkit_upstream_callback_remove(atoi(response.id.value), response.code.value_int);
+            _iotx_linkkit_upstream_mutex_unlock();
+
+       }else if (strstr(topic->valuestring, "add_reply") != NULL){
+            //====todo======
+            //
+            printf(" topic:add_reply  \n");
+            dm_msg_response_payload_t response;
+            res = dm_msg_response_parse((char *)payload->valuestring, strlen(payload->valuestring)+1, &response);
+            if (res != SUCCESS_RETURN) {
+                return FAIL_RETURN;
+            }
+              
+            _iotx_linkkit_upstream_mutex_lock();
+            _iotx_linkkit_upstream_callback_remove(atoi(response.id.value), response.code.value_int);
+            _iotx_linkkit_upstream_mutex_unlock();
+            
+       }else if (strstr(topic->valuestring, "login_reply") != NULL){
+            //====todo======
+            //
+            printf(" topic:login_reply  \n");
+            dm_msg_response_payload_t response;
+            res = dm_msg_response_parse((char *)payload->valuestring, strlen(payload->valuestring)+1, &response);
+            if (res != SUCCESS_RETURN) {
+                return FAIL_RETURN;
+            }
+              
+            _iotx_linkkit_upstream_mutex_lock();
+            _iotx_linkkit_upstream_callback_remove(atoi(response.id.value), response.code.value_int);
+            _iotx_linkkit_upstream_mutex_unlock();
+       }else if (strstr(topic->valuestring, "thing/service/property/set") != NULL){
+            printf("property set reply \n");
+            dm_msg_thing_property_set_reply(topic->valuestring, payload->valuestring, strlen(payload->valuestring), NULL);
+            //kk_tsl_service_property_set(topic->valuestring, payload->valuestring, strlen(payload->valuestring), NULL);
+       }else{
+            printf("Error 222222222222222 \n");
+            
        }
+
+       cJSON_Delete(json);
             
     }
 #if 0
@@ -1442,20 +1444,13 @@ static int _iotx_linkkit_subdev_login(int devid)
     }
     _iotx_linkkit_upstream_mutex_unlock();
 
-    //send app to subscribe mqtt
-    const char subscribe_cmd[]  =
-            "{\"cmd\":\"subscribe\",\"productKey\":\"%s\",\"deviceName\":\"%s\",\"clientId\":\"%s\",\"timestamp\":\"%s\",\"signMethod\":\"%s\",\"sign\":\"%s\",\"cleanSession\":\"%s\"}";
-
-    kk_ipc_send(IPC_MID2APP, subscribe_cmd, strlen(subscribe_cmd) + 1);
-    printf("\n [%d][%s] [%d] allan kk_ipc_send \n", __LINE__, __FUNCTION__, HAL_UptimeMs());
-    
-
-    /*res = iotx_dm_subscribe(devid);
+     
+    res = iotx_dm_subscribe(devid);
     if (res != SUCCESS_RETURN) {
         return FAIL_RETURN;
     }
 
-    iotx_dm_send_aos_active(devid);
+    /*iotx_dm_send_aos_active(devid);
     callback = iotx_event_callback(ITE_INITIALIZE_COMPLETED);
     if (callback) {
         ((int (*)(const int))callback)(devid);
@@ -1745,10 +1740,10 @@ int iot_linkkit_subdev_query_id(char product_key[IOTX_PRODUCT_KEY_LEN + 1], char
 #endif /* #ifdef DEVICE_MODEL_GATEWAY */
 
 
-int kk_mid_subdev_add(char product_key[PRODUCT_KEY_MAXLEN], char device_name[DEVICE_NAME_MAXLEN], char device_secret[DEVICE_SECRET_MAXLEN]){
+int kk_mid_subdev_add(char product_key[PRODUCT_KEY_MAXLEN], char device_name[DEVICE_NAME_MAXLEN], char device_secret[DEVICE_SECRET_MAXLEN],char device_mac[DEVICE_MAC_MAXLEN]){
     int res = 0;
     int devid = 0;
-    res = dm_mgr_subdev_create(product_key,device_name,device_secret,&devid);
+    res = dm_mgr_subdev_create(product_key,device_name,device_secret,device_mac,&devid);
 	if (res != SUCCESS_RETURN) {
         printf("subdev create Failed\n");
         return FAIL_RETURN;

midware/midware/dm/kk_wlist_mng.h

+#ifndef __KK_WHITELIST_MNG_H__
+#define __KK_WHITELIST_MNG_H__
+#include "kk_tsl_common.h"
+
+typedef struct {
+    char device_mac[DEVICE_MAC_MAXLEN];
+	char product_id[PRODUCT_KEY_MAXLEN];
+	char device_sn[DEVICE_SN_MAXLEN];
+	char device_id[DEVICE_NAME_MAXLEN];
+	int index;
+} kk_wlist_dev_t;
+int kk_wlist_init(void);
+int kk_wlist_status_open(int isOpen);
+int kk_add_wlist(kk_wlist_dev_t *wlist_dev);
+int kk_get_wlist_num(void);
+int kk_delete_wlist_byMac(const char* device_mac);
+#endif
\ No newline at end of file

midware/midware/iot.mk

@@ -7,6 +7,7 @@ $(call Append_Conditional, TARGET, midware)
 CFLAGS 			+= -I$(TOP_DIR)/common/nanomsg/include
 CFLAGS 			+= -I$(TOP_DIR)/common/ev/include
 CFLAGS 			+= -I$(TOP_DIR)/common/api
+CFLAGS 			+= -I$(TOP_DIR)/common/sqlite
 CFLAGS 			+= -I$(TOP_DIR)/src/tsl/tsl_handle
 LDFLAGS         += -lapi_com -liot_cjson -lkk_tsl
 LDFLAGS         += -lsqlite -ldl -lm

midware/midware/midware.c

@@ -14,6 +14,7 @@
 #include "cJSON.h"
 #include "kk_product.h"
 #include "kk_tsl_common.h"
+#include "kk_dm_api.h"
 
 
 
@@ -21,6 +22,7 @@ void mid_cb(void* data, int len){
 	if (data != NULL){
 		printf("app2mid_cb: %s RECEIVED \r\n", data); 
         char *out;cJSON *json, *topic, *payload;
+        int res;
 
     	json=cJSON_Parse(data);
     	if (!json) {
@@ -32,31 +34,122 @@ void mid_cb(void* data, int len){
             payload = cJSON_GetObjectItem(json, "payload");
             printf("mid_cb topic: [%s] ,payload= %s  \n",topic->valuestring,payload->valuestring );
             if (strcmp(payload->valuestring, "addsub")==0){
-                kk_mid_subdev_add("a1OYuSallan","allanWno8yDdsjCX15iq","");
+                //kk_mid_subdev_add("a1OYuSallan","allanWno8yDdsjCX15iq","");
             }else{
                 void* buf = malloc(len);
                 memcpy(buf, data, len);
                 int res = dm_queue_msg_insert((void *)buf);
                 if (res != SUCCESS_RETURN) {
                     free(buf);
-                    return FAIL_RETURN;
+                    //return FAIL_RETURN;
                 }
             
                 //kk_tsl_service_property_set(topic->valuestring, payload->valuestring, strlen(payload->valuestring), NULL);
             }
+            char mac[DEVICE_MAC_MAXLEN];
+            res =dm_mgr_search_mac_by_topic(topic->valuestring, mac);
+            if (res != SUCCESS_RETURN) {
+                return;
+            }
+            printf("dm_mgr_search_mac_by_topic mac: %s  \r\n", mac);
+            
+            cJSON * jsonplay=cJSON_Parse(payload->valuestring);
+            cJSON_AddStringToObject(jsonplay, "mac", mac);
+            void* out =  cJSON_Print(jsonplay);
+            kk_ipc_send(IPC_MID2PLAT, out, strlen(out));
+            free(out);
+            cJSON_Delete(jsonplay);
+            cJSON_Delete(json);
             
 	    }
-        kk_ipc_send(IPC_MID2PLAT, data, len);
+	    
+        
 	}
 }
 
 void mid2p_cb(void* data, int len){
 	if (data != NULL){
-		printf("mid2p_cb: %s RECEIVED \r\n", data); 
-        kk_ipc_send(IPC_MID2APP, data, len);
+		printf("mid2plat_cb: %s RECEIVED \r\n", data);
+		void* buf = malloc(len);
+        memcpy(buf, data, len);
+        int res = dm_queue_msg_insert2((void *)buf);
+        if (res != SUCCESS_RETURN) {
+            free(buf);
+            return ;
+        }
+		
+        //kk_ipc_send(IPC_MID2APP, data, len);
 	}
 }
 
+void kk_platMsg_handle(void* data){
+    
+    char *out;
+    int res = 0;
+    cJSON *json, *method, *params;
+    
+    json=cJSON_Parse(data);
+	if (!json) {
+        printf("Error before: [%s]\n","cJSON_Parse");
+    }
+	else{
+        method = cJSON_GetObjectItem(json, "method");
+        if (method != NULL && strcmp(method->valuestring, "thing.topo.add")==0){
+                cJSON *jsonPay, *proType, *proCode, *mac;
+                params = cJSON_GetObjectItem(json, "params");
+                jsonPay =cJSON_Parse(params->valuestring);
+                
+                if (!jsonPay) {
+                    printf("Error before: [%s]\n","cJSON_Parse");
+                }else{
+                    proType = cJSON_GetObjectItem(jsonPay, "productType");
+                    proCode = cJSON_GetObjectItem(jsonPay, "productCode");
+                    mac = cJSON_GetObjectItem(jsonPay, "mac");
+                    printf("productType productCode : [%s][%s]\n",proType, proCode);
+                    kk_set_tsl_by_productKey(proCode->valuestring,"model.json");
+                    kk_mid_subdev_add(proType->valuestring,proCode->valuestring,"", mac->valuestring);
+                    cJSON_Delete(jsonPay);
+                }
+                
+        }else if (method != NULL && strcmp(method->valuestring, "thing.event.property.post")==0){
+            cJSON *mac;
+            mac = cJSON_GetObjectItem(json, "mac");
+            
+            
+            //kk_tsl_service_property_set(topic->valuestring, data, strlen(data), NULL);
+            
+        }else{
+            printf("kk_platMsg_handle data: [%s]\n",data);
+        
+            //kk_tsl_service_property_set(topic->valuestring, payload->valuestring, strlen(payload->valuestring), NULL);
+        }
+        cJSON_Delete(json);
+   }
+}
+
+void kk_platMsg_dispatch(void)
+{
+    int count = 0;
+    void *data = NULL;
+
+    while (CONFIG_DISPATCH_QUEUE_MAXLEN == 0 || count++ < CONFIG_DISPATCH_QUEUE_MAXLEN) {
+
+        if (dm_queue_msg_next2(&data) == SUCCESS_RETURN) {
+            //dm_queue_msg_t *msg = (dm_queue_msg_t *)data;
+            printf("kk_handle_platMsg_dispatch get call \n");
+            if (kk_platMsg_handle) {
+                kk_platMsg_handle( data);
+            }
+
+            
+            free(data);
+            data = NULL;
+        } else {
+            break;
+        }
+    }
+}
+
 
 
 #define MYPORT  5555
@@ -163,8 +256,7 @@ int main(const int argc, const char **argv)
         kk_ipc_init(IPC_MID2APP, mid_cb);
         kk_ipc_init(IPC_MID2PLAT, mid2p_cb);
 		dm_mgr_init();
-		
-		
+
         //DB_Init();
         //test_tcp();
         /* when Connect to app and platfrom */
@@ -191,7 +283,7 @@ int main(const int argc, const char **argv)
                     ct =1;
 
                     kk_set_tsl_by_productKey("a1OYuSallan","model.json");
-                    kk_mid_subdev_add("a1OYuSallan","allanWno8yDdsjCX15iq","");
+                    kk_mid_subdev_add("a1OYuSallan","allanWno8yDdsjCX15iq","","aabbccddeeff1122");
                 }
 
                 /*memset(buf, 0, 100);

midware/tsl/tsl_handle/kk_tsl_api.c

@@ -1234,26 +1234,85 @@ int kk_msg_uri_parse_pkdn(_IN_ char *uri, _IN_ int uri_len, _IN_ int start_deli,
 
     return SUCCESS_RETURN;
 }
+int kk_tsl_response_ok(const char *topic, const char *payload, unsigned int payload_len)
+{   
+	int res = 0;
+    char product_key[PRODUCT_KEY_MAXLEN] = {0};
+    char device_name[DEVICE_NAME_MAXLEN] = {0};
+	kk_msg_response_t response;
+    kk_msg_request_payload_t request;
+	
+    memset(&request, 0, sizeof(kk_msg_request_payload_t));	
+	memset(&response, 0, sizeof(kk_msg_response_t));
+    res =kk_msg_uri_parse_pkdn((char *)topic, strlen(topic), 2 + KK_URI_OFFSET, 4 + KK_URI_OFFSET, product_key,
+                                device_name);
+    res = _kk_msg_request_parse((char *)payload, payload_len, &request);
+    if (res < SUCCESS_RETURN) {
+        return res ;
+    }	
+    response.service_prefix = DM_URI_SYS_PREFIX;
+    response.service_name = DM_URI_THING_SERVICE_PROPERTY_SET_REPLY;
+    memcpy(response.product_key, product_key, strlen(product_key));
+    memcpy(response.device_name, device_name, strlen(device_name));
+    response.code = (res == SUCCESS_RETURN) ? (IOTX_DM_ERR_CODE_SUCCESS) : (IOTX_DM_ERR_CODE_REQUEST_ERROR);
+	dm_msg_response(&request, &response, "{}", strlen("{}"), NULL);
+	return SUCCESS_RETURN;
+
+}
+
+int kk_tsl_property_set_byMac(const char mac[DEVICE_MAC_MAXLEN], const char *payload, unsigned int payload_len)
+{
+    kk_msg_request_payload_t request;
+    int res = 0, devid = 0;
+
+    memset(&request, 0, sizeof(kk_msg_request_payload_t));
+
+    res = dm_mgr_get_devId_by_mac(mac, &devid);
+	if(res != SUCCESS_RETURN){
+		return FAIL_RETURN;
+	}
+    res = _kk_msg_request_parse((char *)payload, payload_len, &request);
+    if (res < SUCCESS_RETURN) {
+        return res ;
+    }
+
+    /* Operation */
+    res = _kk_msg_property_set(devid, &request);
+
+    /* Response */
+	kk_tsl_post_property(devid,NULL);
+
+#if 0
+#define EVENT_ERROR_IDENTIFIER "Error"
+#define EVENT_ERROR_OUTPUT_INFO_IDENTIFIER "ErrorCode"
+
+	//kk_tsl_post_property(devid,NULL);
+    char event_output_identifier[64];
+    snprintf(event_output_identifier, sizeof(event_output_identifier), "%s.%s",
+             EVENT_ERROR_IDENTIFIER, EVENT_ERROR_OUTPUT_INFO_IDENTIFIER);
+
+    int errorCode = 0;
+	printf("[%s][%d]\n",__FUNCTION__,__LINE__);
+    kk_tsl_set_value(kk_tsl_set_event_output_value, devid,
+                      event_output_identifier, &errorCode, NULL);
+	kk_tsl_post_event(devid,EVENT_ERROR_IDENTIFIER);
+#endif
+    return SUCCESS_RETURN;
+}
 
 int kk_tsl_service_property_set(const char *topic, const char *payload, unsigned int payload_len,
         void *context)
 {
-    kk_msg_source_t source;
     kk_msg_request_payload_t request;
-    kk_msg_response_t response;
+
 
     int res = 0, devid = 0;
     char product_key[PRODUCT_KEY_MAXLEN] = {0};
     char device_name[DEVICE_NAME_MAXLEN] = {0};
 
-    memset(&source, 0, sizeof(kk_msg_source_t));
     memset(&request, 0, sizeof(kk_msg_request_payload_t));
-    memset(&response, 0, sizeof(kk_msg_response_t));
 
-    source.uri = topic;
-    source.payload = (unsigned char *)payload;
-    source.payload_len = payload_len;
-    source.context = NULL;	
+
 
 	/**************to do*******************/	
 
@@ -1278,13 +1337,6 @@ int kk_tsl_service_property_set(const char *topic, const char *payload, unsigned
     res = _kk_msg_property_set(devid, &request);
 
     /* Response */
-    response.service_prefix = DM_URI_SYS_PREFIX;
-    response.service_name = DM_URI_THING_SERVICE_PROPERTY_SET_REPLY;
-    memcpy(response.product_key, product_key, strlen(product_key));
-    memcpy(response.device_name, device_name, strlen(device_name));
-    response.code = (res == SUCCESS_RETURN) ? (IOTX_DM_ERR_CODE_SUCCESS) : (IOTX_DM_ERR_CODE_REQUEST_ERROR);
-	dm_msg_response(&request, &response, "{}", strlen("{}"), NULL);
-
 	kk_tsl_post_property(devid,NULL);
 
 #if 0

midware/tsl/tsl_handle/kk_tsl_common.h

@@ -15,6 +15,9 @@
 #define PRODUCT_KEY_MAXLEN          (32 + 1)
 #define DEVICE_NAME_MAXLEN          (32 + 1)
 #define DEVICE_SECRET_MAXLEN        (64 + 1)
+#define DEVICE_MAC_MAXLEN           (16 + 1)
+#define DEVICE_SN_MAXLEN            (32 + 1)
+
 #define TSL_PATH_MAXLEN             (64 + 1)
 
 #define DM_UTILS_UINT16_STRLEN (5)
@@ -66,6 +69,7 @@
 #define KK_TSL_GATAWAY_MAC_IDENTIFIER      	   "MACAddress"
 #define KK_TSL_GATAWAY_PORT_IDENTIFIER      	   "Port"
 #define KK_TSL_GATAWAY_SN_IDENTIFIER      	   "SN"
+#define KK_TSL_GATAWAY_WHITELIST_IDENTIFIER      	   "WhiteListState"
 
 typedef enum {
     KK_TSL_DATA_TARGET_SERVICE_INPUT_DATA,