【修改内容】把代码中product key相关统一修改成productType

【提交人】陈伟灿

application/kcloud/kcloud_data_handle.c

@@ -18,7 +18,7 @@
 #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"
-const char DM_MSG_TO_MIDDWARE[] = "{\"msgtype\":\"%d\",\"product_type\":\"%s\",\"device_name\":\"%s\"}";
+const char DM_MSG_TO_MIDDWARE[] = "{\"msgtype\":\"%d\",\"productType\":\"%s\",\"deviceCode\":\"%s\"}";
 #define KK_TOPIC_SERVICE_DELIMITER 			  '/'
 
 typedef struct{
@@ -53,7 +53,7 @@ int _kk_sendto_cloud(cJSON *root)
 	if(pData == NULL){
 		return -1;
 	}
-	printf("[%s][%d] payload:%s\n",__FUNCTION__,__LINE__,pData->valuestring);	
+	INFO_PRINT("[%s][%d] payload:%s\n",__FUNCTION__,__LINE__,pData->valuestring);	
 	KK_MQTT_SendMsg(topic,(const char*)pData->valuestring);	
 	free(topic);
 	return 0;
@@ -68,7 +68,7 @@ void KK_Data_FromDev(void* str,int len)
 	}
 	root=cJSON_Parse((char*)str);
 	if(root == NULL){
-	    printf("[%s][%d] root is null \n",__FUNCTION__,__LINE__);
+	    ERROR_PRINT("[%s][%d] root is null \n",__FUNCTION__,__LINE__);
 		return;
 	}
 	cmd = cJSON_GetObjectItem(root, "cmd");
