Merge branch 'cwc' into 'master'

Cwc

See merge request chenweican/k-sdk!82

application/kcloud/kcloud_config.h

@@ -2,7 +2,7 @@
 #ifndef MQTT_CONF_H_
 #define MQTT_CONF_H_
 
-#define ADDRESS     "tcp://172.25.240.199:1883"//"tcp://172.25.240.31:1983"////
+#define ADDRESS     "tcp://172.25.240.31:1983"//"tcp://172.25.240.199:1883"//
 #define CLIENTID    "CCU.%s.%s"
 
 #define PAYLOAD     "Hello World!"

application/kcloud/kcloud_data_handle.c

@@ -431,12 +431,12 @@ static char * _kk_data_create(const char *topic,const char *data)
     char deviceCode[DEVICE_CODE_LEN] = {0};	
 	char * msgStr = NULL;
 
-	res =_kk_topic_parse_pkdn((char *)topic,3,productCode,deviceCode);
+	res =_kk_topic_parse_pkdn((char *)topic,2,productCode,deviceCode);
 	//if(!strcmp("gateway_2",productCode)){
 		//memset(productCode,0x0,sizeof(productCode));
 		//memcpy(productCode,"2",strlen("2"));
 	//}
-	res|=_kk_topic_parse_msgType((char *)topic,5,&msgStr);
+	res|=_kk_topic_parse_msgType((char *)topic,4,&msgStr);
 	infoStr_len = strlen(DM_MSG_TO_MIDDWARE)+strlen(productCode)+strlen(deviceCode)+strlen(msgStr)+10;
 	infoStr = malloc(infoStr_len);
 	if(infoStr == NULL){

application/kcloud/kk_info_report.c

@@ -99,7 +99,7 @@ static int kk_info_get(char *str)
             }                  
         }
         str_tmp = cJSON_PrintUnformatted(root);
-        INFO_PRINT("JSON %s\r\n", str_tmp);
+        //INFO_PRINT("JSON %s\r\n", str_tmp);
         strcpy(str, str_tmp);
         free(str_tmp);
         cJSON_Delete(root);
@@ -124,10 +124,10 @@ void *kk_info_nanomsg_send(void *data)
         memset(str,0x0,sizeof(str));
         ret = kk_info_get(str);
         if(ret == 0){
-            printf("*********nn_send***********\n");
+            //printf("*********nn_send***********\n");
             ret = nn_send(socketfd, str, strlen(str), 1);
             if(ret < 0)	{
-                WARNING_PRINT("[%s][%d]nn_send fail!!!\n",__FUNCTION__,__LINE__);
+                //WARNING_PRINT("[%s][%d]nn_send fail!!!\n",__FUNCTION__,__LINE__);
             }
         }
         sleep(10);

application/kcloud/kk_register.c

@@ -352,8 +352,7 @@ int kk_start_ccu_register(void)
                     close(sockfd);
                     return -1;
                 }
-                printf("\n get %s\n",buf);
-                char* json = strstr(buf,"\r\n\r\n");                
+                printf("\n get %s\n",buf);             
                 if(registerType == 1){//get deviceSecret
                     char* deviceSecret = strstr(buf,"deviceSecret");
                     if(deviceSecret != NULL){ 
@@ -379,11 +378,13 @@ int kk_start_ccu_register(void)
                     if(jwt != NULL){
                         char* start = strchr(buf,'{');
                         char* end = strrchr(buf,'}');
-                        strncpy(buf2,start,end-start+1);
-                        ret = kk_parse_token(buf2);
-                        if(ret == 0){
-                            close(sockfd);
-                            return 0;
+                        if(start != NULL && end != NULL){
+                            strncpy(buf2,start,end-start+1);
+                            ret = kk_parse_token(buf2);
+                            if(ret == 0){
+                                close(sockfd);
+                                return 0;
+                            }
                         }
                     }
                 }

application/kcloud/kk_topic_mng.c

@@ -12,7 +12,7 @@ const char KK_URI_SYS_PREFIX[] = "biz/kk/%s/%s/thing/service/property/set";
 const char KK_URI_SYS_PREFIX_SERVICE[] = "biz/kk/%s/%s/thing/service/+";
 const char KK_URI_SYS_PREFIX_TOPO_CHANGE[] = "biz/kk/%s/%s/thing/topo/change";
 const char KK_URI_SYS_PREFIX_EX[] = "biz/kk/%s/%s";
-const char KK_URI_OTA_PREFIX[] = "/ota/device/upgrade/kk/%s/%s/#";
+const char KK_URI_OTA_PREFIX[] = "ota/device/%s/%s/upgrade";
 const char KK_URI_OTA_PROCESS[] = "/ota/device/progress/%s/%s";
 const char KK_URI_OTA_INFORM[] = "/ota/device/inform/%s/%s";
 
@@ -54,8 +54,8 @@ int KK_Subdev_Subscribe(const cJSON *root)
 
     memset(url, 0, url_len);
     snprintf(url, url_len, KK_URI_OTA_PREFIX, productCode->valuestring, deviceCode->valuestring);
-    //INFO_PRINT("ota [%s][%d] URL:%s\n",__FUNCTION__,__LINE__,url);
-    //res = KK_MQTT_SubTopic(url);
+    INFO_PRINT("ota [%s][%d] URL:%s\n",__FUNCTION__,__LINE__,url);
+    res = KK_MQTT_SubTopic(url);
     
     memset(url, 0, url_len);
     snprintf(url, url_len, KK_URI_SYS_PREFIX, productCode->valuestring, deviceCode->valuestring);

application/kcloud/mqtt_api.c

@@ -208,7 +208,7 @@ MQTTAsync KK_MQTT_Connect(void)
 	    fclose(fp);
     }	
 	HAL_Get_mac(mac);
-	sprintf(usrname, "%s&%s", KK_CCU_ID,KK_CCU_PRODUCTID);
+	sprintf(usrname, "%s.%s", KK_CCU_ID,KK_CCU_PRODUCTID);
 	printf("cliendid:%s,usrname:%s\n",g_clientId,usrname);
 	printf("------------>token:%s\n",token);	
 	if ((rc = MQTTAsync_createWithOptions(&s_Client, ADDRESS, g_clientId, MQTTCLIENT_PERSISTENCE_NONE, NULL,&opts)) != MQTTASYNC_SUCCESS)

midware/midware/area/kk_area_handle.c

@@ -15,19 +15,7 @@ typedef struct {
     sqlite3 *pDb;	
 } kk_area_ctx_t;
 
-typedef enum{
-	DB_IDX = 0,
-	DB_ROOM_NAME,
-	DB_ROOM_ID,		
-};
-
-typedef enum{
-	DB_DEV_IDX = 0,
-	DB_DEV_ROOM_ID,
-	DB_DEV_DEVICECODE,	
-	DB_DEV_EPNUM,
-	
-};
+
 
 static kk_area_ctx_t s_kk_area_ctx = {NULL,0,NULL};
 
@@ -185,7 +173,8 @@ static int _kk_check_dev_exist(const char* deviceCode)
 	while(sqlite3_step(stmt) == SQLITE_ROW){
 	   pDeviceCode = sqlite3_column_text(stmt, DB_DEV_DEVICECODE);
 	   if(!strcmp(deviceCode,pDeviceCode))
-	   {
+	   
+{
 		 isExist = 1;
 		 break;
 	   }
@@ -259,32 +248,32 @@ int kk_room_dev_remove(const char *deviceCode,const char *epNum)
 
 
 int kk_room_device_list_add(const char *deviceCode)
-{
-	int len;
+{
+	int len;
 	kk_dev_list_t *ptr,*pre;
-	
+	
 	ptr = pre = s_device_list;
 	if(deviceCode == NULL){
 		return FAIL_RETURN;
 	}
-	
-	while(ptr!=NULL){
+	
+	while(ptr!=NULL){
 		pre = ptr;
 		if(strcmp(ptr->deviceCode,deviceCode) == 0){
 			return SUCCESS_RETURN;
 		}
-		ptr = ptr->next;
-	}
+		ptr = ptr->next;
+	}
 	ptr = (kk_dev_list_t*)malloc(sizeof(kk_dev_list_t));
 	memset(ptr,0,sizeof(kk_dev_list_t));
 	memcpy(ptr->deviceCode,deviceCode,strlen(deviceCode));
-
+
 	if(s_device_list==NULL){
 		s_device_list = ptr;
-	}else{
-		pre->next = ptr;
-	}
-
+	}else{
+		pre->next = ptr;
+	}
+
 	return SUCCESS_RETURN;
 }
 

midware/midware/area/kk_area_handle.h

@@ -7,6 +7,18 @@ typedef struct kk_dev_list{
 	struct kk_dev_list * next;
 }kk_dev_list_t;
 
+typedef enum{
+	DB_ROOM_IDX = 0,
+	DB_ROOM_NAME,
+	DB_ROOM_ID,		
+};
 
+typedef enum{
+	DB_DEV_IDX = 0,
+	DB_DEV_ROOM_ID,
+	DB_DEV_DEVICECODE,	
+	DB_DEV_EPNUM,
+	
+};
 #endif
 

midware/midware/dm/dm_ota.c

@@ -22,7 +22,6 @@ 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->productType);
     HAL_GetProduct_Code(ctx->deviceCode);
 
     return SUCCESS_RETURN;

midware/midware/dm/kk_dm_mng.c

@@ -508,7 +508,7 @@ static void _dm_mgr_destroy_devlist(void)
         free(del_node);
     }
 }
