【修改内容】修改在线离线机制，目前采用主机上电后会主动查询子设备的机制

【提交人】陈伟灿

midware/midware/dm/kk_dm_heartbeat.c

@@ -11,56 +11,15 @@ typedef struct {
     void *mutex;
 	void *hearbeat_thread;
     int hearbeat_thread_running;	
-    //struct list_head dev_list;	
+    struct list_head gw_status_list;	
 } kk_heartbeat_ctx_t;
-#if 0
+
 typedef struct {
-    unsigned int timerstamp;
+    int isOnline;
+	int starttime;
 	char deviceCode[DEVICE_CODE_MAXLEN];
 	struct list_head linked_list;
-} kk_dev_heartbeat_node_t;
-static int _kk_add_heartbeat_node(const char* deviceCode,unsigned int timestamp)
-{
-    kk_heartbeat_ctx_t *ctx = _kk_heartbeat_get_ctx();
-    kk_dev_heartbeat_node_t *node = NULL;
-
-    node = malloc(sizeof(kk_dev_heartbeat_node_t));
-    if (node == NULL) {
-        return MEMORY_NOT_ENOUGH;
-    }
-	_kk_heartbeat_lock();
-	memset(node,0x0,sizeof(kk_dev_heartbeat_node_t));
-	memcpy(node->deviceCode,deviceCode,strlen(deviceCode));
-	node->timerstamp = timestamp;
-    INIT_LIST_HEAD(&node->linked_list);
-    list_add_tail(&node->linked_list, &ctx->dev_list);
-	_kk_heartbeat_unlock();
-	return SUCCESS_RETURN;
-
-
-
-}
-int kk_heartbeat_update_time(const char deviceCode[DEVICE_CODE_MAXLEN],unsigned int timestamp)
-{
-    kk_heartbeat_ctx_t *ctx = _kk_heartbeat_get_ctx();
-    kk_dev_heartbeat_node_t *search_node = NULL;
-
-	_kk_heartbeat_lock();
-    list_for_each_entry(search_node, &ctx->dev_list, linked_list, kk_dev_heartbeat_node_t) {
-        if ( (strlen(search_node->deviceCode) == strlen(deviceCode)) &&
-            (memcmp(search_node->deviceCode, deviceCode, strlen(deviceCode)) == 0)) {
-            search_node->timerstamp = timestamp;
-			_kk_heartbeat_unlock();
-            return SUCCESS_RETURN;
-        }
-    }
-	_kk_add_heartbeat_node(deviceCode,timestamp);
-	_kk_heartbeat_unlock();
-	return FAIL_RETURN;
-
-}
-
-#endif
+} kk_gw_status_ctx_t;
 
 static kk_heartbeat_ctx_t s_kk_heartbeat_ctx = {0};
 static kk_heartbeat_ctx_t *_kk_heartbeat_get_ctx(void)
@@ -88,13 +47,51 @@ void *kk_heartbeat_yield(void *args)
 {
     kk_heartbeat_ctx_t *ctx = _kk_heartbeat_get_ctx();
 	uint64_t current_time = 0;
-    dm_mgr_dev_node_t *search_node = NULL;	
+	int res = 0;
+    dm_mgr_dev_node_t *node = NULL;	
+	kk_gw_status_ctx_t *gw = NULL;	
     while (ctx->hearbeat_thread_running) {
-		current_time = HAL_UptimeMs() - s_start_time;
+		current_time = HAL_GetTime();
+
 		_kk_heartbeat_lock();
-		dm_mgr_check_heartbeat_timeout(current_time);
+	    if (!list_empty(&ctx->gw_status_list)) {
+
+			list_for_each_entry(gw, &ctx->gw_status_list, linked_list, kk_gw_status_ctx_t){
+				if(gw->isOnline){
+					list_del(&gw->linked_list);
+					
+					//kk_subDev_send_property_get(gw->deviceCode);
+					free(gw);
+				}
+				else{
+					res = dm_mgr_get_device_by_devicecode(gw->deviceCode,&node);
+				    if (res != SUCCESS_RETURN) {
+						ERROR_PRINT("ERROR [%s][%d] res:%d\n",__FUNCTION__,__LINE__,res);
+				    }			
+					if(node->hb_timeout == 0){
+						node->hb_timeout = DEFAULT_HEARTBEAT_TIMEOUT;
+					}
+					/*开机如果一直没有收到网关reply,等待到超时到后发送超时到云端*/
+					if((current_time - gw->starttime) >= node->hb_timeout){
+						//printf("&&&&&&&&&&&&&&&&&&&&&&[%s][%d]\n",__FUNCTION__,__LINE__);
+						INFO_PRINT("GW is off line now!!! deviceCode:%s\n",node->deviceCode);
+						dm_mgr_set_dev_onoffline(node,1);
+						list_del(&gw->linked_list);
+						free(gw);
+					}	
+					else{
+						/*先下发网关属性获取，判断网关是否在线*/
+						kk_msg_execute_property_get(node);
+					}
+
+				}
+			}
+	    }
 		_kk_heartbeat_unlock();
-		sleep(30);
+
+		dm_mgr_check_heartbeat_timeout(current_time);
+		sleep(1);
+
     }
     return NULL;
 }