@@ -124,11 +124,11 @@ static kk_msg_type_t _kk_parse_type(const char *topic)
 }
 
 static int _kk_topic_parse_pkdn(_IN_ char *topic, _IN_ int start_deli, _IN_ int end_deli,
-                          _OU_ char product_key[PRODUCT_TYPE_LEN], _OU_ char device_name[DEVICE_CODE_LEN])
+                          _OU_ char productType[PRODUCT_TYPE_LEN], _OU_ char deviceCode[DEVICE_CODE_LEN])
 {
     int res = 0, start = 0, end = 0, slice = 0;
 
-    if (topic == NULL || product_key == NULL || device_name == NULL) {
+    if (topic == NULL || productType == NULL || deviceCode == NULL) {
         return -1;
     }
     res = kk_utils_memtok(topic, strlen(topic), KK_TOPIC_SERVICE_DELIMITER, start_deli, &start);
@@ -147,8 +147,8 @@ static int _kk_topic_parse_pkdn(_IN_ char *topic, _IN_ int start_deli, _IN_ int
     /* dm_log_debug("URI Product Key: %.*s, Device Name: %.*s", slice - start - 1, uri + start + 1, end - slice - 1,
                  uri + slice + 1); */
 
-    memcpy(product_key, topic + start + 1, slice - start - 1);
-    memcpy(device_name, topic + slice + 1, end - slice - 1);
+    memcpy(productType, topic + start + 1, slice - start - 1);
+    memcpy(deviceCode, topic + slice + 1, end - slice - 1);
 
     return 0;
 }
@@ -165,7 +165,7 @@ static char * _kk_data_create(const char *topic,const char *data)
 	kk_msg_type_t type;
 	type = _kk_parse_type(topic);
 	if(type == MSG_INVALID){
-		printf("[%s][%d]\n",__FUNCTION__,__LINE__);
+		ERROR_PRINT("[%s][%d]\n",__FUNCTION__,__LINE__);
 		return NULL;
 	}
 	res =_kk_topic_parse_pkdn((char *)topic,2,4, product_key,device_name);
@@ -173,7 +173,7 @@ static char * _kk_data_create(const char *topic,const char *data)
 	infoStr_len = strlen(DM_MSG_TO_MIDDWARE)+strlen(product_key)+strlen(device_name)+10;
 	infoStr = malloc(infoStr_len);
 	if(infoStr == NULL){
-		printf("[%s][%d]\n",__FUNCTION__,__LINE__);
+		ERROR_PRINT("[%s][%d]\n",__FUNCTION__,__LINE__);
 		return NULL;
 	}
 	memset(infoStr,0x0,infoStr_len);

common/api/com_api.h

@@ -55,8 +55,9 @@ typedef enum{
 }kk_msg_type_t;
 
 #define MSG_TYPE_STR              "msgtype"
-#define MSG_PRODUCT_TYPE_STR      "product_type"
-#define MSG_DEVICE_NAME_STR       "device_name"
+#define MSG_PRODUCT_TYPE_STR      "productType"
+#define MSG_PRODUCT_CODE_STR      "productCode"
+#define MSG_DEVICE_CODE_STR       "deviceCode"
 #define MSG_PAYLOAD_STR           "payload"
 #define MSG_INFO_STR              "info"
 #define MSG_INDENTIFIER_STR              "identifier"

common/hal/HAL_OS_linux.c

@@ -520,7 +520,7 @@ int HAL_Get_mac(char* mac)
         printf("mac ioctl error\n");
         return -1;
     }
-    sprintf(mac_addr, "%02x:%02x:%02x:%02x:%02x:%02x",
+    sprintf(mac_addr, "%02x%02x%02x%02x%02x%02x",
             (unsigned char)tmp.ifr_hwaddr.sa_data[0],
             (unsigned char)tmp.ifr_hwaddr.sa_data[1],
             (unsigned char)tmp.ifr_hwaddr.sa_data[2],

common/hal/kk_product.h

@@ -29,8 +29,8 @@
 #define SN_ADDR_LEN        (32+1)
 
 
-#define PRODUCT_TPYE  "a1OYuSBt23u"
-#define PRODUCT_CODE  "aIqEbWno8yDdsjCX15iq"
+#define PRODUCT_TPYE  "kk"
+#define PRODUCT_CODE  "15"
 
 int HAL_SetProduct_Type(_IN_ char *product_type);
 int HAL_SetProduct_Code(_IN_ char *product_code);

midware/midware/dm/dm_ota.c

@@ -20,8 +20,8 @@ int dm_ota_init(void)
     dm_ota_ctx_t *ctx = _dm_ota_get_ctx();
     memset(ctx, 0, sizeof(dm_ota_ctx_t));
 
-    HAL_GetProduct_Type(ctx->product_key);
-    HAL_GetProduct_Code(ctx->device_name);
+    HAL_GetProduct_Type(ctx->productType);
+    HAL_GetProduct_Code(ctx->deviceCode);
 
     return SUCCESS_RETURN;
 }
@@ -32,7 +32,7 @@ int dm_ota_sub(void)
     void *handle = NULL;
 
     /* Init OTA Handle */
-    handle = IOT_OTA_Init(ctx->product_key, ctx->device_name, NULL);
+    handle = IOT_OTA_Init(ctx->productType, ctx->deviceCode, NULL);
     if (handle == NULL) {
         return FAIL_RETURN;
     }
@@ -43,14 +43,14 @@ int dm_ota_sub(void)
 }
 
 int ota_uri_parse_pkdn(_IN_ char *uri, _IN_ int uri_len, _IN_ int start_deli, _IN_ int end_deli,
-                          _OU_ char product_key[PRODUCT_KEY_MAXLEN], _OU_ char device_name[DEVICE_NAME_MAXLEN])
+                          _OU_ char productType[PRODUCT_TYPE_MAXLEN], _OU_ char deviceCode[DEVICE_CODE_MAXLEN])
 {
     int res = 0, start = 0, end = 0, slice = 0;
     int item_index = 0;
     int count = 0;
 
-    if (uri == NULL || uri_len <= 0 || product_key == NULL || device_name == NULL ||
-        (strlen(product_key) >= PRODUCT_KEY_MAXLEN) || (strlen(device_name) >= DEVICE_NAME_MAXLEN)) {
+    if (uri == NULL || uri_len <= 0 || productType == NULL || deviceCode == NULL ||
+        (strlen(productType) >= PRODUCT_TYPE_MAXLEN) || (strlen(deviceCode) >= DEVICE_CODE_MAXLEN)) {
         return INVALID_PARAMETER;
     }
 
@@ -75,21 +75,21 @@ int ota_uri_parse_pkdn(_IN_ char *uri, _IN_ int uri_len, _IN_ int start_deli, _I
     /* dm_log_debug("URI Product Key: %.*s, Device Name: %.*s", slice - start - 1, uri + start + 1, end - slice - 1,
                  uri + slice + 1); */
 
-    memcpy(product_key, uri + start + 1, slice - start - 1);
-    memcpy(device_name, uri + slice + 1, end - slice - 1);
+    memcpy(productType, uri + start + 1, slice - start - 1);
+    memcpy(deviceCode, uri + slice + 1, end - slice - 1);
 
     return SUCCESS_RETURN;
 }
 
 
-int dm_ota_setPKN(char product_key[PRODUCT_KEY_MAXLEN],char device_name[DEVICE_NAME_MAXLEN])
+int dm_ota_setPKN(char productType[PRODUCT_TYPE_MAXLEN],char deviceCode[DEVICE_CODE_MAXLEN])
 {
     dm_ota_ctx_t *ctx = _dm_ota_get_ctx();
     int res = 0;                     
-    memset(ctx->product_key, 0, PRODUCT_KEY_MAXLEN);
-    memset(ctx->device_name, 0, DEVICE_NAME_MAXLEN);
-    memcpy(ctx->product_key, product_key, PRODUCT_KEY_MAXLEN);
-    memcpy(ctx->device_name, device_name, DEVICE_NAME_MAXLEN);
+    memset(ctx->productType, 0, PRODUCT_TYPE_MAXLEN);
+    memset(ctx->deviceCode, 0, DEVICE_CODE_MAXLEN);
+    memcpy(ctx->productType, productType, PRODUCT_TYPE_MAXLEN);
+    memcpy(ctx->deviceCode, deviceCode, DEVICE_CODE_MAXLEN);
 
     return SUCCESS_RETURN;
 }
@@ -176,7 +176,7 @@ void dm_ota_handle(void *data){
     cJSON *json,*info_root,*info;
     cJSON *topic,*typeJson;
     cJSON *payload;
-    cJSON *product_type,*device_name;
+    cJSON *product_type,*device_code;
     json=cJSON_Parse(data);
 	if (json == NULL) {
         printf("Error before: [%s]\n","cJSON_Parse");
@@ -187,7 +187,7 @@ void dm_ota_handle(void *data){
 	info = cJSON_Parse(info_root->valuestring);
 	typeJson = cJSON_GetObjectItem(info, MSG_TYPE_STR);	
 	product_type = cJSON_GetObjectItem(info, MSG_PRODUCT_TYPE_STR);
-	device_name = cJSON_GetObjectItem(info, MSG_DEVICE_NAME_STR);
+	device_code = cJSON_GetObjectItem(info, MSG_DEVICE_CODE_STR);
     payload = cJSON_GetObjectItem(json, MSG_PAYLOAD_STR);
 
     printf(" payload= %s  \n",payload->valuestring );
@@ -195,7 +195,7 @@ void dm_ota_handle(void *data){
         char buf[128] = {0};
         int len = 128;
         if (dm_ota_check(payload->valuestring, strlen(payload->valuestring)+1, IOTX_OTA_TOPIC_TYPE_DEVICE_UPGRATE) == 0){
-            dm_ota_setPKN(product_type->valuestring,device_name->valuestring);
+            dm_ota_setPKN(product_type->valuestring,device_code->valuestring);
             dm_fota_perform_sync(buf, len);
         }else{
             printf("parse params error !!  \n");

midware/midware/dm/dm_ota.h

@@ -11,8 +11,8 @@
 
 typedef struct {
     void *ota_handle;
-    char product_key[PRODUCT_KEY_MAXLEN];
-    char device_name[DEVICE_NAME_MAXLEN];
+    char productType[PRODUCT_TYPE_MAXLEN];
+    char deviceCode[DEVICE_CODE_MAXLEN];
 } dm_ota_ctx_t;
 
 int dm_ota_init(void);

midware/midware/dm/kk_dm_api.c

@@ -38,23 +38,18 @@ static void _dm_api_unlock(void)
 int kk_dm_subdev_register(_IN_ int devid)
 {
     int res = 0;
-    dm_mgr_dev_node_t *search_node = NULL;
+    //dm_mgr_dev_node_t *search_node = NULL;
 
     if (devid < 0) {
         return INVALID_PARAMETER;
     }
 
     _dm_api_lock();
-    res = dm_mgr_search_dev_by_devid(devid, (void **)&search_node);
-    if (res != SUCCESS_RETURN) {
-        _dm_api_unlock();
-        return FAIL_RETURN;
-    }
-
-    if ((strlen(search_node->device_secret) > 0) && (strlen(search_node->device_secret) < DEVICE_SECRET_MAXLEN)) {
-        _dm_api_unlock();
-        return SUCCESS_RETURN;
-    }
+    //res = dm_mgr_search_dev_by_devid(devid, (void **)&search_node);
+    //if (res != SUCCESS_RETURN) {
+       // _dm_api_unlock();
+       //return FAIL_RETURN;
+    //}
 
     res = dm_mgr_upstream_thing_sub_register(devid);
 
@@ -275,9 +270,6 @@ ERROR:
 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;
@@ -294,12 +286,12 @@ int iotx_dm_subscribe(_IN_ int devid)
     
     //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;
+            "{\"cmd\":\"subscribe\",\"data\":{\"productType\":\"%s\",\"productCode\":\"%s\",\"deviceCode\":\"%s\"}}";
+    int len = strlen(subscribe_cmd) + strlen(node->productType) +strlen(node->productCode)+ strlen(node->deviceCode) + 1;
     void* buf = malloc(len);
     
     if (buf){
-        HAL_Snprintf(buf, len, subscribe_cmd, node->product_key, node->device_name);
+        HAL_Snprintf(buf, len, subscribe_cmd, node->productType, node->productCode,node->deviceCode);
         kk_ipc_send(IPC_MID2APP, buf, len);
         free(buf);
     }else{

midware/midware/dm/kk_dm_mng.h

@@ -6,20 +6,24 @@
 
 #include "iotx_dm.h"
 
-#define KK_DM_DEVICE_SINGLE  (0x01)
+#define KK_DM_DEVICE_CCU  (0x01)
 #define KK_DM_DEVICE_SUBDEV  (0x02)
 #define KK_DM_DEVICE_GATEWAY (0x04)
 #define KK_MID_SYNC_DEFAULT_TIMEOUT_MS (200)
 #define IDENTIFY_MAXLEN      (64 + 1)
+#define KK_DM_CCU_DEVICE_PRODUCT_TYPE "ccu"
+#define KK_DM_CCU_DEVICE_PRODUCT_CODE "15"
+#define KK_DM_GW_DEVICE_PRODUCT_TYPE "gw"
+#define KK_DM_GW_DEVICE_PRODUCT_CODE "2"
 
 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];
-	char device_mac[DEVICE_MAC_MAXLEN];
+    char productType[PRODUCT_TYPE_MAXLEN];
+    char productCode[PRODUCT_CODE_MAXLEN];
+    char deviceCode[DEVICE_CODE_MAXLEN];
+	char fatherMac[DEVICE_MAC_MAXLEN];
     struct list_head linked_list;
 } dm_mgr_dev_node_t;
 
@@ -36,8 +40,9 @@ typedef struct {
     //const char *service_name;
     kk_msg_type_t msgtype;
     char identity[IDENTIFY_MAXLEN];	
-    char product_key[PRODUCT_KEY_MAXLEN];
-    char device_name[DEVICE_NAME_MAXLEN];
+    char productType[PRODUCT_TYPE_MAXLEN];
+    char productCode[PRODUCT_CODE_MAXLEN];
+    char deviceCode[DEVICE_CODE_MAXLEN];
     char *params;
     int params_len;
     char *method;
@@ -46,8 +51,10 @@ typedef struct {
 typedef struct {
 	kk_msg_type_t msgtype;
 	char identity[IDENTIFY_MAXLEN];	
-	char product_key[PRODUCT_KEY_MAXLEN];
-	char device_name[DEVICE_NAME_MAXLEN];
+    char productType[PRODUCT_TYPE_MAXLEN];
+    char productCode[PRODUCT_CODE_MAXLEN];
+    char deviceCode[DEVICE_CODE_MAXLEN];
+
 	iotx_dm_error_code_t code;
 } kk_msg_response_t;
 

midware/midware/dm/kk_linkkit.c

@@ -287,7 +287,7 @@ static void _iotx_linkkit_event_callback(iotx_dm_event_types_t type, char *data)
    }else if (msgType == MSG_PROPERTYSET){
         INFO_PRINT("property set reply \n");
 		cJSON *product_type = cJSON_GetObjectItem(info, MSG_PRODUCT_TYPE_STR);
-		cJSON *device_name = cJSON_GetObjectItem(info, MSG_DEVICE_NAME_STR);		
+		cJSON *device_name = cJSON_GetObjectItem(info, MSG_DEVICE_CODE_STR);		
         dm_msg_thing_property_set_reply(product_type->valuestring, device_name->valuestring,payload->valuestring, strlen(payload->valuestring), NULL);
         //kk_tsl_service_property_set(topic->valuestring, payload->valuestring, strlen(payload->valuestring), NULL);
    }else if (msgType == MSG_OTA_UPGRADE){
@@ -1654,18 +1654,18 @@ 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],char device_mac[DEVICE_MAC_MAXLEN]){
+int kk_mid_subdev_add(char productType[PRODUCT_TYPE_MAXLEN], char productCode[PRODUCT_CODE_MAXLEN], char deviceCode[DEVICE_CODE_MAXLEN],char fatherMac[DEVICE_MAC_MAXLEN]){
     int res = 0;
     int devid = 0;
 	
-    res = dm_mgr_subdev_create(product_key,device_name,device_secret,device_mac,&devid);
+    res = dm_mgr_subdev_create(productType,productCode,deviceCode,fatherMac,&devid);
 	if (res != SUCCESS_RETURN) {
         ERROR_PRINT("subdev create Failed\n");
         return FAIL_RETURN;
     }
     INFO_PRINT("subdev open susseed, devid = %d\n", devid);
 
-	res = kk_subDev_insert_db(0,product_key,device_name,device_secret,device_mac);
+	res = kk_subDev_insert_db(0,productType,productCode,deviceCode,fatherMac,"1.1.0");
     if (res != SUCCESS_RETURN) {
         return FAIL_RETURN;
     }	

midware/midware/dm/kk_sub_db.c

@@ -49,7 +49,7 @@ static int kk_subDev_db_Init(void)
     }     
     INFO_PRINT("sub db Database opened\n");
     {
-		const char *pSubDevTable = "CREATE TABLE IF NOT EXISTS SubDeviceInfo(idx INTEGER,isOnline INTEGER,product_type varchar(33), device_name varchar(33), device_secret varchar(33),device_mac varchar(17))";
+		const char *pSubDevTable = "CREATE TABLE IF NOT EXISTS SubDeviceInfo(idx INTEGER,isOnline INTEGER,productType varchar(33),productCode varchar(33),deviceCode varchar(33),fatherMac varchar(17),version varchar(33))";
 
 	    char *pcErr;
         
@@ -91,9 +91,10 @@ static int _kk_load_subDevice(void)
 	   else{
 	   	   ctx->subDevNum++;
 	   }
-	   iotx_dm_subscribe(devId);
-	   kk_dm_ota_report_version(devId,"1.0.0");//todo
 	   usleep(100000);
+	   iotx_dm_subscribe(devId);
+	   kk_dm_ota_report_version(devId,sqlite3_column_text(stmt, 6));//version
+	   //usleep(100000);
     }	
 	sqlite3_finalize(stmt);
 	_kk_subDb_unlock();
@@ -130,7 +131,7 @@ static int _kk_check_subDev_exist(const char* device_mac)
 	sqlite3_prepare_v2(ctx->pDb, searchCmd, strlen(searchCmd), &stmt, NULL);
 	INFO_PRINT("total_column = %d\n", sqlite3_column_count(stmt));
 	while(sqlite3_step(stmt) == SQLITE_ROW){
-	   pmac = sqlite3_column_text(stmt, 5);
+	   pmac = sqlite3_column_text(stmt, 4);
 	   if(!strcmp(device_mac,pmac))
 	   {
 		 isExist = 1;
@@ -146,23 +147,23 @@ static int _kk_check_subDev_exist(const char* device_mac)
 
 }
 
-int kk_subDev_insert_db(int isOnline,char product_type[PRODUCT_KEY_MAXLEN],char device_name[DEVICE_NAME_MAXLEN], \
-										char device_secret[DEVICE_SECRET_MAXLEN],char device_mac[DEVICE_MAC_MAXLEN])
+int kk_subDev_insert_db(int isOnline,char productType[PRODUCT_TYPE_MAXLEN],char productCode[PRODUCT_CODE_MAXLEN], \
+										char deviceCode[DEVICE_CODE_MAXLEN],char fatherMac[DEVICE_MAC_MAXLEN],char version[DEVICE_VERSION_MAXLEN])
 {
-	const char *insertCmd = "insert into SubDeviceInfo (idx,isOnline, product_type, device_name,device_secret,device_mac) values ('%d','%d', '%s', '%s','%s','%s');";
+	const char *insertCmd = "insert into SubDeviceInfo (idx,isOnline, productType,productCode,deviceCode,fatherMac,version) values ('%d','%d', '%s', '%s','%s','%s','%s');";
 	char *sqlCmd = NULL;
 	int rc = 0;
 	char *zErrMsg = 0;
     kk_subDb_ctx_t *ctx = _kk_subDb_get_ctx();
 
 
-	if(_kk_check_subDev_exist((const char*)device_mac) == 1)
+	if(_kk_check_subDev_exist((const char*)deviceCode) == 1)
 	{
 		WARNING_PRINT("[%s][%d] DATA ALREADY EXIST!!!\n",__FUNCTION__,__LINE__);
 		return SUCCESS_RETURN;
 	}
 	_kk_subDb_lock();
-	sqlCmd = sqlite3_mprintf(insertCmd,ctx->subDevNum,isOnline,product_type,device_name,device_secret,device_mac);	
+	sqlCmd = sqlite3_mprintf(insertCmd,ctx->subDevNum,isOnline,productType,productCode,deviceCode,fatherMac,version);	
 
 	rc = sqlite3_exec(ctx->pDb, sqlCmd, NULL, NULL, &zErrMsg);
 	if( rc != SQLITE_OK ){
@@ -176,16 +177,16 @@ int kk_subDev_insert_db(int isOnline,char product_type[PRODUCT_KEY_MAXLEN],char
 	_kk_subDb_unlock();
 	return SUCCESS_RETURN;
 }
-int kk_subDev_delete_byMac(char device_mac[DEVICE_MAC_MAXLEN])
+int kk_subDev_delete_byMac(char deviceCode[DEVICE_CODE_MAXLEN])
 {
-	const char *deleteCmd = "delete from SubDeviceInfo where deviceMac = %s;";
+	const char *deleteCmd = "delete from SubDeviceInfo where deviceCode = %s;";
 	char *sqlCmd = NULL;
 	int rc = 0;
 	char *zErrMsg = 0;
 	kk_subDb_ctx_t *ctx = _kk_subDb_get_ctx();
 
 	_kk_subDb_lock();
-	 sqlCmd = sqlite3_mprintf(deleteCmd,device_mac);	
+	 sqlCmd = sqlite3_mprintf(deleteCmd,deviceCode);	
 
 	INFO_PRINT("Table delete data sqlCmd:%s\n",sqlCmd);
 	rc = sqlite3_exec(ctx->pDb, sqlCmd, NULL, NULL, &zErrMsg);

midware/midware/dm/kk_sub_db.h

@@ -4,15 +4,15 @@
 typedef struct {
 	int isOnline;
 	int index;
-    char device_mac[DEVICE_MAC_MAXLEN];
-	char product_id[PRODUCT_KEY_MAXLEN];
-	char device_sn[DEVICE_SN_MAXLEN];
-	char device_id[DEVICE_NAME_MAXLEN];
+    char productType[PRODUCT_TYPE_MAXLEN];
+	char productCode[PRODUCT_CODE_MAXLEN];
+	char deviceCode[DEVICE_CODE_MAXLEN];
+	char fatherMac[DEVICE_MAC_MAXLEN];
 } kk_dm_subdev_t;
 
 int kk_subDb_init(void);
-int kk_subDev_insert_db(int isOnline,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 kk_subDev_insert_db(int isOnline,char productType[PRODUCT_TYPE_MAXLEN],char productCode[PRODUCT_CODE_MAXLEN], \
+							char deviceCode[DEVICE_CODE_MAXLEN],char fatherMac[DEVICE_MAC_MAXLEN],char version[DEVICE_VERSION_MAXLEN]);
 int kk_subDev_delete_byMac(char device_mac[DEVICE_MAC_MAXLEN]);
 
 int kk_subDev_update_online(int isOnline,const char *device_mac);

midware/midware/dm/kk_wlist_mng.c

@@ -17,6 +17,7 @@
 typedef struct {
     void *mutex;
 	int  isOpened;
+	int  isInited;
 	int  wlistNum;
     sqlite3 *pDb;	
 } kk_wlist_ctx_t;
@@ -102,8 +103,8 @@ static int _kk_check_exist(const char* device_mac)
 	
 
 }
-static int kk_wlist_insert_db(int index,char device_mac[DEVICE_MAC_MAXLEN],char product_Id[PRODUCT_KEY_MAXLEN], \
-										char device_SN[DEVICE_SN_MAXLEN],char device_Id[DEVICE_NAME_MAXLEN])
+static int kk_wlist_insert_db(int index,char device_mac[DEVICE_MAC_MAXLEN],char product_Id[PRODUCT_CODE_MAXLEN], \
+										char device_SN[DEVICE_SN_MAXLEN],char device_Id[DEVICE_CODE_MAXLEN])
 {
 	const char *insertCmd = "insert into WhiteList (idx, deviceMac, productId,deviceSN,deviceId) values ('%d', '%s', '%s','%s','%s');";
 	char *sqlCmd = NULL;
@@ -155,12 +156,20 @@ int kk_wlist_status_open(int isOpen)
 {
 	int res = 0;
     kk_wlist_ctx_t *ctx = _kk_wlist_get_ctx();
+	if(ctx->isOpened)
+	{
+		printf("[%s][%d] ALREADY OPENED\n",__FUNCTION__,__LINE__,res);
+		return SUCCESS_RETURN;
+	}
 	res = kk_tsl_set_value(kk_tsl_set_property_value,0,KK_TSL_GATAWAY_WHITELIST_IDENTIFIER,&isOpen,NULL);
 	if(res != SUCCESS_RETURN){
 		ERROR_PRINT("[%s][%d] res:%d\n",__FUNCTION__,__LINE__,res);
 		return FAIL_RETURN;
 	}	
-	ctx->isOpened = 1;
+	ctx->isOpened = isOpen;
+	if(ctx->isOpened){
+		kk_wlist_init();
+	}
 	return SUCCESS_RETURN;
 }
 int kk_load_wlist(void)
@@ -195,6 +204,10 @@ int kk_wlist_init(void)
 	int res = 0;
     kk_wlist_ctx_t *ctx = _kk_wlist_get_ctx();
 
+	if(ctx->isInited)
+	{
+		return SUCCESS_RETURN;
+	}
     /* Create Mutex */
     ctx->mutex = HAL_MutexCreate();
     if (ctx->mutex == NULL) {
@@ -207,6 +220,7 @@ int kk_wlist_init(void)
 
 	}
 	kk_load_wlist();
+	ctx->isInited = 1;
 	return SUCCESS_RETURN;
 }
 int kk_set_wlist_byIdx(int idx,kk_wlist_dev_t * wlist_dev)

midware/midware/dm/kk_wlist_mng.h

@@ -4,9 +4,9 @@
 
 typedef struct {
     char device_mac[DEVICE_MAC_MAXLEN];
-	char product_id[PRODUCT_KEY_MAXLEN];
+	char product_id[PRODUCT_TYPE_MAXLEN];
 	char device_sn[DEVICE_SN_MAXLEN];
-	char device_id[DEVICE_NAME_MAXLEN];
+	char device_id[DEVICE_CODE_MAXLEN];
 	int index;
 } kk_wlist_dev_t;
 int kk_wlist_init(void);

midware/midware/midware.c

@@ -45,7 +45,7 @@ void mid_cb(void* data, int len){
             info_root = cJSON_GetObjectItem(json, MSG_INFO_STR);
 			info = cJSON_Parse(info_root->valuestring);
 			product_type = cJSON_GetObjectItem(info, MSG_PRODUCT_TYPE_STR);	
-			device_name = cJSON_GetObjectItem(info, MSG_DEVICE_NAME_STR);				
+			device_name = cJSON_GetObjectItem(info, MSG_DEVICE_CODE_STR);				
 			type = cJSON_GetObjectItem(info, MSG_TYPE_STR);
 			switch(atoi(type->valuestring))
 			{
@@ -109,6 +109,7 @@ void kk_platMsg_handle(void* data){
     cJSON *jsonPay;
     cJSON *proType;
     cJSON *proCode;
+	cJSON *devCode;
     cJSON *mac;
     
     json=cJSON_Parse(data);
@@ -123,9 +124,9 @@ void kk_platMsg_handle(void* data){
                 jsonPay = cJSON_GetObjectItem(json, "params");
                 proType = cJSON_GetObjectItem(jsonPay, "productType");
                 proCode = cJSON_GetObjectItem(jsonPay, "productCode");
-                
+                devCode = cJSON_GetObjectItem(jsonPay, "deviceCode");
                 INFO_PRINT("productType productCode mac: [%s][%s] [%s] \n",proType->valuestring, proCode->valuestring, mac->valuestring);
-                kk_mid_subdev_add(proType->valuestring,proCode->valuestring,"", mac->valuestring);
+                kk_mid_subdev_add(proType->valuestring,proCode->valuestring,devCode->valuestring, mac->valuestring);
                 
         }else if (method != NULL && mac != NULL){
             INFO_PRINT("save property and send to cloud \n");
@@ -276,7 +277,7 @@ int main(const int argc, const char **argv)
                 kk_platMsg_dispatch();
                 /*if (ct == 0){
                     ct =1;
-                    void* buf = "{        \"msgId\":        \"7\", \"version\":      \"1.0\", \"mac\":  \"588E81FFFED3834A\", \"method\":       \"thing.topo.add\",    \"params\":       {          \"AppVersion\":   \"10\",  \"deviceType\":   \"1\",  \"deviceCode\":   \"2\",   \"productType\":  \"3\",   \"productCode\":  \"4\"  }}";
+                    void* buf = "{        \"msgId\":        \"7\", \"version\":      \"1.0\", \"mac\":  \"588E81FFFED3834A\", \"method\":       \"thing.topo.add\",    \"params\":       {          \"AppVersion\":   \"10\",  \"deviceCode\":   \"1212121212121212\",   \"productType\":  \"curtain\",   \"productCode\":  \"24\"  }}";
                     kk_platMsg_handle(buf);
                     //kk_set_tsl_by_productKey("a1OYuSallan","model.json");
                     //kk_mid_subdev_add("a1OYuSallan","allanWno8yDdsjCX15iq","","aabbccddeeff1122");

midware/midware/utils/infra_defs.h

@@ -298,14 +298,14 @@ typedef enum IOT_RETURN_CODES {
 
 } iotx_err_t;
 #endif
-
+#if 0
 typedef struct _iotx_dev_meta_info {
     char product_key[IOTX_PRODUCT_KEY_LEN + 1];
     char product_secret[IOTX_PRODUCT_SECRET_LEN + 1];
     char device_name[IOTX_DEVICE_NAME_LEN + 1];
     char device_secret[IOTX_DEVICE_SECRET_LEN + 1];
 } iotx_dev_meta_info_t;
-
+#endif
 typedef struct {
     const char *region;
     uint16_t port;

midware/tsl/tsl_handle/kk_tsl_api.c

@@ -1207,12 +1207,12 @@ int kk_tsl_set_value(kk_tsl_set_t set, int devId, const char *identifier,
     return SUCCESS_RETURN;
 }
 int kk_msg_uri_parse_pkdn(_IN_ char *uri, _IN_ int uri_len, _IN_ int start_deli, _IN_ int end_deli,
-                          _OU_ char product_key[PRODUCT_KEY_MAXLEN], _OU_ char device_name[DEVICE_NAME_MAXLEN])
+                          _OU_ char productType[PRODUCT_TYPE_MAXLEN], _OU_ char deviceCode[DEVICE_CODE_MAXLEN])
 {
     int res = 0, start = 0, end = 0, slice = 0;
 
-    if (uri == NULL || uri_len <= 0 || product_key == NULL || device_name == NULL ||
-        (strlen(product_key) >= PRODUCT_KEY_MAXLEN) || (strlen(device_name) >= DEVICE_NAME_MAXLEN)) {
+    if (uri == NULL || uri_len <= 0 || productType == NULL || deviceCode == NULL ||
+        (strlen(productType) >= PRODUCT_TYPE_MAXLEN) || (strlen(deviceCode) >= DEVICE_CODE_MAXLEN)) {
         return INVALID_PARAMETER;
     }
 
@@ -1234,8 +1234,8 @@ int kk_msg_uri_parse_pkdn(_IN_ char *uri, _IN_ int uri_len, _IN_ int start_deli,
     /* dm_log_debug("URI Product Key: %.*s, Device Name: %.*s", slice - start - 1, uri + start + 1, end - slice - 1,
                  uri + slice + 1); */
 
-    memcpy(product_key, uri + start + 1, slice - start - 1);
-    memcpy(device_name, uri + slice + 1, end - slice - 1);
+    memcpy(productType, uri + start + 1, slice - start - 1);
+    memcpy(deviceCode, uri + slice + 1, end - slice - 1);
 
     return SUCCESS_RETURN;
 }
@@ -1287,8 +1287,8 @@ int kk_tsl_service_property_set(const char *topic, const char *payload, unsigned
 
 
     int res = 0, devid = 0;
-    char product_key[PRODUCT_KEY_MAXLEN] = {0};
-    char device_name[DEVICE_NAME_MAXLEN] = {0};
+    char productType[PRODUCT_TYPE_MAXLEN] = {0};
+    char deviceCode[DEVICE_CODE_MAXLEN] = {0};
 
     memset(&request, 0, sizeof(kk_msg_request_payload_t));
 
@@ -1300,11 +1300,11 @@ int kk_tsl_service_property_set(const char *topic, const char *payload, unsigned
 
     /* 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 =kk_msg_uri_parse_pkdn((char *)topic, strlen(topic), 2 + KK_URI_OFFSET, 4 + KK_URI_OFFSET, productType,
+                                deviceCode);
 
 
-    res = dm_mgr_search_device_by_pkdn(product_key, device_name, &devid);
+    res = dm_mgr_search_device_by_pkdn(productType, deviceCode, &devid);
     if (res < SUCCESS_RETURN) {
         return res;
     }

midware/tsl/tsl_handle/kk_tsl_api.h

@@ -78,7 +78,7 @@ extern int kk_tsl_get_value(kk_tsl_get_t method_get, int devId, const char *iden
                                        char **value_str);
 
 extern int kk_msg_uri_parse_pkdn(_IN_ char *uri, _IN_ int uri_len, _IN_ int start_deli, _IN_ int end_deli, \
-                          _OU_ char product_key[PRODUCT_KEY_MAXLEN], _OU_ char device_name[DEVICE_NAME_MAXLEN]);
+                          _OU_ char productType[PRODUCT_TYPE_MAXLEN], _OU_ char deviceCode[DEVICE_CODE_MAXLEN]);
 extern int kk_tsl_service_property_set(const char *topic, const char *payload, unsigned int payload_len,
         void *context);
 extern int kk_tsl_post_property(int devId, const char *property_identifier);

midware/tsl/tsl_handle/kk_tsl_common.h

@@ -12,11 +12,13 @@
     #define _OU_
 #endif
 
-#define PRODUCT_KEY_MAXLEN          (32 + 1)
-#define DEVICE_NAME_MAXLEN          (32 + 1)
-#define DEVICE_SECRET_MAXLEN        (64 + 1)
+#define PRODUCT_TYPE_MAXLEN          (32 + 1)
+#define PRODUCT_CODE_MAXLEN         (32 + 1)
+#define DEVICE_CODE_MAXLEN          (32 + 1)
+
 #define DEVICE_MAC_MAXLEN           (16 + 1)
 #define DEVICE_SN_MAXLEN            (32 + 1)
+#define DEVICE_VERSION_MAXLEN       (32 + 1)
 
 #define DM_UTILS_UINT16_STRLEN (5)
 #define DM_UTILS_UINT32_STRLEN (10)

midware/tsl/tsl_handle/kk_tsl_load.c

@@ -2,11 +2,15 @@
 #include <string.h>
 #include <stdio.h>
 #include "kk_tsl_common.h"
+#include "kk_dm_mng.h"
 #include "kk_log.h"
 
 
-#define TSL_PATH_FILE "/home/tsl/%s.json"
-char* kk_load_json(const char *product_type)
+#define TSL_SUBDEVICE_PATH_FILE "/home/tsl/product_%s.json"
+#define TSL_GATEWAY_PATH_FILE "/home/tsl/gateway-%s.json"
+#define TSL_CCU_PATH_FILE "/home/tsl/ccu-%s.json"
+
+char* kk_load_json(const char *productCode,int type)
 {
 	FILE *fp;
 	char *buf = NULL;
@@ -14,13 +18,33 @@ char* kk_load_json(const char *product_type)
 	int path_len = 0;
 	unsigned int filesize;
 
-	path_len = strlen(TSL_PATH_FILE)+strlen(product_type)+1;
+	if(type == KK_DM_DEVICE_CCU){
+		path_len = strlen(TSL_CCU_PATH_FILE)+strlen(productCode)+1;
+	}
+	else if(type == KK_DM_DEVICE_GATEWAY){
+		path_len = strlen(TSL_GATEWAY_PATH_FILE)+strlen(productCode)+1;
+	}
+	else{
+		path_len = strlen(TSL_SUBDEVICE_PATH_FILE)+strlen(productCode)+1;
+	}
+
 	tslPath = malloc(path_len);
 	if(tslPath == NULL){
 		return NULL;
 	}
 	memset(tslPath,0x0,path_len);
-	snprintf(tslPath,path_len,TSL_PATH_FILE,product_type);
+	
+	if(type == KK_DM_DEVICE_CCU){
+		snprintf(tslPath,path_len,TSL_CCU_PATH_FILE,productCode);
+	}
+	else if(type == KK_DM_DEVICE_GATEWAY){
+		snprintf(tslPath,path_len,TSL_GATEWAY_PATH_FILE,productCode);
+	}
+	else{
+		snprintf(tslPath,path_len,TSL_SUBDEVICE_PATH_FILE,productCode);
+	}
+	
+	
 	INFO_PRINT("\n[%s][%d]tslPath:%s!!!\n",__FUNCTION__,__LINE__,tslPath);
 	if(!(fp =  fopen(tslPath,"a+")))
 	{

midware/tsl/tsl_handle/kk_tsl_load.h

 #ifndef __TSL_DATA_LOAD__
 #define __TSL_DATA_LOAD__
 
-char* kk_load_json(const char *product_type);
+char* kk_load_json(const char *productCode,int type);
+
 
 #endif

midware/tsl/tsl_handle/kk_utils.c

@@ -188,18 +188,18 @@ void kk_MutexDestroy(void *mutex)
 
     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 kk_utils_service_name(_IN_ const char *prefix, _IN_ const char *name, _IN_ char productType[PRODUCT_TYPE_MAXLEN],
+                          _IN_ char deviceCode[DEVICE_CODE_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 ||
+    if ((prefix == NULL && name == NULL) || productType == NULL || deviceCode == 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_len = prefix_len + name_len + strlen(productType) + strlen(deviceCode) + 1;
     *service_name = malloc(service_name_len);
     if (*service_name == NULL) {
         return MEMORY_NOT_ENOUGH;
@@ -207,7 +207,7 @@ int kk_utils_service_name(_IN_ const char *prefix, _IN_ const char *name, _IN_ c
     memset(*service_name, 0, service_name_len);
 
     if (prefix != NULL) {
-        snprintf(*service_name, service_name_len, prefix, product_key, device_name);
+        snprintf(*service_name, service_name_len, prefix, productType, deviceCode);
     }
 
     if (name != NULL) {