-
+extern char *kk_sync_get_info();
 int dm_mgr_init(void)
 {
     int res = 0;
@@ -527,11 +527,12 @@ int dm_mgr_init(void)
     /* Init Device Id*/
     ctx->global_devid = 1;
 	kk_property_db_init();
+
     /* Init Device List */
     INIT_LIST_HEAD(&ctx->dev_list);
-
 	HAL_Get_mac(mac);
-	
+    kk_sync_init();
+	//kk_sync_get_info();
 	res = dm_mgr_device_create(KK_DM_DEVICE_CCU,KK_DM_CCU_DEVICE_PRODUCT_CODE,KK_CCU_ID,mac,"",KK_DEV_UNKNOW,&devId,&heartbeat);
 	if (res != SUCCESS_RETURN) {
 		goto ERROR;
@@ -1086,7 +1087,7 @@ int dm_mgr_upstream_thing_topo_get(void)
 
     memset(&request, 0, sizeof(dm_msg_request_t));
     request.msgTypeStr = DM_URI_THING_TOPO_GET;
-    HAL_GetProduct_Code(request.deviceCode);
+    HAL_GetDevice_Code(request.deviceCode);
 
 
     res = _dm_mgr_search_dev_by_pkdn(request.deviceCode, &node);

midware/midware/dm/kk_property_db.c

@@ -29,14 +29,7 @@ typedef struct {
     sqlite3 *pDb;	
 } kk_property_db_ctx_t;
 
-typedef enum{
-	DB_IDX = 0,
-	DB_DEVICECODE,
-	DB_IDENTIFITER,
-	DB_VALUE,
-	DB_VALUETYPE,
-	DB_DEVTYPE
-};
+
 
 typedef enum{
 	DB_LOCKKEY_IDX = 0,
@@ -184,7 +177,7 @@ static int _kk_check_property_exist(const char* deviceCode,const char* identifie
 	   pIdentifier = sqlite3_column_text(stmt, DB_IDENTIFITER);
 	   if(!strcmp(deviceCode,pDeviceCode)&&!strcmp(identifier,pIdentifier))
 	   
-{
+		{
 		 isExist = 1;
 		 break;
 	   }

midware/midware/dm/kk_property_db.h

@@ -8,6 +8,14 @@ typedef struct{
 	char raw[60];
 }kk_prop_raw_struct_t;
 
+typedef enum{
+	DB_IDX = 0,
+	DB_DEVICECODE,
+	DB_IDENTIFITER,
+	DB_VALUE,
+	DB_VALUETYPE,
+	DB_DEVTYPE
+};
 int kk_property_db_init(void);
 
 #endif

midware/midware/dm/kk_sub_db.c

@@ -22,20 +22,7 @@ typedef struct {
 	int  subDevNum;
     sqlite3 *pDb;	
 } kk_subDb_ctx_t;
-typedef enum{
-	DB_IDX = 0,
-	DB_ONLINE,
-	DB_PRODUCTCODE,
-	DB_DEVICECODE,
-	DB_MAC,
-	DB_FATHERDEVICECODE,
-	DB_VERSION,
-	DB_AUTH,
-	DB_DEVTYPE,	
-	DB_HEARTBEAT,	
-	DB_PRODUCTTYPE,
-	DB_SCENESUPPORT
-};
+
 
 static kk_subDb_ctx_t s_kk_subDb_ctx = {NULL,0,NULL};
 static kk_subDb_ctx_t *_kk_subDb_get_ctx(void)
@@ -128,12 +115,12 @@ static int _kk_load_subDevice(void)
 	_kk_subDb_lock();
 	sqlite3_prepare_v2(ctx->pDb, searchCmd, strlen(searchCmd), &stmt, NULL);
 	while(sqlite3_step(stmt) == SQLITE_ROW){
-	   deviceType = sqlite3_column_int(stmt, DB_DEVTYPE);
+	   deviceType = sqlite3_column_int(stmt, DB_SUB_DEVTYPE);
 	   res = dm_mgr_subdev_create(deviceType,
-	   					sqlite3_column_text(stmt, DB_PRODUCTCODE),
-	   					sqlite3_column_text(stmt, DB_DEVICECODE),
-	   					sqlite3_column_text(stmt, DB_MAC),
-	   					sqlite3_column_text(stmt, DB_FATHERDEVICECODE),
+	   					sqlite3_column_text(stmt, DB_SUB_PRODUCTCODE),
+	   					sqlite3_column_text(stmt, DB_SUB_DEVICECODE),
+	   					sqlite3_column_text(stmt, DB_SUB_MAC),
+	   					sqlite3_column_text(stmt, DB_SUB_FATHERDEVICECODE),
 	   					KK_DEV_UNKNOW,&devId,&heartbeat);
 	
 	   if(res != SUCCESS_RETURN){
@@ -147,11 +134,11 @@ static int _kk_load_subDevice(void)
 	   iotx_dm_subscribe(devId);
 	   
 	   //sync the data from property db
-	   kk_property_sync_values(sqlite3_column_text(stmt, DB_DEVICECODE));
+	   kk_property_sync_values(sqlite3_column_text(stmt, DB_SUB_DEVICECODE));
 	   usleep(100000);
 
 	   if(deviceType == KK_DM_DEVICE_GATEWAY){
-			kk_dm_gw_status_check_push(sqlite3_column_text(stmt, DB_DEVICECODE));
+			kk_dm_gw_status_check_push(sqlite3_column_text(stmt, DB_SUB_DEVICECODE));
 	   }
 	   //post the property to cloud
 	   //dm_msg_thing_property_post_all(sqlite3_column_text(stmt, DB_DEVICECODE));
@@ -209,9 +196,10 @@ static int _kk_check_subDev_exist(const char* deviceCode)
 	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, DB_DEVICECODE);
+	   pmac = sqlite3_column_text(stmt, DB_SUB_DEVICECODE);
 	   if(!strcmp(deviceCode,pmac))
-	   {
+	   
+{
 		 isExist = 1;
 		 break;
 	   }
@@ -447,15 +435,15 @@ int kk_subDev_send_property_get_from_db(void)
 	_kk_subDb_lock();
 	sqlite3_prepare_v2(ctx->pDb, searchCmd, strlen(searchCmd), &stmt, NULL);
 	while(sqlite3_step(stmt) == SQLITE_ROW){
-	   isOffline = sqlite3_column_int(stmt, DB_DEVTYPE);
+	   isOffline = sqlite3_column_int(stmt, DB_SUB_DEVTYPE);
 	   if(isOffline == KK_DEV_ONLINE){
-		   res = dm_mgr_get_device_by_devicecode(sqlite3_column_text(stmt, DB_DEVICECODE), &node);
+		   res = dm_mgr_get_device_by_devicecode(sqlite3_column_text(stmt, DB_SUB_DEVICECODE), &node);
 		   if (res != SUCCESS_RETURN) {
 		       continue;
 		   }
 		   iotx_dm_dev_online(node->devid);
 
-		   dm_msg_thing_property_post_all(sqlite3_column_text(stmt, DB_DEVICECODE));
+		   dm_msg_thing_property_post_all(sqlite3_column_text(stmt, DB_SUB_DEVICECODE));
 	   }
     }	
 	sqlite3_finalize(stmt);
@@ -490,7 +478,7 @@ int kk_subDev_send_property_get(const char *fatherDeviceCode)
 	sqlite3_prepare_v2(ctx->pDb, sqlCmd, strlen(sqlCmd), &stmt, NULL);
 	//INFO_PRINT("total_column = %d\n", sqlite3_column_count(stmt));
 	while(sqlite3_step(stmt) == SQLITE_ROW){
-	   pDeviceCode = sqlite3_column_text(stmt, DB_DEVICECODE);
+	   pDeviceCode = sqlite3_column_text(stmt, DB_SUB_DEVICECODE);
 	   res = dm_mgr_get_device_by_devicecode(pDeviceCode,&node);
 	   if (res != SUCCESS_RETURN) {
 		   ERROR_PRINT("ERROR [%s][%d] res:%d\n",__FUNCTION__,__LINE__,res);
@@ -540,7 +528,7 @@ int kk_subDev_check_scene_support(const char *deviceCode)
 	sqlite3_prepare_v2(ctx->pDb, sqlCmd, strlen(sqlCmd), &stmt, NULL);
 	//INFO_PRINT("total_column = %d\n", sqlite3_column_count(stmt));
 	while(sqlite3_step(stmt) == SQLITE_ROW){
-	   pDeviceCode = sqlite3_column_text(stmt, DB_DEVICECODE);
+	   pDeviceCode = sqlite3_column_text(stmt, DB_SUB_DEVICECODE);
 	   if (!strcmp(deviceCode,pDeviceCode)) {
 		  res = 1;
 	   }
@@ -598,7 +586,7 @@ int kk_subDev_set_action_by_productType(const char *productType,const char *scen
 		sqlite3_prepare_v2(ctx->pDb, sqlCmd, strlen(sqlCmd), &stmt, NULL);
 		//INFO_PRINT("total_column = %d\n", sqlite3_column_count(stmt));
 		while(sqlite3_step(stmt) == SQLITE_ROW){
-		   pDeviceCode = sqlite3_column_text(stmt, DB_DEVICECODE);
+		   pDeviceCode = sqlite3_column_text(stmt, DB_SUB_DEVICECODE);
 		   res = dm_mgr_get_device_by_devicecode(pDeviceCode,&node);
 		   if (res != SUCCESS_RETURN) {
 			   continue;

midware/midware/dm/kk_sub_db.h

@@ -10,6 +10,19 @@ int kk_subDev_delete_byMac(char device_mac[DEVICE_MAC_MAXLEN]);
 
 int kk_subDev_update_offline(int isOnline,const char *device_mac);
 int kk_subDev_update_auth(int isAuth,const char *deviceCode);
-
+typedef enum{
+	DB_SUB_IDX = 0,
+	DB_SUB_ONLINE,
+	DB_SUB_PRODUCTCODE,
+	DB_SUB_DEVICECODE,
+	DB_SUB_MAC,
+	DB_SUB_FATHERDEVICECODE,
+	DB_SUB_VERSION,
+	DB_SUB_AUTH,
+	DB_SUB_DEVTYPE,	
+	DB_SUB_HEARTBEAT,	
+	DB_SUB_PRODUCTTYPE,
+	DB_SUB_SCENESUPPORT
+};
 
 #endif

midware/midware/dm/kk_sync_data.c

+/************************************************************
+*版权所有 （C）2020，公司（或个人）名称
+*
+*文件名称： kk_sync_data.c
+*内容摘要： 数据同步处理相关
+*其他说明： 
+*当前版本：  
+*************************************************************/
+
+#include <stdio.h>
+#include "kk_tsl_api.h"
+#include "kk_sync_data.h"
+#include "kk_dm_mng.h"
+#include "kk_scene_handle.h"
+#include "kk_scene_db.h"
+#include "sqlite3.h"
+#include "kk_log.h"
+#include "cJSON.h"
+#include "kk_property_db.h"
+#include "kk_tsl_api.h"
+#include "kk_area_handle.h"
+#include "kk_sub_db.h"
+extern sqlite3 *g_kk_pDb;
+
+typedef struct {
+    void *mutex;
+    sqlite3 *pDb;	
+} kk_sync_ctx_t;
+
+static kk_sync_ctx_t s_kk_sync_ctx = {NULL,NULL};
+static kk_sync_ctx_t *_kk_sync_get_ctx(void)
+{
+    return &s_kk_sync_ctx;
+}
+static void _kk_sync_lock(void)
+{
+    kk_sync_ctx_t *ctx = _kk_sync_get_ctx();
+    if (ctx->mutex) {
+        HAL_MutexLock(ctx->mutex);
+    }
+}
+
+static void _kk_sync_unlock(void)
+{
+    kk_sync_ctx_t *ctx = _kk_sync_get_ctx();
+    if (ctx->mutex) {
+        HAL_MutexUnlock(ctx->mutex);
+    }
+}
+
+/************************************************************
+*功能描述：同步数据模块初始化
+*输入参数：无
+*输出参数：无
+*返 回 值：0:成功；其他：失败
+*其他说明：
+*************************************************************/
+int kk_sync_init(void)
+{
+	int res = 0;
+    kk_sync_ctx_t *ctx = _kk_sync_get_ctx();
+    /* Create Mutex */
+    ctx->mutex = HAL_MutexCreate();
+    if (ctx->mutex == NULL) {
+        return FAIL_RETURN;
+    }
+	ctx->pDb = g_kk_pDb;
+	return SUCCESS_RETURN;
+}
+static int kk_get_rooms_devices(cJSON *roomDevicesArray,char *roomId)
+{
+	char *sqlCmd = NULL;	
+	sqlite3_stmt *stmt;	
+	char *deviceCode = NULL;
+	cJSON *deviceObj = NULL;
+	kk_sync_ctx_t *ctx = _kk_sync_get_ctx();	
+	if(roomDevicesArray == NULL || roomId == NULL){
+		return FAIL_RETURN;
+	}
+	sqlCmd = sqlite3_mprintf("select * from AreaDevInfo where roomId = '%s'",roomId);
+	sqlite3_prepare_v2(ctx->pDb, sqlCmd, strlen(sqlCmd), &stmt, NULL);
+	while(sqlite3_step(stmt) == SQLITE_ROW){
+		deviceObj = cJSON_CreateObject();
+        deviceCode = sqlite3_column_text(stmt, DB_DEV_DEVICECODE);
+		cJSON_AddStringToObject(deviceObj, KK_SYNC_DEVICECODE_STR, deviceCode);		
+	}	
+	sqlite3_free(sqlCmd);
+    sqlite3_finalize(stmt);	
+	return SUCCESS_RETURN;
+}
+static int kk_get_rooms_info(cJSON *data)
+{
+	char *sqlCmd = NULL;
+	sqlite3_stmt *stmt;	
+	char *roomId = NULL;
+	char *roomName = NULL;
+	int valueType = 0;
+	kk_sync_ctx_t *ctx = _kk_sync_get_ctx();	
+	if(data == NULL){
+		return FAIL_RETURN;
+	}
+	cJSON *rooms = cJSON_CreateArray();
+	cJSON *roomItem = cJSON_CreateObject();
+	cJSON *roomDevicesArray = cJSON_CreateArray();	
+	_kk_sync_lock();
+	sqlCmd = sqlite3_mprintf("select * from AreaInfo");	
+	sqlite3_prepare_v2(ctx->pDb, sqlCmd, strlen(sqlCmd), &stmt, NULL);
+	while(sqlite3_step(stmt) == SQLITE_ROW){
+        roomId = sqlite3_column_text(stmt, DB_ROOM_ID);
+		roomName = sqlite3_column_text(stmt, DB_ROOM_NAME);
+		cJSON_AddStringToObject(roomItem, KK_SYNC_ROOMID_STR, roomId);
+		cJSON_AddStringToObject(roomItem, KK_SYNC_NANE_STR, roomName);
+		kk_get_rooms_devices(roomDevicesArray,roomId);		
+	}
+	sqlite3_free(sqlCmd);
+    sqlite3_finalize(stmt);	
+	_kk_sync_unlock();	
+	cJSON_AddItemToObject(roomItem, KK_SYNC_DEVICES_STR, roomDevicesArray);
+
+
+	cJSON *sceneId = cJSON_CreateObject();
+	cJSON_AddStringToObject(sceneId, KK_SYNC_SCENEID_STR, "sceneId");
+	cJSON *scenes = cJSON_CreateArray();	
+	cJSON_AddItemToArray(scenes, sceneId);
+	cJSON_AddItemToObject(roomItem, KK_SYNC_SCENE_STR, scenes);
+	cJSON_AddItemToArray(rooms, roomItem);	
+	cJSON_AddItemToObject(data, KK_SYNC_ROOMS_STR, rooms);
+	return SUCCESS_RETURN;			
+}
+static int kk_get_properties_info(char *deviceCode,cJSON *obj)
+{
+	char *sqlCmd = NULL;
+	char *zErrMsg = 0;
+	sqlite3_stmt *stmt;	
+	char *propertyStr = NULL;
+	char *valueStr = NULL;
+	int valueType = 0;
+	kk_sync_ctx_t *ctx = _kk_sync_get_ctx();		
+	if(deviceCode == NULL || obj == NULL){
+		return FAIL_RETURN;
+	}
+	cJSON *propertyItem = cJSON_CreateObject();
+	sqlCmd = sqlite3_mprintf("select * from PropertiesInfo WHERE deviceCode = '%s' ",deviceCode);	
+	sqlite3_prepare_v2(ctx->pDb, sqlCmd, strlen(sqlCmd), &stmt, NULL);	
+	while(sqlite3_step(stmt) == SQLITE_ROW){
+        propertyStr = sqlite3_column_text(stmt, DB_IDENTIFITER);
+		valueType = sqlite3_column_int(stmt, DB_VALUETYPE);
+		valueStr = sqlite3_column_text(stmt, DB_VALUE);
+		if(valueType == KK_TSL_DATA_TYPE_TEXT){
+			cJSON_AddStringToObject(propertyItem, propertyStr, valueStr);
+		}else if(valueType == KK_TSL_DATA_TYPE_INT||
+            valueType == KK_TSL_DATA_TYPE_ENUM||
+            valueType == KK_TSL_DATA_TYPE_BOOL){
+			cJSON_AddNumberToObject(propertyItem, propertyStr, atoi(valueStr));
+		}
+	}	
+	cJSON_AddItemToObject(obj, KK_SYNC_PROPERTY_STR, propertyItem);
+	sqlite3_free(sqlCmd);
+    sqlite3_finalize(stmt);	
+	return SUCCESS_RETURN;
+}
+
+static int kk_get_sub_devices_info(cJSON *gwdevicesItem,char *deviceCode)
+{
+	char *sqlCmd = NULL;
+	char *zErrMsg = 0;
+	sqlite3_stmt *stmt;	
+	kk_sync_ctx_t *ctx = _kk_sync_get_ctx();
+	char *subDeviceCode = NULL;	
+	char *subProductCode = NULL;
+	char *subVersion = NULL;
+	char *subIsline = NULL;	
+	if(gwdevicesItem == NULL || deviceCode == NULL){
+		return FAIL_RETURN;
+	}
+	cJSON *subDevices = cJSON_CreateArray();
+	sqlCmd = sqlite3_mprintf("select * from SubDeviceInfo WHERE fatherDeviceCode = '%s' ",deviceCode);	
+	sqlite3_prepare_v2(ctx->pDb, sqlCmd, strlen(sqlCmd), &stmt, NULL);
+	while(sqlite3_step(stmt) == SQLITE_ROW){
+		cJSON *subdevicesItem = cJSON_CreateObject();
+        subDeviceCode = sqlite3_column_text(stmt, DB_SUB_DEVICECODE);
+        subProductCode = sqlite3_column_text(stmt, DB_SUB_PRODUCTCODE);	
+		subVersion = sqlite3_column_text(stmt, DB_SUB_VERSION);
+        subIsline = sqlite3_column_text(stmt, DB_SUB_ONLINE);				
+		cJSON_AddStringToObject(subdevicesItem, KK_SYNC_DEVICECODE_STR, subDeviceCode);	
+		cJSON_AddStringToObject(subdevicesItem, KK_SYNC_VERSION_STR, subVersion);
+		cJSON_AddStringToObject(subdevicesItem, KK_SYNC_MAC_STR, subDeviceCode);	
+		cJSON_AddStringToObject(subdevicesItem, KK_SYNC_NANE_STR, "SUBDEV");	
+		cJSON_AddStringToObject(subdevicesItem, KK_SYNC_ONLINE_STR, subIsline);	
+		cJSON_AddStringToObject(subdevicesItem, KK_SYNC_PRODUCTCODE_STR, subProductCode);	
+		cJSON_AddStringToObject(subdevicesItem, KK_SYNC_SN_STR, "");	
+		cJSON_AddStringToObject(subdevicesItem, KK_SYNC_STATUS_STR, "启动");
+		kk_get_properties_info(subDeviceCode,subdevicesItem);
+		cJSON_AddItemToArray(subDevices, gwdevicesItem);			
+	}	
+	cJSON_AddItemToObject(gwdevicesItem, KK_SYNC_DEVICES_STR, subDevices);
+	sqlite3_free(sqlCmd);
+    sqlite3_finalize(stmt);	
+	return SUCCESS_RETURN;
+}
+static int kk_get_gw_devices_info(cJSON *gwdevices)
+{
+	char *sqlCmd = NULL;
+	char *zErrMsg = 0;
+	sqlite3_stmt *stmt;	
+	cJSON *gwdevicesItem = NULL;
+	char *gw_deviceCode = NULL;
+	char *gw_productCode = NULL;
+	char *gw_version = NULL;	
+	char *gw_isline = NULL;		
+	char *valueStr = NULL;
+	int valueType = 0;
+	kk_sync_ctx_t *ctx = _kk_sync_get_ctx();	
+	if(gwdevices == NULL){
+		return FAIL_RETURN;
+	}
+
+	_kk_sync_lock();
+	sqlCmd = sqlite3_mprintf("select * from SubDeviceInfo WHERE devType = '%d' ",KK_DM_DEVICE_GATEWAY);	
+	sqlite3_prepare_v2(ctx->pDb, sqlCmd, strlen(sqlCmd), &stmt, NULL);	
+	while(sqlite3_step(stmt) == SQLITE_ROW){
+		cJSON *gwdevicesItem = cJSON_CreateObject();
+        gw_deviceCode = sqlite3_column_text(stmt, DB_SUB_DEVICECODE);
+        gw_productCode = sqlite3_column_text(stmt, DB_SUB_PRODUCTCODE);	
+		gw_version = sqlite3_column_text(stmt, DB_SUB_VERSION);
+        gw_isline = sqlite3_column_text(stmt, DB_SUB_ONLINE);				
+		cJSON_AddStringToObject(gwdevicesItem, KK_SYNC_DEVICECODE_STR, gw_deviceCode);	
+		cJSON_AddStringToObject(gwdevicesItem, KK_SYNC_VERSION_STR, gw_version);
+		cJSON_AddStringToObject(gwdevicesItem, KK_SYNC_MAC_STR, gw_deviceCode);	
+		cJSON_AddStringToObject(gwdevicesItem, KK_SYNC_NANE_STR, "GW");	
+		cJSON_AddStringToObject(gwdevicesItem, KK_SYNC_ONLINE_STR, gw_isline);	
+		cJSON_AddStringToObject(gwdevicesItem, KK_SYNC_PRODUCTCODE_STR, gw_productCode);	
+		cJSON_AddStringToObject(gwdevicesItem, KK_SYNC_SN_STR, "");	
+		cJSON_AddStringToObject(gwdevicesItem, KK_SYNC_STATUS_STR, "启动");
+		kk_get_properties_info(gw_deviceCode,gwdevicesItem);
+		kk_get_sub_devices_info(gwdevicesItem,gw_deviceCode);
+		cJSON_AddItemToArray(gwdevices, gwdevicesItem);			
+	}	
+	sqlite3_free(sqlCmd);
+    sqlite3_finalize(stmt);	
+	_kk_sync_unlock();
+	return SUCCESS_RETURN;
+}
+static int kk_get_devices_info(cJSON *data)
+{
+	if(data == NULL){
+		return FAIL_RETURN;
+	}
+	cJSON *gwdevices = cJSON_CreateArray();	
+	kk_get_gw_devices_info(gwdevices);
+	cJSON_AddItemToObject(data, KK_SYNC_DEVICES_STR, gwdevices);	
+	return SUCCESS_RETURN;		
+}
+static int kk_get_scenes_actions_info(char *actionArray )
+{
+	char *sqlCmd = NULL;
+	char *zErrMsg = 0;
+	sqlite3_stmt *stmt;
+	char *deviceCode = NULL;
+	char *propertyName = NULL;
+	char *propertyValue = NULL;	
+	char *type = NULL;
+	int delay = 0,epNum = 0;
+	kk_sync_ctx_t *ctx = _kk_sync_get_ctx();			
+	if(actionArray == NULL){
+		return FAIL_RETURN;
+	}
+	sqlCmd = sqlite3_mprintf("select * from SceneActionInfo");	
+	sqlite3_prepare_v2(ctx->pDb, sqlCmd, strlen(sqlCmd), &stmt, NULL);	
+	while(sqlite3_step(stmt) == SQLITE_ROW){
+		cJSON *actionItem = cJSON_CreateObject();
+        deviceCode = sqlite3_column_text(stmt, DB_SCENEACTION_DEVICECODE);
+        delay = sqlite3_column_int(stmt, DB_SCENEACTION_DELAY);	
+		epNum = sqlite3_column_int(stmt, DB_SCENEACTION_EPNUM);
+        propertyName = sqlite3_column_text(stmt, DB_SCENEACTION_PROPERTYNAME);
+	    propertyValue = sqlite3_column_text(stmt, DB_SCENEACTION_PROPERTYVALUE);	
+		type = sqlite3_column_text(stmt, DB_SCENEACTION_TYPE);			
+		cJSON_AddStringToObject(actionItem, KK_SYNC_DEVICECODE_STR, deviceCode);	
+		cJSON_AddNumberToObject(actionItem, KK_SYNC_SCENE_DELAY_STR, delay);
+		cJSON_AddNumberToObject(actionItem, KK_SYNC_SCENE_EPNUM_STR, epNum);	
+		cJSON_AddStringToObject(actionItem, KK_SYNC_SCENE_PROPERTYNAME_STR, propertyName);	
+		cJSON_AddStringToObject(actionItem, KK_SYNC_SCENE_TYPE_STR, type);	
+		cJSON_AddStringToObject(actionItem, KK_SYNC_SCENE_PROPERTYVALUE_STR, propertyValue);	
+		cJSON_AddStringToObject(actionItem, KK_SYNC_ROOMID_STR, "");	
+		cJSON_AddItemToArray(actionArray, actionItem);			
+	}	
+	sqlite3_free(sqlCmd);
+    sqlite3_finalize(stmt);	
+	return SUCCESS_RETURN;	
+}
+static int kk_get_scenes_trigger_info(char *triggerArray,char *sceneId)
+{
+	char *sqlCmd = NULL;
+	char *zErrMsg = 0;
+	sqlite3_stmt *stmt;
+	char *deviceCode = NULL;
+	char *propertyName = NULL;
+	char *compareType = NULL;	
+	char *compareValue = NULL;		
+	char *type = NULL;
+	int delay = 0,epNum = 0;
+	kk_sync_ctx_t *ctx = _kk_sync_get_ctx();			
+	if(triggerArray == NULL || sceneId == NULL){
+		return FAIL_RETURN;
+	}
+	sqlCmd = sqlite3_mprintf("select * from SceneTriggerInfo where sceneId = %s",sceneId);	
+	sqlite3_prepare_v2(ctx->pDb, sqlCmd, strlen(sqlCmd), &stmt, NULL);	
+	while(sqlite3_step(stmt) == SQLITE_ROW){
+		cJSON *triggerItem = cJSON_CreateObject();
+        deviceCode = sqlite3_column_text(stmt, DB_SCENETRIGGER_DEVICECODE);
+		epNum = sqlite3_column_int(stmt, DB_SCENETRIGGER_EPNUM);
+        propertyName = sqlite3_column_text(stmt, DB_SCENETRIGGER_PROPERTYNAME);
+	    compareType = sqlite3_column_text(stmt, DB_SCENETRIGGER_COMPARETYPE);
+	    compareValue = sqlite3_column_text(stmt, DB_SCENETRIGGER_COMPAREVALUE);	
+		type = sqlite3_column_text(stmt, DB_SCENETRIGGER_TYPE);			
+		cJSON_AddStringToObject(triggerItem, KK_SYNC_DEVICECODE_STR, deviceCode);	
+		cJSON_AddNumberToObject(triggerItem, KK_SYNC_SCENE_EPNUM_STR, epNum);	
+		cJSON_AddStringToObject(triggerItem, KK_SYNC_SCENE_PROPERTYNAME_STR, propertyName);	
+		cJSON_AddStringToObject(triggerItem, KK_SYNC_SCENE_COMPARETYPE_STR, compareType);	
+		cJSON_AddStringToObject(triggerItem, KK_SYNC_SCENE_COMPAREValue_STR, compareValue);		
+		cJSON_AddItemToArray(triggerArray, triggerItem);			
+	}	
+	sqlite3_free(sqlCmd);
+    sqlite3_finalize(stmt);	
+	return SUCCESS_RETURN;	
+}
+static int kk_get_scenes_condition_info(char *conditionArray,char *sceneId)
+{
+	char *sqlCmd = NULL;
+	char *zErrMsg = 0;
+	sqlite3_stmt *stmt;
+	int starttime = 0;
+	int endtime = 0;	
+	int crossDay = 0;		
+	int repeat = 0;
+
+	kk_sync_ctx_t *ctx = _kk_sync_get_ctx();			
+	if(conditionArray == NULL || sceneId == NULL){
+		return FAIL_RETURN;
+	}
+	sqlCmd = sqlite3_mprintf("select * from SceneConditionInfo where sceneId = %s",sceneId);	
+	sqlite3_prepare_v2(ctx->pDb, sqlCmd, strlen(sqlCmd), &stmt, NULL);	
+	while(sqlite3_step(stmt) == SQLITE_ROW){
+		cJSON *conditionItem = cJSON_CreateObject();
+        starttime = sqlite3_column_int(stmt, DB_SCENECONDITION_STARTTIME);
+	    endtime = sqlite3_column_int(stmt, DB_SCENECONDITION_ENDTIME);
+	    crossDay = sqlite3_column_int(stmt, DB_SCENECONDITION_CROSSDAY);
+		repeat = sqlite3_column_int(stmt, DB_SCENECONDITION_REPEATDAY);		
+		cJSON_AddNumberToObject(conditionItem, KK_SYNC_SCENE_STARTTIME_STR, starttime);	
+		cJSON_AddNumberToObject(conditionItem, KK_SYNC_SCENE_ENDTIME_STR, endtime);	
+		cJSON_AddNumberToObject(conditionItem, KK_SYNC_SCENE_CROSSDAY_STR, crossDay);	
+		cJSON_AddNumberToObject(conditionItem, KK_SYNC_SCENE_REPEATDAY_STR, repeat);		
+		cJSON_AddItemToArray(conditionArray, conditionItem);			
+	}	
+	sqlite3_free(sqlCmd);
+    sqlite3_finalize(stmt);	
+	return SUCCESS_RETURN;	
+}
+static int kk_get_scenes_info(cJSON *data)
+{
+	char *sqlCmd = NULL;
+	char *zErrMsg = 0;
+	sqlite3_stmt *stmt;	
+	int enable = 0,type = 0;
+	char *name = NULL;
+	char *sceneId = NULL;
+	kk_sync_ctx_t *ctx = _kk_sync_get_ctx();		
+	if(data == NULL){
+		return FAIL_RETURN;
+	}
+	cJSON *sceneArray = cJSON_CreateArray();	
+	sqlCmd = sqlite3_mprintf("select * from SceneInfo");
+	sqlite3_prepare_v2(ctx->pDb, sqlCmd, strlen(sqlCmd), &stmt, NULL);	
+	while(sqlite3_step(stmt) == SQLITE_ROW){
+		cJSON *sceneArrayItem = cJSON_CreateObject();
+        enable = sqlite3_column_int(stmt, DB_SCENEINFO_ENABLE);
+		if(enable == 1){
+			cJSON_AddStringToObject(sceneArrayItem, KK_SYNC_SCENE_ENABLE_STR, "启动");	
+		}else{
+			cJSON_AddStringToObject(sceneArrayItem, KK_SYNC_SCENE_ENABLE_STR, "禁用");	
+
+		}
+		type = sqlite3_column_int(stmt, DB_SCENEINFO_SCENETYPE);
+		cJSON_AddNumberToObject(sceneArrayItem, KK_SYNC_SCENE_SCENETYPE_STR, type);	
+		name = sqlite3_column_text(stmt, DB_SCENEINFO_NAME);
+		cJSON_AddStringToObject(sceneArrayItem, KK_SYNC_NANE_STR, name);	
+		sceneId = sqlite3_column_text(stmt, DB_SCENEINFO_SCENEID);
+		cJSON_AddStringToObject(sceneArrayItem, KK_SYNC_SCENEID_STR, sceneId);
+		cJSON *actionArray = cJSON_CreateArray();
+		kk_get_scenes_actions_info(actionArray);	
+		cJSON_AddItemToObject(sceneArrayItem, KK_SYNC_SCENE_ACTIONS_STR, actionArray);	
+		cJSON *triggerArray = cJSON_CreateArray();
+		kk_get_scenes_trigger_info(triggerArray,sceneId);	
+		cJSON_AddItemToObject(sceneArrayItem, KK_SYNC_SCENE_TRIGGER_STR, triggerArray);		
+		cJSON *conditionArray = cJSON_CreateArray();
+		kk_get_scenes_condition_info(conditionArray,sceneId);	
+		cJSON_AddItemToObject(sceneArrayItem, KK_SYNC_SCENE_CONDITION_STR, conditionArray);				
+		cJSON_AddItemToArray(sceneArray, sceneArrayItem);			
+	}			
+	cJSON_AddItemToObject(data, KK_SYNC_SCENE_STR, sceneArray);	
+	sqlite3_free(sqlCmd);
+    sqlite3_finalize(stmt);
+	return SUCCESS_RETURN;		
+}
+static int kk_get_ccu_properties(cJSON *property)
+{
+	char *sqlCmd = NULL;
+	char *zErrMsg = 0;
+	sqlite3_stmt *stmt;	
+	char *propertyStr = NULL;
+	char *valueStr = NULL;
+	int valueType = 0;
+	kk_sync_ctx_t *ctx = _kk_sync_get_ctx();
+	if(property == NULL){
+		return FAIL_RETURN;
+	}
+	
+	_kk_sync_lock();
+	sqlCmd = sqlite3_mprintf("select * from PropertiesInfo WHERE devType = '%d' ",KK_DM_DEVICE_CCU);	
+	sqlite3_prepare_v2(ctx->pDb, sqlCmd, strlen(sqlCmd), &stmt, NULL);
+	while(sqlite3_step(stmt) == SQLITE_ROW){
+        propertyStr = sqlite3_column_text(stmt, DB_IDENTIFITER);
+		valueType = sqlite3_column_int(stmt, DB_VALUETYPE);
+		valueStr = sqlite3_column_text(stmt, DB_VALUE);
+		if(valueType == KK_TSL_DATA_TYPE_TEXT){
+			cJSON_AddStringToObject(property, propertyStr, valueStr);
+		}else if(valueType == KK_TSL_DATA_TYPE_INT||
+            valueType == KK_TSL_DATA_TYPE_ENUM||
+            valueType == KK_TSL_DATA_TYPE_BOOL){
+			cJSON_AddNumberToObject(property, propertyStr, atoi(valueStr));
+		}
+	}
+
+	sqlite3_free(sqlCmd);
+    sqlite3_finalize(stmt);
+	_kk_sync_unlock();
+	return SUCCESS_RETURN;
+}
+/************************************************************
+*功能描述：检查设备是否有重复
+*输入参数：deviceCode：设备deviceCode
+*输出参数：无
+*返 回 值：1:存在；0：不存在
+*其他说明：
+*************************************************************/
+char *kk_sync_get_info()
+{
+	char ccu_deviceCode[DEVICE_CODE_MAXLEN] = {0};
+	char ccu_productCode[PRODUCT_CODE_MAXLEN] = {0};	
+	char version[32] = {0};	
+	char cloudstatus_str[16] = {0};	
+	cJSON *root=cJSON_CreateObject();
+	cJSON_AddStringToObject(root,KK_SYNC_CODE_STR,"0");
+	cJSON *data = cJSON_CreateObject();
+	cJSON_AddItemToObject(root, KK_SYNC_DATA_STR, data);
+    
+	kk_get_rooms_info(data);
+	kk_get_devices_info(data);
+	kk_get_scenes_info(data);
+	HAL_GetDevice_Code(ccu_deviceCode);
+	HAL_GetProduct_Code(ccu_productCode);	
+	HAL_GetVersion(version);	
+	cJSON_AddStringToObject(data, KK_SYNC_DEVICECODE_STR,ccu_deviceCode);
+	cJSON_AddStringToObject(data, KK_SYNC_NANE_STR, "newccu");	
+	sprintf(cloudstatus_str, "%d", kk_get_cloudstatus());
+	cJSON_AddStringToObject(data, KK_SYNC_ONLINE_STR, cloudstatus_str);	
+	cJSON_AddStringToObject(data, KK_SYNC_PRODUCTCODE_STR, ccu_productCode);	
+	cJSON_AddStringToObject(data, KK_SYNC_VERSION_STR, version);
+	cJSON *property = cJSON_CreateObject();
+	kk_get_ccu_properties(property);	
+	cJSON_AddItemToObject(data, KK_SYNC_PROPERTY_STR, property);
+	char *out=cJSON_Print(root);
+	printf("kk_sync_get_info:%s\n",out);
+	cJSON_Delete(root); 
+	free(out);	
+	return NULL;
+}
+

midware/midware/dm/kk_sync_data.h

+#ifndef _KK_SYNC_DATA_H_
+#define _KK_SYNC_DATA_H_
+#include "kk_tsl_common.h"
+#define KK_SYNC_CODE_STR                    "code"
+#define KK_SYNC_DATA_STR                    "data"
+#define KK_SYNC_ROOMS_STR                   "rooms"
+#define KK_SYNC_ROOMID_STR                  "roomId"
+#define KK_SYNC_DEVICES_STR                 "devices"
+#define KK_SYNC_DEVICECODE_STR              "deviceCode"
+#define KK_SYNC_NANE_STR                    "name"
+#define KK_SYNC_SCENEID_STR                 "sceneId"
+#define KK_SYNC_SCENE_STR                   "scenes"
+#define KK_SYNC_VERSION_STR                 "firmwareVersion"
+#define KK_SYNC_MAC_STR                     "mac"
+#define KK_SYNC_ONLINE_STR                  "onlineStatus"
+#define KK_SYNC_PRODUCTCODE_STR             "productCode"
+#define KK_SYNC_PROPERTY_STR                "properties"
+#define KK_SYNC_SN_STR                      "sn"
+#define KK_SYNC_STATUS_STR                  "status"
+#define KK_SYNC_SCENE_DELAY_STR                  "delay"
+#define KK_SYNC_SCENE_EPNUM_STR                  "epNum"
+#define KK_SYNC_SCENE_PROPERTYNAME_STR                  "propertyName"
+#define KK_SYNC_SCENE_PROPERTYVALUE_STR                  "propertyValue"
+#define KK_SYNC_SCENE_TYPE_STR                  "type"
+#define KK_SYNC_SCENE_ACTIONS_STR                  "actions"
+#define KK_SYNC_SCENE_ENABLE_STR                  "enable"
+#define KK_SYNC_SCENE_SCENETYPE_STR                  "sceneType"
+#define KK_SYNC_SCENE_TRIGGER_STR                  "trigger"
+#define KK_SYNC_SCENE_ITEMS_STR                  "items"
+#define KK_SYNC_SCENE_CONDITION_STR              "condition"
+#define KK_SYNC_SCENE_COMPARETYPE_STR            "compareType"
+#define KK_SYNC_SCENE_COMPAREValue_STR           "compareValue"
+#define KK_SYNC_SCENE_STARTTIME_STR              "startTime"
+#define KK_SYNC_SCENE_ENDTIME_STR                "endTime"
+#define KK_SYNC_SCENE_CROSSDAY_STR              "crossDay"
+#define KK_SYNC_SCENE_REPEATDAY_STR                "repeat_days"
+#endif