@@ -109,6 +106,7 @@ int kk_heartbeat_init(void)
         return FAIL_RETURN;
     }
     /* Init Device Id*/
+    INIT_LIST_HEAD(&ctx->gw_status_list);	
     ctx->hearbeat_thread_running = 1;
 	s_start_time = HAL_UptimeMs();
 
@@ -125,4 +123,48 @@ int kk_heartbeat_init(void)
 
 }
 
+int kk_dm_gw_status_check_push(const char *deviceCode)
+{
+	kk_gw_status_ctx_t *gw = NULL;
+    kk_heartbeat_ctx_t *ctx = _kk_heartbeat_get_ctx();
+
+	if(deviceCode == NULL){
+		ERROR_PRINT("kk_dm_gw_status_check_push Failed\n");
+        return INVALID_PARAMETER;
+	}
+	gw = malloc(sizeof(kk_gw_status_ctx_t));
+    if (gw == NULL) {
+		ERROR_PRINT("kk_dm_gw_status_check_push malloc Failed\n");
+        return MEMORY_NOT_ENOUGH;
+    }
+    memset(gw, 0, sizeof(kk_gw_status_ctx_t));	
+	_kk_heartbeat_lock();
+	memcpy(gw->deviceCode,deviceCode,strlen(deviceCode));	
+	gw->isOnline = 0;
+	gw->starttime = HAL_GetTime();
+    INIT_LIST_HEAD(&gw->linked_list);
+    list_add_tail(&gw->linked_list, &ctx->gw_status_list);	
+	_kk_heartbeat_unlock();
+	return SUCCESS_RETURN;
+}
+
+int kk_dm_gw_status_update_online(const char *deviceCode)
+{
+	kk_gw_status_ctx_t *gw = NULL;
+    kk_heartbeat_ctx_t *ctx = _kk_heartbeat_get_ctx();
+	
+	_kk_heartbeat_lock();
+	list_for_each_entry(gw,&ctx->gw_status_list,linked_list,kk_gw_status_ctx_t){
+		if(0 == strcmp(gw->deviceCode,deviceCode))
+		{
+			INFO_PRINT("kk_dm_gw_status_update_online find!!!\n");
+			gw->isOnline = 1;
+			_kk_heartbeat_unlock();
+			return SUCCESS_RETURN;
+		}
+	}
+
+	_kk_heartbeat_unlock();
+	return FAIL_RETURN;
+}
 

midware/midware/dm/kk_dm_mng.c

@@ -250,7 +250,7 @@ int dm_mgr_device_create(_IN_ int dev_type,_IN_ char productCode[PRODUCT_CODE_MA
     if (dev_type != KK_DM_DEVICE_CCU && fatherDeviceCode != NULL) {
         memcpy(node->fatherDeviceCode, fatherDeviceCode, strlen(fatherDeviceCode));
     }
-	node->timestamp = 0;
+	node->timestamp = HAL_GetTime();
     //node->dev_status = IOTX_DM_DEV_STATUS_AUTHORIZED;
     //if(strcmp(productCode,"1035") == 0){
 		//tsl_str = kk_load_json("130", dev_type);
@@ -394,36 +394,46 @@ int dm_mgr_update_timestamp_by_devicecode(_IN_ char deviceCode[DEVICE_CODE_MAXLE
     ERROR_PRINT("Device Not Found, deviceCode: %s\n", deviceCode);
     return FAIL_RETURN;
 }
-#define TEST_TIMEOUT     600000 // ten minutes
+
+int dm_mgr_set_dev_onoffline(dm_mgr_dev_node_t *node,int isOffline)
+{
+	if(node == NULL){
+		return INVALID_PARAMETER;
+	}
+	if(isOffline){
+		INFO_PRINT("---------->dev timeout,send offline\n");
+		node->isOffline = 1;
+		iotx_dm_dev_offline(node->devid);
+		kk_subDev_update_offline(node->isOffline,node->deviceCode);
+	}
+	else{
+		INFO_PRINT("---------->dev online,send online\n");
+		node->isOffline = 0;
+		iotx_dm_dev_online(node->devid);
+		kk_subDev_update_offline(node->isOffline,node->deviceCode);
+		/*如果网关在线，下发对应子设备的属性获取*/
+		if(node->dev_type == KK_DM_DEVICE_GATEWAY){
+			kk_subDev_send_property_get(node->deviceCode);
+		}
+	}
+	return SUCCESS_RETURN;
+}
+
 int dm_mgr_check_heartbeat_timeout(uint64_t timestamp)
 {
     dm_mgr_ctx *ctx = _dm_mgr_get_ctx();
     dm_mgr_dev_node_t *search_node = NULL;
-
 	_dm_mgr_mutex_lock();
     list_for_each_entry(search_node, &ctx->dev_list, linked_list, dm_mgr_dev_node_t) {
 		if(search_node->dev_type == KK_DM_DEVICE_CCU){
 			continue;
 		}
 		if(search_node->hb_timeout == 0){
-			search_node->hb_timeout = TEST_TIMEOUT;
+			search_node->hb_timeout = DEFAULT_HEARTBEAT_TIMEOUT;
 		}
-		if((timestamp - search_node->timestamp) >= search_node->hb_timeout/*search_node->hb_timeout*/){
-			
+		if(((int)timestamp - (int)search_node->timestamp) >= search_node->hb_timeout/*search_node->hb_timeout*/){
 			if(search_node->isOffline == 0){
-				INFO_PRINT("---------->dev timeout,send offline\n");
-				search_node->isOffline = 1;
-				iotx_dm_dev_offline(search_node->devid);
-				kk_subDev_update_offline(search_node->isOffline,search_node->deviceCode);
-			}
-
-		}
-		else{
-			if(search_node->isOffline == 1 && search_node->timestamp != 0) {//need send online 
-				INFO_PRINT("---------->dev online again,send online\n");
-				search_node->isOffline = 0;
-				iotx_dm_dev_online(search_node->devid);
-				kk_subDev_update_offline(search_node->isOffline,search_node->deviceCode);
+				dm_mgr_set_dev_onoffline(search_node,1);
 			}
 		}
     }

midware/midware/dm/kk_dm_msg.c

@@ -1060,6 +1060,88 @@ int kk_msg_execute_property_set(const char *productCode,const char *deviceCode,c
 
 }
 
+int kk_msg_execute_property_get(dm_mgr_dev_node_t *node)
+{
+	char *method = "thing.service.property.get";
+	char *req_info = NULL,*payload = NULL;
+	int req_info_len = 0,payload_len = 0;
+	int res = 0;
+	int needFree = 0;
+	int i = 0,j = 0,serviceNum = 0;
+	char *paramS = NULL;
+
+	if(node == NULL){
+		return INVALID_PARAMETER;
+	}
+	req_info_len = strlen(DM_MSG_INFO)+10+strlen(node->productCode)+strlen(node->productCode)+strlen(KK_THING_SERVICE_PROPERTY_SET)+1;
+    req_info = malloc(req_info_len);
+    if (req_info == NULL) {
+        return MEMORY_NOT_ENOUGH;
+    }
+    memset(req_info, 0, req_info_len);
+    snprintf(req_info, req_info_len, DM_MSG_INFO, KK_THING_SERVICE_PROPERTY_GET,node->productCode, node->deviceCode);
+
+	cJSON *rootParam = cJSON_CreateObject();
+	cJSON *array = cJSON_CreateArray();
+
+	serviceNum = node->dev_shadow->service_number;
+	for(i = 0; i < serviceNum; i++){ 
+		kk_tsl_service_t *item = node->dev_shadow->services + i;
+		if(!strcmp(item->identifier,"get")){
+			
+			int inputNum = item->input_data_number;
+			if(inputNum == 0){
+				paramS = "{}";
+				
+			}else{
+				for(j = 0; j < inputNum; j++){
+					kk_tsl_data_t *inputItem = item->input_datas + j;
+					cJSON_AddItemToArray(array,cJSON_CreateString(inputItem->identifier));
+				}
+				cJSON_AddItemToObject(rootParam, KK_TSL_KEY_IDENTIFIER, array);
+				paramS = cJSON_Print(rootParam);
+				needFree = 1;
+			}
+			break;
+		}	
+	}
+
+    payload_len = strlen(DM_MSG_REQUEST) + 10 + strlen(DM_MSG_VERSION) + strlen(paramS) + strlen(
+                              method) + 1 + 20;
+    payload = malloc(payload_len);
+    if (payload == NULL) {
+		free(req_info);
+        return MEMORY_NOT_ENOUGH;
+    }
+    memset(payload, 0, payload_len);
+    snprintf(payload, payload_len, DM_MSG_REQUEST, iotx_report_id(),
+                 DM_MSG_VERSION, paramS,HAL_GetTime(), method);
+    cJSON *root=cJSON_CreateObject();
+    cJSON* infoObj = cJSON_Parse(req_info);
+    cJSON* payloadObj = cJSON_Parse(payload);
+    cJSON_AddItemToObject(root, "info", infoObj);
+    cJSON_AddItemToObject(root, "payload",payloadObj);
+	void *buf = cJSON_Print(root);
+	printf("------------->buf:%s\n",buf);
+	if(node->dev_type == KK_DM_DEVICE_GATEWAY)
+		kk_sendData2gw(buf, strlen(buf), node->deviceCode);
+	else
+		kk_sendData2gw(buf, strlen(buf), node->fatherDeviceCode);
+
+	if(needFree){
+		free(paramS);
+	}	
+	free(buf);
+	free(req_info);
+	free(payload);
+
+	cJSON_Delete(root);
+	cJSON_Delete(rootParam);
+	return SUCCESS_RETURN;
+
+}
+
+
 int kk_msg_parse_productType(char *str,char *productType)
 {
 	cJSON *item = NULL;

midware/midware/dm/kk_dm_msg.h

@@ -72,6 +72,7 @@ const char DM_MSG_INFO[] DM_READ_ONLY;
 #define KK_THING_SERVICE_ADDSCENC                 "/thing/service/addScene"
 #define KK_THING_SERVICE_DELETESCENC              "/thing/service/deleteScene"
 #define KK_THING_SERVICE_UPDATESCENC              "/thing/service/updateScene"
+#define KK_THING_SERVICE_PROPERTY_GET_REPLY       "/thing/service/property/get_reply"
 
 #define KK_THING_EVENT_MESSAGE                    "/thing/event/"
 #define KK_THING_EVENT_POST                       "/post"

midware/midware/dm/kk_sub_db.c

@@ -96,18 +96,20 @@ static int _kk_load_subDevice(void)
 {
 	const char *searchCmd = "select * from SubDeviceInfo;";	
 	sqlite3_stmt *stmt;	
+	int deviceType = 0;
     kk_subDb_ctx_t *ctx = _kk_subDb_get_ctx();
 	int devId = 0,heartbeat = 0;
 	int res = 0;
 	_kk_subDb_lock();
 	sqlite3_prepare_v2(ctx->pDb, searchCmd, strlen(searchCmd), &stmt, NULL);
 	while(sqlite3_step(stmt) == SQLITE_ROW){
-	   res = dm_mgr_subdev_create(sqlite3_column_int(stmt, DB_DEVTYPE),
+	   deviceType = sqlite3_column_int(stmt, DB_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_int(stmt, DB_ONLINE),&devId,&heartbeat);
+	   					1,&devId,&heartbeat);
 	
 	   if(res != SUCCESS_RETURN){
 		   ERROR_PRINT("[%s][%d]dm_mgr_subdev_create FAIL!!!\n",__FUNCTION__,__LINE__);
@@ -123,8 +125,11 @@ static int _kk_load_subDevice(void)
 	   kk_property_sync_values(sqlite3_column_text(stmt, DB_DEVICECODE));
 	   usleep(100000);
 
+	   if(deviceType == KK_DM_DEVICE_GATEWAY){
+			kk_dm_gw_status_check_push(sqlite3_column_text(stmt, DB_DEVICECODE));
+	   }
 	   //post the property to cloud
-	   dm_msg_thing_property_post_all(sqlite3_column_text(stmt, DB_DEVICECODE));
+	   //dm_msg_thing_property_post_all(sqlite3_column_text(stmt, DB_DEVICECODE));
 	    //kk_dm_ota_report_version(devId,sqlite3_column_text(stmt, DB_VERSION));//post version
 	   //usleep(100000);
     }	
@@ -302,7 +307,46 @@ int kk_subDev_update_auth(int isAuth,const char *deviceCode)
 	return SUCCESS_RETURN;
 }
 
+int kk_subDev_send_property_get(const char *fatherDeviceCode)
+{
+	int res = 0;
+	sqlite3_stmt *stmt;
+	char *sqlCmd = NULL;
+	char *pDeviceCode = NULL;
+	dm_mgr_dev_node_t *node = NULL;		
+    kk_subDb_ctx_t *ctx = _kk_subDb_get_ctx();
+	const char *searchCmd = "select * from SubDeviceInfo WHERE fatherDeviceCode = '%s'";	
 
+	if(fatherDeviceCode == NULL){
+		ERROR_PRINT("ERROR [%s][%d]\n",__FUNCTION__,__LINE__);
+		return INVALID_PARAMETER;
+	}
+	sqlCmd = sqlite3_mprintf(searchCmd,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);
+	   res = dm_mgr_get_device_by_devicecode(pDeviceCode,&node);
+	   if (res != SUCCESS_RETURN) {
+		   ERROR_PRINT("ERROR [%s][%d] res:%d\n",__FUNCTION__,__LINE__,res);
+		   continue;
+	   }
+	   //if(!strcmp(pDeviceCode,"842E14FFFE9A26CA")){
+			//continue;
+	   //}
+	   /*发送之前先置为offline*/
+	   node->isOffline = 1;
+	   printf("[%s][%d]\n",__FUNCTION__,__LINE__);
+	   kk_msg_execute_property_get(node);
+	   usleep(100000);
+    }
+
+	sqlite3_finalize(stmt);
+	sqlite3_free(sqlCmd);
+	return SUCCESS_RETURN;
+
+
+}
 
 
 

midware/midware/midware.c

@@ -315,20 +315,22 @@ void kk_platMsg_handle(void* data, char* chalMark){
 		msgType = cJSON_GetObjectItem(info, MSG_TYPE_STR);
 		info_dcode = cJSON_GetObjectItem(info, MSG_DEVICE_CODE_STR);
 
-        jsonPay = cJSON_GetObjectItem(payload, MSG_PARAMS_STR);
        
-		if (msgType == NULL || info_dcode == NULL || jsonPay == NULL){
+        
+		if (msgType == NULL || info_dcode == NULL){
             ERROR_PRINT("msgType info_dcode or jsonPay params are error\n");
             goto error;
 		}
 
         if (chalMark != NULL){
-		    dm_mgr_update_timestamp_by_devicecode(chalMark,HAL_UptimeMs()-s_start_time);
+		    dm_mgr_update_timestamp_by_devicecode(chalMark,HAL_GetTime());
 		}
 
-        dm_mgr_update_timestamp_by_devicecode(info_dcode->valuestring,HAL_UptimeMs()-s_start_time);
+
+        dm_mgr_update_timestamp_by_devicecode(info_dcode->valuestring,HAL_GetTime());
 		
         if (strcmp(msgType->valuestring, KK_THING_TOPO_ADD_MSG)==0){
+			jsonPay = cJSON_GetObjectItem(payload, MSG_PARAMS_STR);
             proCode = cJSON_GetObjectItem(jsonPay, MSG_PRODUCT_CODE_STR);
             devCode = cJSON_GetObjectItem(jsonPay, MSG_DEVICE_CODE_STR);
 			mac = cJSON_GetObjectItem(jsonPay, "mac");
@@ -345,10 +347,12 @@ void kk_platMsg_handle(void* data, char* chalMark){
 			}else{
                 kk_mid_subdev_add(KK_DM_DEVICE_SUBDEV,proCode->valuestring,devCode->valuestring, mac->valuestring,info_dcode->valuestring);
 			}
-			dm_mgr_update_timestamp_by_devicecode(devCode->valuestring,HAL_UptimeMs()-s_start_time);
+			dm_mgr_update_timestamp_by_devicecode(devCode->valuestring,HAL_GetTime());
                 
-        }else if (strstr(msgType->valuestring, KK_THING_TOPO_BATCH_ADD_MSG) != NULL){
+        }
+		else if (strstr(msgType->valuestring, KK_THING_TOPO_BATCH_ADD_MSG) != NULL){
         	kk_ipc_send(IPC_MID2APP,data,strlen(data));
+			jsonPay = cJSON_GetObjectItem(payload, MSG_PARAMS_STR);
 			cJSON *devices = cJSON_GetObjectItem(jsonPay, MSG_TOPO_CHANGE_DEVICES_STR);
 			cJSON * item = devices->child;
 			while(item != NULL){
@@ -362,32 +366,43 @@ void kk_platMsg_handle(void* data, char* chalMark){
             
         }else if (strstr(msgType->valuestring, KK_THING_PROPERTY_POST) != NULL){
             INFO_PRINT("save property and send to cloud \n");
+			jsonPay = cJSON_GetObjectItem(payload, MSG_PARAMS_STR);
             char* outstr = cJSON_Print(payload);
-			kk_tsl_t *dev_shadow = NULL;
-			dm_mgr_get_device_shadow_by_devicecode(info_dcode->valuestring,&dev_shadow);
-            kk_tsl_property_set_by_shadow(dev_shadow, outstr, strlen(outstr)+1);
+			dm_mgr_dev_node_t *search_node = NULL;
+			dm_mgr_get_device_by_devicecode(info_dcode->valuestring,&search_node);
+			if(search_node->isOffline){
+				/*如果是离线状态，上报在线给云端*/
+				dm_mgr_set_dev_onoffline(search_node,0);
+			}
+            kk_tsl_property_set_by_shadow(search_node->dev_shadow, outstr, strlen(outstr)+1);
 			dm_msg_thing_property_post_by_identify(info_dcode->valuestring,jsonPay);
 			kk_scene_iftt_check(info_dcode->valuestring,jsonPay);
             free(outstr);
         }else if(strstr(msgType->valuestring, KK_THING_TOPO_DELETE_MSG) != NULL){
 			INFO_PRINT("kk_platMsg_handle data: handle delete\n");
+			jsonPay = cJSON_GetObjectItem(payload, MSG_PARAMS_STR);
 			devCode = cJSON_GetObjectItem(jsonPay, MSG_DEVICE_CODE_STR);
 			kk_ipc_send(IPC_MID2APP,data,strlen(data)+1);
 			dm_mgr_subdev_delete(devCode->valuestring);
 			
 		}else if(strstr(msgType->valuestring, KK_THING_EVENT_MESSAGE) != NULL && \
 			strstr(msgType->valuestring, KK_THING_EVENT_POST) != NULL){
-			kk_tsl_t *dev_shadow = NULL;
+			dm_mgr_dev_node_t *node = NULL;
 			int idx = 0;
 			kk_tsl_event_t *eventItem =NULL;
 			char tmpStr[128] = {0};
 			cJSON * itemStr = NULL;
-			res = dm_mgr_get_device_shadow_by_devicecode(info_dcode->valuestring,&dev_shadow);
+			jsonPay = cJSON_GetObjectItem(payload, MSG_PARAMS_STR);
+			res = dm_mgr_get_device_by_devicecode(info_dcode->valuestring,&node);
 			if (res < SUCCESS_RETURN) {
 		        goto error;
 		    }
-			for(idx = 0; idx < dev_shadow->event_number; idx++){
-				eventItem = dev_shadow->events + idx;
+			if(node->isOffline){
+				/*如果是离线状态，上报在线给云端*/
+				dm_mgr_set_dev_onoffline(node,0);
+			}			
+			for(idx = 0; idx < node->dev_shadow->event_number; idx++){
+				eventItem = node->dev_shadow->events + idx;
 				if(eventItem != NULL){
 					if(strcmp(eventItem->identifier,MSG_PROPERTY_STR) != 0 &&
 						eventItem->output_data_number > 0){
@@ -412,10 +427,11 @@ void kk_platMsg_handle(void* data, char* chalMark){
 									kk_tsl_set_value(kk_tsl_set_event_output_value,dev_shadow,tmpStr,&itemStr->valueint,NULL);	
 								}
 								#else
-								kk_tsl_set_value(kk_tsl_set_event_output_value,dev_shadow,tmpStr,&itemStr->valueint,NULL);	
+								kk_tsl_set_value(kk_tsl_set_event_output_value,node->dev_shadow,tmpStr,&itemStr->valueint,NULL);	
 								#endif
 								INFO_PRINT("kk_platMsg_handle data: event post\n");
 								dm_msg_thing_event_post(info_dcode->valuestring,eventItem->identifier);
+								kk_scene_iftt_check(info_dcode->valuestring,jsonPay);
 							}							
 						}
 						
@@ -431,8 +447,10 @@ void kk_platMsg_handle(void* data, char* chalMark){
 					}
 				}
 			}
-		}else if(strstr(msgType->valuestring, KK_THING_TOPO_BATCH_DELETE_MSG) != NULL){
+		}
+		else if(strstr(msgType->valuestring, KK_THING_TOPO_BATCH_DELETE_MSG) != NULL){
 			kk_ipc_send(IPC_MID2APP,data,strlen(data));
+			jsonPay = cJSON_GetObjectItem(payload, MSG_PARAMS_STR);
 			cJSON *devices = cJSON_GetObjectItem(jsonPay, MSG_TOPO_CHANGE_DEVICES_STR);
 			cJSON * item = devices->child;
 			while(item != NULL){
@@ -441,7 +459,26 @@ void kk_platMsg_handle(void* data, char* chalMark){
 				item = item->next;
 			}			
 			
-		}else{
+		}
+		else if(strstr(msgType->valuestring, KK_THING_SERVICE_PROPERTY_GET_REPLY) != NULL){
+			INFO_PRINT("kk_platMsg_handle data: KK_THING_SERVICE_PROPERTY_GET_REPLY\n");
+			int res = 0;
+			dm_mgr_dev_node_t *node = NULL;
+			res = dm_mgr_get_device_by_devicecode(info_dcode->valuestring,&node);
+		    if (res != SUCCESS_RETURN) {
+				ERROR_PRINT("ERROR [%s][%d] res:%d\n",__FUNCTION__,__LINE__,res);
+		        return;
+		    }	
+			/*开机先获取网关属性，网关返回relay，置网关状态在线*/
+			if(node->dev_type == KK_DM_DEVICE_GATEWAY){
+				kk_dm_gw_status_update_online(info_dcode->valuestring);
+				if(node->isOffline){
+					/*如果是离线状态，上报在线给云端*/
+					dm_mgr_set_dev_onoffline(node,0);
+				}				
+			}
+		}
+		else{
             INFO_PRINT("kk_platMsg_handle data: don't handle it [%s]\n",data);
         
         }
@@ -773,9 +810,9 @@ int main(const int argc, const char **argv)
         kk_ipc_init(IPC_MID2PLAT, mid2p_cb, NULL, "*");
 		
         kk_init_dmproc();
-		
-		kk_subDb_init();
 		kk_heartbeat_init();
+		kk_subDb_init();
+		
 		kk_area_init();	
 		kk_scene_init();
         mid_ctx->g_mid_dispatch_thread_running = 1;

midware/tsl/tsl_handle/kk_tsl_common.h

@@ -81,6 +81,9 @@
 #define KK_TSL_GATAWAY_SN_IDENTIFIER      	   "SN"
 #define KK_TSL_GATAWAY_WHITELIST_IDENTIFIER      	   "WhiteListState"
 
+#define DEFAULT_HEARTBEAT_TIMEOUT      (60*4)// four minutes
+
+
 typedef enum {
     KK_TSL_DATA_TARGET_SERVICE_INPUT_DATA,
     KK_TSL_DATA_TARGET_SERVICE_OUTPUT_DATA

midware/tsl/tsl_handle/kk_tsl_parse.c

@@ -752,6 +752,57 @@ static int _kk_tsl_service_inputdata_parse(_IN_ kk_tsl_t *shadow, _IN_ kk_tsl_da
     return SUCCESS_RETURN;
 }
 
+static int _kk_tsl_service_parse_get_input_identifier(char *str,int count,kk_tsl_data_t *input_datas)
+{
+	char *pstr = str;
+	char *start = NULL;
+	char *end = NULL;
+	int i = 0;
+	int len = 0;
+	char *identifier = NULL;
+	kk_tsl_data_t *input_data = NULL;
+	if(input_datas == NULL){
+		return -1;
+	}
+	for(i = 0; i < count; i++){
+		input_data = input_datas + i;
+		start = strchr(pstr,'"') ;
+		end = strchr(start+1,'"');
+		len = end-start-1;
+		identifier = malloc(len+1);
+		if(identifier == NULL) 
+			return -1;
+		memset(identifier,0x0,len);
+		strncpy(identifier,start+1,len);
+		identifier[len] = '\0';
+		input_data->identifier = identifier;
+		pstr = end + 1;
+	}
+	return 0;
+}
+
+static int _kk_tsl_service_inputdatas_get_parse(_IN_ kk_tsl_t *shadow, _IN_ kk_tsl_service_t *service,
+		_IN_ lite_cjson_t *root)
+{
+	int res = 0, index = 0;
+	lite_cjson_t lite_item;
+	kk_tsl_data_t *input_data = NULL;
+
+	printf("input Number: %d\n", service->input_data_number);
+	if (service->input_data_number == 0) {
+		return SUCCESS_RETURN;
+	}
+
+	//Allocate Memory For Output Datas
+	service->input_datas = malloc((service->input_data_number) * (sizeof(kk_tsl_data_t)));
+	if (service->input_datas == NULL) {
+		return MEMORY_NOT_ENOUGH;
+	}
+	memset(service->input_datas, 0, (service->input_data_number) * (sizeof(kk_tsl_data_t)));
+	_kk_tsl_service_parse_get_input_identifier( root->value,service->input_data_number,service->input_datas);
+	return SUCCESS_RETURN;
+}
+
 static int _kk_tsl_service_inputdatas_parse(_IN_ kk_tsl_t *shadow, _IN_ kk_tsl_service_t *service,
         _IN_ lite_cjson_t *root)
 {
@@ -759,7 +810,7 @@ static int _kk_tsl_service_inputdatas_parse(_IN_ kk_tsl_t *shadow, _IN_ kk_tsl_s
     lite_cjson_t lite_item;
     kk_tsl_data_t *input_data = NULL;
 
-    printf("Number: %d", service->input_data_number);
+    printf("input Number: %d\n", service->input_data_number);
     if (service->input_data_number == 0) {
         return SUCCESS_RETURN;
     }
@@ -791,6 +842,7 @@ static int _kk_tsl_service_parse(_IN_ kk_tsl_t *shadow, _IN_ kk_tsl_service_t *s
 {
     int res = 0;
     lite_cjson_t lite_item;
+	int isGetService = 0;
 
     //Parse Identifier (Mandatory)
     memset(&lite_item, 0, sizeof(lite_cjson_t));
@@ -806,16 +858,18 @@ static int _kk_tsl_service_parse(_IN_ kk_tsl_t *shadow, _IN_ kk_tsl_service_t *s
     //printf("Identifier: %s", service->identifier);
 
     /* Check If Current Service Id Is Set Or Get */
-    if (((strlen(service->identifier) == strlen(KK_TSL_SPECIAL_SERVICE_SET_IDENTIFIER)) &&
+    if ((strlen(service->identifier) == strlen(KK_TSL_SPECIAL_SERVICE_SET_IDENTIFIER)) &&
          (memcmp(service->identifier, KK_TSL_SPECIAL_SERVICE_SET_IDENTIFIER,
-                 strlen(KK_TSL_SPECIAL_SERVICE_SET_IDENTIFIER)) == 0)) ||
-        ((strlen(service->identifier) == strlen(KK_TSL_SPECIAL_SERVICE_GET_IDENTIFIER)) &&
-         (memcmp(service->identifier, KK_TSL_SPECIAL_SERVICE_GET_IDENTIFIER,
-                 strlen(KK_TSL_SPECIAL_SERVICE_GET_IDENTIFIER)) == 0))) {
+                 strlen(KK_TSL_SPECIAL_SERVICE_SET_IDENTIFIER)) == 0)) {
         /* dm_log_info("TSL Special Service Identifier: %s, Ignore It",service->identifier); */
         return SUCCESS_RETURN;
     }
-
+	if((strlen(service->identifier) == strlen(KK_TSL_SPECIAL_SERVICE_GET_IDENTIFIER)) &&
+         (memcmp(service->identifier, KK_TSL_SPECIAL_SERVICE_GET_IDENTIFIER,
+                 strlen(KK_TSL_SPECIAL_SERVICE_GET_IDENTIFIER)) == 0))
+	{
+		isGetService = 1;
+	}
     //Parse Output Data (Optional)
     memset(&lite_item, 0, sizeof(lite_cjson_t));
     res = lite_cjson_object_item(root, KK_TSL_KEY_OUTPUTDATA, strlen(KK_TSL_KEY_OUTPUTDATA), &lite_item);
@@ -832,13 +886,16 @@ static int _kk_tsl_service_parse(_IN_ kk_tsl_t *shadow, _IN_ kk_tsl_service_t *s
     res = lite_cjson_object_item(root, KK_TSL_KEY_INPUTDATA, strlen(KK_TSL_KEY_INPUTDATA), &lite_item);
     if (res == SUCCESS_RETURN && lite_cjson_is_array(&lite_item)) {
         service->input_data_number = lite_item.size;
+
+		if(isGetService && service->input_data_number > 0){
+			res = _kk_tsl_service_inputdatas_get_parse(shadow, service, &lite_item);
+		}else
+		{
 	        res = _kk_tsl_service_inputdatas_parse(shadow, service, &lite_item);
-        if (res != SUCCESS_RETURN) {
-            return FAIL_RETURN;
 		}
     }
 
-    return SUCCESS_RETURN;
+    return res;
 }
 
 static int _kk_tsl_services_parse(_IN_ kk_tsl_t *shadow, _IN_ lite_cjson_t *root)
@@ -1604,7 +1661,7 @@ static int _kk_tsl_heartbeat_parse(_OU_ int *heartbeat, _IN_ lite_cjson_t *root)
     if (res != SUCCESS_RETURN || !lite_cjson_is_string(&lite_item_heartbeat)) {
         return JSON_PARSE_FAILED;
     }
-	*heartbeat = atoi(lite_item_heartbeat.value)*1000;
+	*heartbeat = atoi(lite_item_heartbeat.value);
 	return SUCCESS_RETURN;
 }
 int kk_tsl_create(_IN_ const char *tsl, _IN_ int tsl_len, _OU_ kk_tsl_t **shadow,_OU_ int *heartbeat)