Merge branch 'cwc' into 'master'

【修改内容】增加场景addscene,updatescene以及deletescene的service调用，以及相关的event事件上报

See merge request chenweican/k-sdk!45

common/api/com_api.h

@@ -92,6 +92,38 @@ typedef enum {
 #define MSG_KEYDELETE_NOTIFICATION                  "KeyDeletedNotification"
 #define MSG_KEYMODIFY_NOTIFICATION                  "KeyModifyNotification"
 
+/************************SCENE RELATION*************************/
+#define MSG_SCENE_ARGS               				"args"
+#define MSG_SCENE_NAME               				"name"
+#define MSG_SCENE_SCENCTYPE              		    "sceneType"
+#define MSG_SCENE_ENABLE              		    	"enable"
+#define MSG_SCENE_TRIGGERS              		    "triggers"
+#define MSG_SCENE_ITEMS              		    	"items"
+#define MSG_SCENE_TYPE              		    	"type"
+#define MSG_SCENE_EPNUM              		    	"epNum"
+#define MSG_SCENE_PROPERTYNAME 						"propertyName"
+#define MSG_SCENE_COMPARETYPE						"compareType"
+#define MSG_SCENE_COMPAREVALUE						"compareValue"
+#define MSG_SCENE_CONDITIONS              		    "conditions"
+#define MSG_SCENE_STARTTIME              		    "startTime"
+#define MSG_SCENE_ENDTIME              		    	"endTime"
+#define MSG_SCENE_CROSSDAY              		    "crossDay"
+#define MSG_SCENE_REPEATDAYS              		    "repeat_days"
+#define MSG_SCENE_ACTIONS              		    	"actions"
+#define MSG_SCENE_PROPERTYVALUE              		"propertyValue"
+#define MSG_SCENE_DELAY              				"delay"
+#define MSG_SCENE_SCENEID           				"sceneId"
+#define MSG_SCENE_ADDNOTIFICATION_SCENEID           "addSceneNotification.sceneId"
+#define MSG_SCENE_ADDNOTIFICATION          			"addSceneNotification"
+#define MSG_SCENE_UPDATENOTIFICATION_SCENEID        "updateSceneNotification.sceneId"
+#define MSG_SCENE_UPDATENOTIFICATION          		"updateSceneNotification"
+#define MSG_SCENE_DELETENOTIFICATION_SCENEID        "deleteSceneNotification.sceneId"
+#define MSG_SCENE_DELETENOTIFICATION          		"deleteSceneNotification"
+
+
+
+
+
 
 
 typedef void ipc_cb(void* data, int len, char* chalMark);

common/hal/HAL_OS_linux.c

@@ -123,14 +123,15 @@ uint64_t HAL_GetTime(void)
 }
 
 
-uint64_t HAL_GetTimeMs(void)
+uint64_t HAL_GetTimeMs(char *outStr)
 {
     uint64_t            time_ms;
-    struct timespec     ts;
-
-    clock_gettime(CLOCK_REALTIME, &ts);
-    time_ms = ((uint64_t)ts.tv_sec * (uint64_t)1000) + (ts.tv_nsec / 1000 / 1000);
+    struct timeval tv;
 
+    gettimeofday(&tv, NULL);
+    time_ms = ((uint64_t)tv.tv_sec * (uint64_t)1000) + (tv.tv_usec / 1000 );
+	sprintf(outStr,"%lld",time_ms);
+	
     return time_ms;
 }
 

midware/midware/area/kk_area_handle.c

@@ -173,6 +173,32 @@ int kk_room_delete(const char *roomId)
 	return SUCCESS_RETURN;
 }
 
+static int _kk_check_dev_exist(const char* deviceCode)
+{
+	int isExist = 0;
+	sqlite3_stmt *stmt;
+	char *pDeviceCode = NULL;
+	char *pKeyId = NULL;
+    kk_area_ctx_t *ctx = _kk_area_get_ctx();
+	const char *searchCmd = "select * from AreaDevInfo;";	
+	_kk_area_lock();
+	
+	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){
+	   pDeviceCode = sqlite3_column_text(stmt, DB_DEV_DEVICECODE);
+	   if(!strcmp(deviceCode,pDeviceCode))
+	   {
+		 isExist = 1;
+		 break;
+	   }
+    }
+    //INFO_PRINT("\n");
+	sqlite3_finalize(stmt);
+	_kk_area_unlock();
+	return isExist;
+}
+
 int kk_room_dev_add(const char *roomId,const char *deviceCode,const char *epNum)
 {
 	int res = 0;
@@ -180,11 +206,18 @@ int kk_room_dev_add(const char *roomId,const char *deviceCode,const char *epNum)
 	char *sqlCmd = NULL;
 	char *zErrMsg = 0;
 
-	const char *insertCmd = "insert into AreaDevInfo (roomId, deviceCode, epNum) \
-								values ('%s','%s','%s');";	
+	if(_kk_check_dev_exist(deviceCode)){
+		sqlCmd = sqlite3_mprintf("UPDATE AreaDevInfo SET roomId='%s', epNum='%s' \
+					WHERE deviceCode= '%s'",deviceCode);	
+
+	}
+	else{
+		const char *insertCmd = "insert into AreaDevInfo (roomId, deviceCode, epNum) \
+							values ('%s','%s','%s');";	
+		sqlCmd = sqlite3_mprintf(insertCmd,roomId,deviceCode,epNum);
+	}
 								
 	_kk_area_lock();
-	sqlCmd = sqlite3_mprintf(insertCmd,roomId,deviceCode,epNum);	
 	res = sqlite3_exec(ctx->pDb, sqlCmd, NULL, NULL, &zErrMsg);
 	if( res != SQLITE_OK ){
 	   ERROR_PRINT("SQL error: %s\n", zErrMsg);

midware/midware/dm/kk_dm_msg.c

@@ -777,6 +777,46 @@ int dm_msg_thing_event_post(const char *deviceCode, const char *identifier)
 	}
 	return SUCCESS_RETURN;
 }
+int dm_msg_scene_event_post(const char *deviceCode, const char *identifier,kk_tsl_t *dev_shadow)
+{
+	int res = 0;
+	int nums = 0;
+	int idx = 0; 
+	char *payload = NULL;
+	dm_mgr_dev_node_t *node = NULL; 
+    void *event = NULL;
+	char *method = NULL;
+
+	if(deviceCode == NULL){
+		return FAIL_RETURN;
+	}
+	
+	res = dm_mgr_get_device_by_devicecode(deviceCode, &node);
+	if (res != SUCCESS_RETURN) {
+		return FAIL_RETURN;
+	}
+	payload = kk_tsl_get_post_event_str(dev_shadow,identifier,strlen(identifier));
+	if(payload != NULL){
+	    res = kk_tsl_get_event_by_identifier(dev_shadow, identifier, &event);
+	    if (res != SUCCESS_RETURN) {
+	        free(payload);
+			return FAIL_RETURN;
+
+	    }	
+	    res = kk_tsl_get_event_method(event, &method);
+	    if (res != SUCCESS_RETURN) {
+	        free(payload);
+			return FAIL_RETURN;
+	    }		
+	    dm_mgr_upstream_thing_event_post(node->devid, identifier, strlen(identifier), method, payload, strlen(payload));		
+		free(method);
+		method = NULL;
+		free(payload);
+		payload = NULL;
+	}
+	return SUCCESS_RETURN;
+}
+
 int dm_msg_thing_service_post(const char *deviceCode, const char *identifier)
 {
 	int res = 0;

midware/midware/dm/kk_dm_msg.h

@@ -69,6 +69,9 @@ const char DM_MSG_INFO[] DM_READ_ONLY;
 #define KK_THING_SERVICE_ADDKEY                   "/thing/service/AddKey"
 #define KK_THING_SERVICE_DELETEKEY                "/thing/service/DeleteKey"
 #define KK_THING_SERVICE_MODIFYKEY                "/thing/service/ModifyKey"
+#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_EVENT_MESSAGE                    "/thing/event/"
 #define KK_THING_EVENT_POST                       "/post"

midware/midware/dm/kk_linkkit.c

@@ -472,7 +472,7 @@ static int kk_service_setCountDown_handle(cJSON *params,const char *deviceCode)
     }
 
 	size = kk_service_get_array_size(search_node->dev_shadow);
-	printf("[%s][%d]size:%d\n",__FUNCTION__,__LINE__,size);
+
 	cJSON *LocalTimerArray = cJSON_GetObjectItem(params, MSG_TIMER_SETCOUNTDOWN_COUNTDOWN);	
 	if(LocalTimerArray == NULL){
 		return FAIL_RETURN;
@@ -547,6 +547,7 @@ static int kk_service_addKey_handle(const char *deviceCode,cJSON *param)
 	kk_tsl_set_value(kk_tsl_set_event_output_value,node->dev_shadow,MSG_KEYADD_NOTIFICATION_KEYNAME,NULL,KeyName->valuestring);
 	kk_tsl_set_value(kk_tsl_set_event_output_value,node->dev_shadow,MSG_KEYADD_NOTIFICATION_KEYEFFECTIVE,&IsValid->valueint,NULL);
 	kk_tsl_set_value(kk_tsl_set_event_output_value,node->dev_shadow,MSG_KEYADD_NOTIFICATION_KEYEXPIRE,&IsValid->valueint,NULL);
+	dm_msg_thing_event_post(deviceCode,MSG_KEYADD_NOTIFICATION);
 
 	return SUCCESS_RETURN;
 }
@@ -587,6 +588,7 @@ static int kk_service_modifyKey_handle(const char *deviceCode,cJSON *param)
 	kk_tsl_set_value(kk_tsl_set_event_output_value,node->dev_shadow,MSG_KEYMODIFY_NOTIFICATION_KEYNAME,NULL,KeyName->valuestring);
 	kk_tsl_set_value(kk_tsl_set_event_output_value,node->dev_shadow,MSG_KEYMODIFY_NOTIFICATION_KEYEFFECTIVE,&IsValid->valueint,NULL);
 	kk_tsl_set_value(kk_tsl_set_event_output_value,node->dev_shadow,MSG_KEYMODIFY_NOTIFICATION_KEYEXPIRE,&IsValid->valueint,NULL);
+	dm_msg_thing_event_post(deviceCode,MSG_KEYMODIFY_NOTIFICATION);
 
 	return SUCCESS_RETURN;
 }
@@ -614,28 +616,98 @@ static int kk_service_deleteKey_handle(const char *deviceCode,cJSON *param)
 	kk_tsl_set_value(kk_tsl_set_event_output_value,node->dev_shadow,MSG_KEYDELETE_NOTIFICATION_KEYID,NULL,keyId->valuestring);		
 	kk_tsl_set_value(kk_tsl_set_event_output_value,node->dev_shadow,MSG_KEYDELETE_NOTIFICATION_KEYTYPE,&KeyType->valueint,NULL);	
 	kk_tsl_set_value(kk_tsl_set_event_output_value,node->dev_shadow,MSG_KEYDELETE_NOTIFICATION_KEYROLE,&KeyRole->valueint,NULL);
+	dm_msg_thing_event_post(deviceCode,MSG_KEYDELETE_NOTIFICATION);
 
 	return SUCCESS_RETURN;
 }
 
+static int kk_service_addScene_handle(const char *deviceCode,cJSON *param)
+{
+	int res = 0;
+	char sceneId[32] = {0};
+	kk_tsl_t *pSceneShadow = NULL;
+	if(deviceCode == NULL || param == NULL){
+		return INVALID_PARAMETER;
+	}
+	cJSON *args = cJSON_GetObjectItem(param,MSG_SCENE_ARGS);
+	if(args == NULL) return FAIL_RETURN;
+
+	res = kk_scene_parse_addscene(args,sceneId,0);
+	if(res == SUCCESS_RETURN){
+		pSceneShadow = kk_scene_shadow();
+		if(pSceneShadow != NULL){
+			kk_tsl_set_value(kk_tsl_set_event_output_value,pSceneShadow,MSG_SCENE_ADDNOTIFICATION_SCENEID,NULL,sceneId);
+			dm_msg_scene_event_post(deviceCode,MSG_SCENE_ADDNOTIFICATION,pSceneShadow);		
+		}
+	}
+	return res;
+}
+static int kk_service_updateScene_handle(const char *deviceCode,cJSON *param)
+{
+	int res = 0;
+	kk_tsl_t *pSceneShadow = NULL;
+	if(deviceCode == NULL || param == NULL){
+		return INVALID_PARAMETER;
+	}
+	cJSON *args = cJSON_GetObjectItem(param,MSG_SCENE_ARGS);
+	if(args == NULL) return FAIL_RETURN;	
+	cJSON *sceneId = cJSON_GetObjectItem(args,MSG_SCENE_SCENEID);
+	if(sceneId == NULL) return FAIL_RETURN;		
+	res = kk_scene_parse_updatescene(args,sceneId->valuestring);
+	if(res == SUCCESS_RETURN){
+		pSceneShadow = kk_scene_shadow();
+		if(pSceneShadow != NULL){
+			kk_tsl_set_value(kk_tsl_set_event_output_value,pSceneShadow,MSG_SCENE_UPDATENOTIFICATION_SCENEID,NULL,sceneId->valuestring);
+			dm_msg_scene_event_post(deviceCode,MSG_SCENE_UPDATENOTIFICATION,pSceneShadow);		
+		}
+	}
+
+	return res;
+}
+
+static int kk_service_deleteScene_handle(const char *deviceCode,cJSON *param)
+{
+	int res = 0;
+	kk_tsl_t *pSceneShadow = NULL;
+	if(deviceCode == NULL || param == NULL){
+		return INVALID_PARAMETER;
+	}
+	cJSON *sceneId = cJSON_GetObjectItem(param,MSG_SCENE_SCENEID);
+	if(sceneId == NULL) return FAIL_RETURN;		
+	res = kk_scene_parse_deletescene(sceneId->valuestring);
+	if(res == SUCCESS_RETURN){
+		pSceneShadow = kk_scene_shadow();
+		if(pSceneShadow != NULL){
+			kk_tsl_set_value(kk_tsl_set_event_output_value,pSceneShadow,MSG_SCENE_DELETENOTIFICATION_SCENEID,NULL,sceneId->valuestring);
+			dm_msg_scene_event_post(deviceCode,MSG_SCENE_DELETENOTIFICATION,pSceneShadow);		
+		}
+	}
+	return res;
+}
+
 static void _iotx_linkkit_event_callback(iotx_dm_event_types_t type, char *data)
 {
-    //INFO_PRINT("_iotx_linkkit_event_callback ================== [%s]\n",data);
     char *out;
     int res = 0;
     cJSON *json;
     cJSON *info_root;
     cJSON *payload,*typeJson;
 	char *payload_Str = NULL;
+	cJSON *deviceCode = NULL;
     json=cJSON_Parse(data);
 	if (json == NULL) {
         WARNING_PRINT("Error before: [%s]\n","cJSON_Parse");
 		return;
     }
     info_root = cJSON_GetObjectItem(json, MSG_INFO_STR);
+	if(info_root == NULL) return;
 	typeJson = cJSON_GetObjectItem(info_root, MSG_TYPE_STR);
+	if(typeJson == NULL) return;	
 	payload = cJSON_GetObjectItem(json, MSG_PAYLOAD_STR);
+	if(payload == NULL) return;
 	payload_Str = cJSON_Print(payload);
+	deviceCode = cJSON_GetObjectItem(info_root, MSG_DEVICE_CODE_STR);
+	if(deviceCode == NULL) return;
 
     if (strstr(typeJson->valuestring,KK_REGISTER_TOPIC_REPLY)){
         INFO_PRINT(" topic:register_reply  \n");
@@ -675,8 +747,7 @@ static void _iotx_linkkit_event_callback(iotx_dm_event_types_t type, char *data)
         _iotx_linkkit_upstream_callback_remove(atoi(response.id.value), response.code.value_int);
         _iotx_linkkit_upstream_mutex_unlock();
    }else if (strstr(typeJson->valuestring,KK_THING_SERVICE_PROPERTY_SET)){
-        INFO_PRINT("property set \n");
-		cJSON *deviceCode = cJSON_GetObjectItem(info_root, MSG_DEVICE_CODE_STR);	
+        INFO_PRINT("property set \n");	
         dm_msg_thing_property_set_reply(deviceCode->valuestring,payload_Str, strlen(payload_Str), NULL);
    }else if (strstr(typeJson->valuestring,KK_THING_CLOUDSTATE_MSG)){
         INFO_PRINT("cloud state notify \n");
@@ -716,15 +787,13 @@ static void _iotx_linkkit_event_callback(iotx_dm_event_types_t type, char *data)
 		kk_topo_delete_handle(payload);
 
    }else if(strcmp(typeJson->valuestring,KK_THING_SERVICE_REBOOT) == 0){
-   		INFO_PRINT(" reboot called!!!\n");
-		cJSON *deviceCode = cJSON_GetObjectItem(info_root, MSG_DEVICE_CODE_STR);	
+   		INFO_PRINT(" reboot called!!!\n");	
 		dm_msg_thing_event_post(deviceCode->valuestring,MSG_REBOOT_REBOOTNOTIFICATION);
 		sleep(3);
 		HAL_Reboot();
    }
    else if(strcmp(typeJson->valuestring,KK_THING_SERVICE_ADDROOM) == 0){
 		INFO_PRINT(" add room!!!\n");
-		cJSON *deviceCode = cJSON_GetObjectItem(info_root, MSG_DEVICE_CODE_STR);
 		cJSON *paramStr = cJSON_GetObjectItem(payload, MSG_PARAMS_STR);	
 		kk_service_addRoom_handle(deviceCode->valuestring,paramStr);
 		dm_msg_thing_event_post(deviceCode->valuestring,MSG_AREA_ADDROOM_NOTIFICATION);
@@ -753,53 +822,60 @@ static void _iotx_linkkit_event_callback(iotx_dm_event_types_t type, char *data)
    }
    else if(strcmp(typeJson->valuestring,KK_THING_SERVICE_SETLOCALTIMER) == 0){
    		INFO_PRINT(" setlocaltimer  \n");
-		cJSON *deviceCode = cJSON_GetObjectItem(info_root, MSG_DEVICE_CODE_STR);
 		cJSON *paramStr = cJSON_GetObjectItem(payload, MSG_PARAMS_STR);
 		
 		kk_service_setLocalTimer_handle(paramStr,deviceCode->valuestring);
    }
    else if(strcmp(typeJson->valuestring,KK_THING_SERVICE_GETLOCALTIMER) == 0){
    		INFO_PRINT(" getlocaltimer  \n");
-		cJSON *deviceCode = cJSON_GetObjectItem(info_root, MSG_DEVICE_CODE_STR);
 		kk_service_getLocalTimer_handle(deviceCode->valuestring);
    }   
    else if(strcmp(typeJson->valuestring,KK_THING_SERVICE_SETCOUNTDOWN) == 0){
    		INFO_PRINT(" set count down  \n");
-		cJSON *deviceCode = cJSON_GetObjectItem(info_root, MSG_DEVICE_CODE_STR);
    		cJSON *paramStr = cJSON_GetObjectItem(payload, MSG_PARAMS_STR);
 		kk_service_setCountDown_handle(paramStr,deviceCode->valuestring);
    }   
    else if(strcmp(typeJson->valuestring,KK_THING_SERVICE_GETCOUNTDOWN) == 0){
    		INFO_PRINT(" get count down  \n");
-		cJSON *deviceCode = cJSON_GetObjectItem(info_root, MSG_DEVICE_CODE_STR);
 		kk_service_getCountDown_handle(deviceCode->valuestring);
    }  
    else if(strcmp(typeJson->valuestring,KK_THING_SERVICE_GETKEYLIST) == 0){
    		INFO_PRINT(" get key list  \n");
-		cJSON *deviceCode = cJSON_GetObjectItem(info_root, MSG_DEVICE_CODE_STR);
 		kk_service_getLockKeylist_handle(deviceCode->valuestring);
    }  
    else if(strcmp(typeJson->valuestring,KK_THING_SERVICE_ADDKEY) == 0){
    		INFO_PRINT(" add key  \n");
-		cJSON *deviceCode = cJSON_GetObjectItem(info_root, MSG_DEVICE_CODE_STR);
    		cJSON *paramStr = cJSON_GetObjectItem(payload, MSG_PARAMS_STR);	
 		kk_service_addKey_handle(deviceCode->valuestring,paramStr);
-		dm_msg_thing_event_post(deviceCode->valuestring,MSG_KEYADD_NOTIFICATION);
+
    }   
    else if(strcmp(typeJson->valuestring,KK_THING_SERVICE_MODIFYKEY) == 0){
    		INFO_PRINT(" modify key  \n");
-		cJSON *deviceCode = cJSON_GetObjectItem(info_root, MSG_DEVICE_CODE_STR);
    		cJSON *paramStr = cJSON_GetObjectItem(payload, MSG_PARAMS_STR);	
 		kk_service_modifyKey_handle(deviceCode->valuestring,paramStr);
-		dm_msg_thing_event_post(deviceCode->valuestring,MSG_KEYMODIFY_NOTIFICATION);
+
    }     
    else if(strcmp(typeJson->valuestring,KK_THING_SERVICE_DELETEKEY) == 0){
    		INFO_PRINT(" delete key  \n");
-		cJSON *deviceCode = cJSON_GetObjectItem(info_root, MSG_DEVICE_CODE_STR);
    		cJSON *paramStr = cJSON_GetObjectItem(payload, MSG_PARAMS_STR);	
 		kk_service_deleteKey_handle(deviceCode->valuestring,paramStr);
-		dm_msg_thing_event_post(deviceCode->valuestring,MSG_KEYDELETE_NOTIFICATION);
+
    }     
+   else if(strcmp(typeJson->valuestring,KK_THING_SERVICE_ADDSCENC) == 0){
+   		INFO_PRINT(" add scene  \n");
+   		cJSON *paramStr = cJSON_GetObjectItem(payload, MSG_PARAMS_STR);	
+		kk_service_addScene_handle(deviceCode->valuestring,paramStr);
+   }    
+   else if(strcmp(typeJson->valuestring,KK_THING_SERVICE_UPDATESCENC) == 0){
+   		INFO_PRINT(" update scene  \n");
+   		cJSON *paramStr = cJSON_GetObjectItem(payload, MSG_PARAMS_STR);	
+		kk_service_updateScene_handle(deviceCode->valuestring,paramStr);
+   }    
+   else if(strcmp(typeJson->valuestring,KK_THING_SERVICE_DELETESCENC) == 0){
+   		INFO_PRINT("delete scene  \n");
+   		cJSON *paramStr = cJSON_GetObjectItem(payload, MSG_PARAMS_STR);	
+		kk_service_deleteScene_handle(deviceCode->valuestring,paramStr);
+   }   
    else{
         INFO_PRINT("Error msgtype!!! \n");
         

midware/midware/midware.c

@@ -36,7 +36,10 @@ char * g_filerToPlatTable[] =
 	{KK_THING_SERVICE_GETCOUNTDOWN},
 	{KK_THING_SERVICE_ADDKEY},
 	{KK_THING_SERVICE_DELETEKEY},
-	{KK_THING_SERVICE_MODIFYKEY}
+	{KK_THING_SERVICE_MODIFYKEY},
+	{KK_THING_SERVICE_ADDSCENC},
+	{KK_THING_SERVICE_UPDATESCENC},	
+	{KK_THING_SERVICE_DELETESCENC},		
 };
 static int _kk_filter_to_plat(const char* msgtype)
 {
@@ -774,6 +777,7 @@ int main(const int argc, const char **argv)
 		kk_subDb_init();
 		kk_heartbeat_init();
 		kk_area_init();	
+		kk_scene_init();
         mid_ctx->g_mid_dispatch_thread_running = 1;
         res = pthread_create(&mid_ctx->g_mid_dispatch_thread, NULL, mid_dispatch_yield, NULL);
         if (res < 0) {

midware/midware/scene/kk_scene_handle.c

+#include <stdio.h>
+#include "kk_tsl_api.h"
+#include "kk_dm_mng.h"
+#include "sqlite3.h"
+#include "kk_log.h"
+#include "kk_scene_handle.h"
+#include "cJSON.h"
+
+extern sqlite3 *g_kk_pDb;
+
+typedef struct {
+    void *mutex;
+    sqlite3 *pDb;	
+} kk_scene_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_scene_ctx_t s_kk_scene_ctx = {NULL,NULL};
+
+static kk_scene_ctx_t *_kk_scene_get_ctx(void)
+{
+    return &s_kk_scene_ctx;
+}
+static void _kk_scene_lock(void)
+{
+    kk_scene_ctx_t *ctx = _kk_scene_get_ctx();
+    if (ctx->mutex) {
+        HAL_MutexLock(ctx->mutex);
+    }
+}
+
+static void _kk_scene_unlock(void)
+{
+    kk_scene_ctx_t *ctx = _kk_scene_get_ctx();
+	
+    if (ctx->mutex) {
+        HAL_MutexUnlock(ctx->mutex);
+    }
+}
+
+static int _kk_scene_db_init(void)
+{
+    kk_scene_ctx_t *ctx = _kk_scene_get_ctx();
+    char *pcErr;
+
+    //eUtils_LockLock(&sLock);
+    _kk_scene_lock();
+    ctx->pDb = g_kk_pDb;
+   
+    INFO_PRINT("scene db Database opened\n");
+    
+	const char *pSceneTable = "CREATE TABLE IF NOT EXISTS SceneInfo( \
+		name varchar(255), \
+		sceneType INTEGER, \
+		enable INTEGER, \
+		sceneId varchar(255) UNIQUE)";
+
+    if (sqlite3_exec(ctx->pDb, pSceneTable, NULL, NULL, &pcErr) != SQLITE_OK)
+    {
+        ERROR_PRINT("Error creating table (%s)\n", pcErr);
+        sqlite3_free(pcErr);
+        //eUtils_LockUnlock(&sLock);
+        _kk_scene_unlock();
+        return FAIL_RETURN;
+    }
+
+	const char *pSceneTriggerTable = "CREATE TABLE IF NOT EXISTS SceneTriggerInfo( \
+		type varchar(255), \
+		deviceCode varchar(255), \
+		epNum INTEGER, \
+		propertyName varchar(255), \
+		compareType varchar(255), \
+		compareValue varchar(255), \
+		sceneId varchar(255))";
+
+
+    if (sqlite3_exec(ctx->pDb, pSceneTriggerTable, NULL, NULL, &pcErr) != SQLITE_OK)
+    {
+        ERROR_PRINT("Error creating table (%s)\n", pcErr);
+        sqlite3_free(pcErr);
+        //eUtils_LockUnlock(&sLock);
+        _kk_scene_unlock();
+        return FAIL_RETURN;
+    }
+
+	const char *pSceneConditionTable = "CREATE TABLE IF NOT EXISTS SceneConditionInfo( \
+		type varchar(255), \
+		startTime INTEGER, \
+		endTime INTEGER, \
+		crossDay INTEGER, \
+		repeat_days INTEGER, \
+		sceneId varchar(255))";
+
+
+    if (sqlite3_exec(ctx->pDb, pSceneConditionTable, NULL, NULL, &pcErr) != SQLITE_OK)
+    {
+        ERROR_PRINT("Error creating table (%s)\n", pcErr);
+        sqlite3_free(pcErr);
+        //eUtils_LockUnlock(&sLock);
+        _kk_scene_unlock();
+        return FAIL_RETURN;
+    }	
+
+	const char *pSceneActionTable = "CREATE TABLE IF NOT EXISTS SceneActionInfo( \
+		type varchar(255), \
+		deviceCode varchar(255), \
+		epNum INTEGER, \
+		propertyName varchar(255), \
+		propertyValue varchar(255), \
+		delay INTEGER, \
+		sceneId varchar(255))";
+
+
+    if (sqlite3_exec(ctx->pDb, pSceneActionTable, NULL, NULL, &pcErr) != SQLITE_OK)
+    {
+        ERROR_PRINT("Error creating table (%s)\n", pcErr);
+        sqlite3_free(pcErr);
+        //eUtils_LockUnlock(&sLock);
+        _kk_scene_unlock();
+        return FAIL_RETURN;
+    }	
+
+    _kk_scene_unlock();
+    return SUCCESS_RETURN;
+}
+
+#define KK_DEVICE_TSL_TYPE (0x08)
+static kk_tsl_t *s_scene_shadow = NULL;
+static int kk_scene_tsl_load(void)
+{
+	int res = 0;
+	char *tsl_str = NULL;
+	int heartTime = 0;
+	tsl_str = kk_load_json("15", KK_DEVICE_TSL_TYPE);
+	if(tsl_str != NULL)
+	{
+		printf("[%s][%d]\n",__FUNCTION__,__LINE__);
+		res = kk_tsl_create(tsl_str,strlen(tsl_str),&s_scene_shadow,&heartTime);
+		free(tsl_str);
+		if(res != 0){
+			return FAIL_RETURN;
+		}
+	}
+	printf("[%s][%d]\n",__FUNCTION__,__LINE__);
+	return SUCCESS_RETURN;
+
+}
+kk_tsl_t * kk_scene_shadow(void)
+{
+	return s_scene_shadow;
+}
+
+int kk_scene_init(void)
+{
+	int res = 0;
+    kk_scene_ctx_t *ctx = _kk_scene_get_ctx();
+
+	printf("[%s][%d]\n",__FUNCTION__,__LINE__);
+
+    /* Create Mutex */
+    ctx->mutex = HAL_MutexCreate();
+    if (ctx->mutex == NULL) {
+        return FAIL_RETURN;
+    }
+	_kk_scene_db_init();
+
+	res = kk_scene_tsl_load();
+	if(res != SUCCESS_RETURN){
+		ERROR_PRINT("[%s][%d]kk_scene_init FAIL!!!\n",__FUNCTION__,__LINE__);
+
+	}
+	printf("[%s][%d]\n",__FUNCTION__,__LINE__);
+	return SUCCESS_RETURN;
+}
+
+#if 0
+uint64_t kk_room_add(const char *name)
+{
+	int res = 0;
+    kk_area_ctx_t *ctx = _kk_area_get_ctx();
+	char *sqlCmd = NULL;
+	char roomId[32] = {0};
+	char *zErrMsg = 0;
+	uint64_t u64RoomId = 0;
+
+	const char *insertCmd = "insert into AreaInfo (name, roomId) \
+								values ('%s','%s');";						
+	_kk_area_lock();
+	ctx->roomNum++;
+	u64RoomId = get_unique_id();
+	sprintf(roomId,"%u",u64RoomId);
+
+	sqlCmd = sqlite3_mprintf(insertCmd,name,roomId);	
+	res = sqlite3_exec(ctx->pDb, sqlCmd, NULL, NULL, &zErrMsg);
+	if( res != SQLITE_OK ){
+	   ERROR_PRINT("SQL error: %s\n", zErrMsg);
+	   sqlite3_free(zErrMsg);
+	}else{
+	   //INFO_PRINT("sub device insert data successfully\n");
+	}
+	sqlite3_free(sqlCmd);
+	_kk_area_unlock();
+	return u64RoomId;
+}
+
+int kk_room_delete(const char *roomId)
+{
+	int res = 0;
+    kk_area_ctx_t *ctx = _kk_area_get_ctx();
+	char *sqlCmd = NULL;
+	char *zErrMsg = 0;
+	const char *deleteCmd = "delete from AreaInfo where roomId = '%s';";
+
+								
+	_kk_area_lock();
+	 sqlCmd = sqlite3_mprintf(deleteCmd,roomId);	
+
+	INFO_PRINT("Table delete data sqlCmd:%s\n",sqlCmd);
+	res = sqlite3_exec(ctx->pDb, sqlCmd, NULL, NULL, &zErrMsg);
+	if( res != SQLITE_OK ){
+	   ERROR_PRINT("SQL error: %s\n", zErrMsg);
+	   sqlite3_free(zErrMsg);
+	}else{
+	   //INFO_PRINT("Table delete data successfully\n");
+	   ctx->roomNum--;
+	}
+	sqlite3_free(sqlCmd);
+	
+	_kk_area_unlock();
+	return SUCCESS_RETURN;
+}
+
+int kk_room_dev_add(const char *roomId,const char *deviceCode,const char *epNum)
+{
+	int res = 0;
+    kk_area_ctx_t *ctx = _kk_area_get_ctx();
+	char *sqlCmd = NULL;
+	char *zErrMsg = 0;
+
+	const char *insertCmd = "insert into AreaDevInfo (roomId, deviceCode, epNum) \
+								values ('%s','%s','%s');";	
+								
+	_kk_area_lock();
+	sqlCmd = sqlite3_mprintf(insertCmd,roomId,deviceCode,epNum);	
+	res = sqlite3_exec(ctx->pDb, sqlCmd, NULL, NULL, &zErrMsg);
+	if( res != SQLITE_OK ){
+	   ERROR_PRINT("SQL error: %s\n", zErrMsg);
+	   sqlite3_free(zErrMsg);
+	}else{
+	   //INFO_PRINT("sub device insert data successfully\n");
+	}
+	sqlite3_free(sqlCmd);
+	_kk_area_unlock();
+	return SUCCESS_RETURN;
+}
+
+int kk_room_dev_remove(const char *deviceCode,const char *epNum)
+{
+	int res = 0;
+    kk_area_ctx_t *ctx = _kk_area_get_ctx();
+	char *sqlCmd = NULL;
+	char *zErrMsg = 0;
+
+	const char *insertCmd = "delete from AreaDevInfo where deviceCode = '%s' and epNum = '%s';";	
+								
+	_kk_area_lock();
+	sqlCmd = sqlite3_mprintf(insertCmd,deviceCode,epNum);	
+	res = sqlite3_exec(ctx->pDb, sqlCmd, NULL, NULL, &zErrMsg);
+	if( res != SQLITE_OK ){
+	   ERROR_PRINT("SQL error: %s\n", zErrMsg);
+	   sqlite3_free(zErrMsg);
+	}else{
+	   //INFO_PRINT("sub device insert data successfully\n");
+	}
+	sqlite3_free(sqlCmd);
+	_kk_area_unlock();
+	return SUCCESS_RETURN;
+}
+
+
+
+int kk_room_device_list_add(const char *deviceCode)
+{
+	int len;
+	kk_dev_list_t *ptr,*pre;
+	
+	ptr = pre = s_device_list;
+	if(deviceCode == NULL){
+		return FAIL_RETURN;
+	}
+	
+	while(ptr!=NULL){
+		pre = ptr;
+		if(strcmp(ptr->deviceCode,deviceCode) == 0){
+			return SUCCESS_RETURN;
+		}
+		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;
+	}
+
+	return SUCCESS_RETURN;
+}
+
+kk_dev_list_t*  kk_get_room_deviceCode(const char* roomId)
+{
+	sqlite3_stmt *stmt;
+	char *sqlCmd = NULL;
+    kk_area_ctx_t *ctx = _kk_area_get_ctx();
+	const char *searchCmd = "select * from AreaDevInfo;";	
+	printf("");
+	_kk_area_lock();
+	sqlCmd = sqlite3_mprintf(searchCmd,roomId);	
+	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){
+	   if(strcmp(sqlite3_column_text(stmt, DB_DEV_ROOM_ID),roomId) == 0){
+	   		kk_room_device_list_add(sqlite3_column_text(stmt, DB_DEV_DEVICECODE));
+	   }
+    }
+	sqlite3_finalize(stmt);
+	_kk_area_unlock();
+	return s_device_list;
+}
+void kk_free_room_dev_list(void)
+{
+	kk_dev_list_t *ptr = s_device_list;
+	kk_dev_list_t *ptmp = NULL;
+	while(ptr != NULL){
+		ptmp = ptr->next;
+		free(ptr);
+		ptr = NULL;
+		ptr = ptmp;
+	}
+	s_device_list = NULL;
+}
+#endif
+static int kk_scene_insert_scene_info(const char* name,const char* sceneType,const char* enable,const char* sceneId)
+{
+	int res = 0;
+    kk_scene_ctx_t *ctx = _kk_scene_get_ctx();
+	char *sqlCmd = NULL;
+	char *zErrMsg = 0;
+
+	const char *insertCmd = "insert into SceneInfo (name, sceneType,enable,sceneId) \
+								values ('%s','%d','%d','%s');";	
+								
+	_kk_scene_lock();
+	sqlCmd = sqlite3_mprintf(insertCmd,name,sceneType,enable,sceneId);	
+	res = sqlite3_exec(ctx->pDb, sqlCmd, NULL, NULL, &zErrMsg);
+	if( res != SQLITE_OK ){
+	   ERROR_PRINT("SQL error: %s\n", zErrMsg);
+	   sqlite3_free(zErrMsg);
+	   sqlite3_free(sqlCmd);
+	   _kk_scene_unlock();	
+	   return FAIL_RETURN;
+	}
+	
+	sqlite3_free(sqlCmd);
+	_kk_scene_unlock();
+	return SUCCESS_RETURN;
+
+}
+static int kk_scene_insert_scene_trigger(const char* type,const char* deviceCode,const char* epNum,const char* propertyName,
+												const char* compareType,const char* compareValue,const char* sceneId)
+{
+	int res = 0;
+    kk_scene_ctx_t *ctx = _kk_scene_get_ctx();
+	char *sqlCmd = NULL;
+	char *zErrMsg = 0;
+
+	const char *insertCmd = "insert into SceneTriggerInfo (type, deviceCode,epNum,propertyName,compareType,compareValue,sceneId) \
+								values ('%s','%s','%d','%s','%s','%s','%s');";	
+								
+	_kk_scene_lock();
+	sqlCmd = sqlite3_mprintf(insertCmd,type,deviceCode,epNum,propertyName,compareType,compareValue,sceneId);	
+	res = sqlite3_exec(ctx->pDb, sqlCmd, NULL, NULL, &zErrMsg);
+	if( res != SQLITE_OK ){
+	   ERROR_PRINT("SQL error: %s\n", zErrMsg);
+	   sqlite3_free(zErrMsg);
+	   sqlite3_free(sqlCmd);
+	   _kk_scene_unlock();	
+	   return FAIL_RETURN;	
+	}
+	sqlite3_free(sqlCmd);
+	_kk_scene_unlock();
+	
+	return SUCCESS_RETURN;
+
+}
+
+static int kk_scene_insert_scene_condition(const char* type,int startTime,int endTime,int crossDay,
+												char repeat_days,const char* sceneId)
+{
+	int res = 0;
+	kk_scene_ctx_t *ctx = _kk_scene_get_ctx();
+	char *sqlCmd = NULL;
+	char *zErrMsg = 0;
+
+	const char *insertCmd = "insert into SceneConditionInfo (type, startTime,endTime,crossDay,repeat_days,sceneId) \
+								values ('%s','%d','%d','%d','%d','%s');";	
+								
+	_kk_scene_lock();
+	sqlCmd = sqlite3_mprintf(insertCmd,type,startTime,endTime,crossDay,repeat_days,sceneId);	
+	res = sqlite3_exec(ctx->pDb, sqlCmd, NULL, NULL, &zErrMsg);
+	if( res != SQLITE_OK ){
+	   ERROR_PRINT("SQL error: %s\n", zErrMsg);
+	   sqlite3_free(zErrMsg);
+	   sqlite3_free(sqlCmd);
+	   _kk_scene_unlock();	
+	   return FAIL_RETURN;	
+	}
+	sqlite3_free(sqlCmd);
+	_kk_scene_unlock();
+	
+	return SUCCESS_RETURN;
+
+}
+
+
+static int kk_scene_insert_scene_action(const char* type,const char* deviceCode,int epNum,const char* propertyName,
+												const char* propertyValue,int delay,const char* sceneId)
+{
+	int res = 0;
+	kk_scene_ctx_t *ctx = _kk_scene_get_ctx();
+	char *sqlCmd = NULL;
+	char *zErrMsg = 0;
+
+	const char *insertCmd = "insert into SceneActionInfo (type, deviceCode,epNum,propertyName,propertyValue,delay,sceneId) \
+								values ('%s','%s','%d','%s','%s','%d','%s');";	
+								
+	_kk_scene_lock();
+	sqlCmd = sqlite3_mprintf(insertCmd,type,deviceCode,epNum,propertyName,propertyValue,delay,sceneId);	
+	res = sqlite3_exec(ctx->pDb, sqlCmd, NULL, NULL, &zErrMsg);
+	if( res != SQLITE_OK ){
+	   ERROR_PRINT("SQL error: %s\n", zErrMsg);
+	   sqlite3_free(zErrMsg);
+	   sqlite3_free(sqlCmd);
+	   _kk_scene_unlock();	
+	   return FAIL_RETURN;	
+	}
+	sqlite3_free(sqlCmd);
+	_kk_scene_unlock();
+	
+	return SUCCESS_RETURN;
+
+}
+int kk_scene_delete_scene_info(const char *sceneId)
+{
+	int res = 0;
+	kk_scene_ctx_t *ctx = _kk_scene_get_ctx();
+	char *sqlCmd = NULL;
+	char *zErrMsg = 0;
+	const char *deleteCmd = "delete from SceneInfo where sceneId = '%s';";
+						
+	_kk_scene_lock();
+	 sqlCmd = sqlite3_mprintf(deleteCmd,sceneId);	
+	res = sqlite3_exec(ctx->pDb, sqlCmd, NULL, NULL, &zErrMsg);
+	if( res != SQLITE_OK ){
+	   ERROR_PRINT("SQL error: %s\n", zErrMsg);
+	   sqlite3_free(zErrMsg);
+	   sqlite3_free(sqlCmd);
+	   _kk_scene_unlock();	
+	   return FAIL_RETURN;		
+	}
+	sqlite3_free(sqlCmd);
+	_kk_scene_unlock();
+	return SUCCESS_RETURN;
+}
+int kk_scene_delete_scene_trigger(const char *sceneId)
+{
+	int res = 0;
+	kk_scene_ctx_t *ctx = _kk_scene_get_ctx();
+	char *sqlCmd = NULL;
+	char *zErrMsg = 0;
+	const char *deleteCmd = "delete from SceneTriggerInfo where sceneId = '%s';";
+						
+	_kk_scene_lock();
+	 sqlCmd = sqlite3_mprintf(deleteCmd,sceneId);	
+	res = sqlite3_exec(ctx->pDb, sqlCmd, NULL, NULL, &zErrMsg);
+	if( res != SQLITE_OK ){
+	   ERROR_PRINT("SQL error: %s\n", zErrMsg);
+	   sqlite3_free(zErrMsg);
+	   sqlite3_free(sqlCmd);
+	   _kk_scene_unlock();	
+	   return FAIL_RETURN;		
+	}
+	sqlite3_free(sqlCmd);
+	_kk_scene_unlock();
+	return SUCCESS_RETURN;
+}
+int kk_scene_delete_scene_condition(const char *sceneId)
+{
+	int res = 0;
+	kk_scene_ctx_t *ctx = _kk_scene_get_ctx();
+	char *sqlCmd = NULL;
+	char *zErrMsg = 0;
+	const char *deleteCmd = "delete from SceneConditionInfo where sceneId = '%s';";
+						
+	_kk_scene_lock();
+	 sqlCmd = sqlite3_mprintf(deleteCmd,sceneId);	
+	res = sqlite3_exec(ctx->pDb, sqlCmd, NULL, NULL, &zErrMsg);
+	if( res != SQLITE_OK ){
+	   ERROR_PRINT("SQL error: %s\n", zErrMsg);
+	   sqlite3_free(zErrMsg);
+	   sqlite3_free(sqlCmd);
+	   _kk_scene_unlock();	
+	   return FAIL_RETURN;		
+	}
+	sqlite3_free(sqlCmd);
+	_kk_scene_unlock();
+	return SUCCESS_RETURN;
+}
+
+int kk_scene_delete_scene_action(const char *sceneId)
+{
+	int res = 0;
+	kk_scene_ctx_t *ctx = _kk_scene_get_ctx();
+	char *sqlCmd = NULL;
+	char *zErrMsg = 0;
+	const char *deleteCmd = "delete from SceneActionInfo where sceneId = '%s';";
+						
+	_kk_scene_lock();
+	 sqlCmd = sqlite3_mprintf(deleteCmd,sceneId);	
+	res = sqlite3_exec(ctx->pDb, sqlCmd, NULL, NULL, &zErrMsg);
+	if( res != SQLITE_OK ){
+	   ERROR_PRINT("SQL error: %s\n", zErrMsg);
+	   sqlite3_free(zErrMsg);
+	   sqlite3_free(sqlCmd);
+	   _kk_scene_unlock();	
+	   return FAIL_RETURN;		
+	}
+	sqlite3_free(sqlCmd);
+	_kk_scene_unlock();
+	return SUCCESS_RETURN;
+}
+
+
+int kk_scene_parse_scene_trigger(const cJSON* str,const char *sceneId)
+{
+	int res = 0;
+	if(str == NULL || sceneId == NULL){
+		return INVALID_PARAMETER;
+	}
+
+	cJSON *triggers = cJSON_GetObjectItem(str,MSG_SCENE_TRIGGERS);
+	if(triggers == NULL) return FAIL_RETURN;	
+	cJSON *items = cJSON_GetObjectItem(triggers,MSG_SCENE_ITEMS);
+	if(items == NULL) return FAIL_RETURN;
+	cJSON * item = items->child;
+	while(item != NULL){
+		cJSON *type = cJSON_GetObjectItem(item,MSG_SCENE_TYPE);
+		if(type == NULL) return FAIL_RETURN;
+		cJSON *deviceCode = cJSON_GetObjectItem(item,MSG_DEVICE_CODE_STR);
+		if(deviceCode == NULL) return FAIL_RETURN;	
+		cJSON *epNum = cJSON_GetObjectItem(item,MSG_SCENE_EPNUM);
+		if(epNum == NULL) return FAIL_RETURN;		
+		cJSON *propertyName = cJSON_GetObjectItem(item,MSG_SCENE_PROPERTYNAME);
+		if(propertyName == NULL) return FAIL_RETURN;
+		cJSON *compareType = cJSON_GetObjectItem(item,MSG_SCENE_COMPARETYPE);
+		if(compareType == NULL) return FAIL_RETURN;		
+		cJSON *compareValue = cJSON_GetObjectItem(item,MSG_SCENE_COMPAREVALUE);
+		if(compareValue == NULL) return FAIL_RETURN;	
+		res = kk_scene_insert_scene_trigger(type->valuestring,deviceCode->valuestring,deviceCode->valueint,
+				propertyName->valuestring,compareType->valuestring,compareValue->valuestring,sceneId);
+		if(res != SUCCESS_RETURN){
+			ERROR_PRINT("kk_scene_parse_scene_trigger fail!!!\n");
+			return res;
+		}
+		item = item->next;	
+	}
+	INFO_PRINT("kk_scene_parse_scene_trigger success!!!\n");
+	return SUCCESS_RETURN;
+}
+static int kk_scene_parse_repeatday(cJSON *repeatday)
+{
+	/***weekflag 01111111  ---> week 7 6 5 4 3 2 1*/
+	char weekflag = 0;
+	int iCnt = 0;
+	if(repeatday == NULL){
+		return INVALID_PARAMETER;
+	}
+	int  array_size = cJSON_GetArraySize (repeatday);
+	INFO_PRINT("array_size:%d\n",array_size);
+	if(array_size == 0){
+		weekflag = 0;
+	}else{
+		for(iCnt = 0; iCnt < array_size; iCnt++){
+			cJSON * pSub = cJSON_GetArrayItem(repeatday, iCnt);
+			if(pSub != NULL){
+				weekflag = weekflag|(1<<(pSub->valueint-1));
+			}
+		}
+	}
+	INFO_PRINT("kk_scene_parse_repeatday weekflag:%d!!!\n",weekflag);
+	return weekflag;
+	
+}
+
+
+int kk_scene_parse_scene_condition(const cJSON* str,const char *sceneId)
+{
+	char weekflag = 0;
+	int res = 0;
+	if(str == NULL || sceneId == NULL){
+		ERROR_PRINT("kk_scene_parse_scene_condition failed\n");
+		return INVALID_PARAMETER;
+	}
+
+	cJSON *conditon = cJSON_GetObjectItem(str,MSG_SCENE_CONDITIONS);
+	if(conditon == NULL) return FAIL_RETURN;	
+
+	cJSON *items = cJSON_GetObjectItem(conditon,MSG_SCENE_ITEMS);
+	if(items == NULL) return FAIL_RETURN;
+	cJSON * item = items->child;
+	while(item != NULL){
+		cJSON *type = cJSON_GetObjectItem(item,MSG_SCENE_TYPE);
+		if(type == NULL) return FAIL_RETURN;
+
+		cJSON *startTime = cJSON_GetObjectItem(item,MSG_SCENE_STARTTIME);
+		if(startTime == NULL) return FAIL_RETURN;
+		cJSON *endTime = cJSON_GetObjectItem(item,MSG_SCENE_ENDTIME);
+		if(endTime == NULL) return FAIL_RETURN;	
+		cJSON *crossday = cJSON_GetObjectItem(item,MSG_SCENE_CROSSDAY);
+		if(crossday == NULL) return FAIL_RETURN;	
+		cJSON *repeatday = cJSON_GetObjectItem(item,MSG_SCENE_REPEATDAYS);
+		if(repeatday == NULL) return FAIL_RETURN;
+		weekflag = kk_scene_parse_repeatday(repeatday);
+		res = kk_scene_insert_scene_condition(type->valuestring,startTime->valueint,endTime->valueint,
+				crossday->valueint,weekflag,sceneId);
+		if(res != SUCCESS_RETURN){
+			INFO_PRINT("kk_scene_insert_scene_condition fail!!!\n");
+			return res;
+		}
+		item = item->next;
+	}
+	INFO_PRINT("kk_scene_parse_scene_condition success!!!\n");
+	return SUCCESS_RETURN;
+}
+
+int kk_scene_parse_scene_action(const cJSON* str,const char *sceneId)
+{
+	int res = 0;
+	if(str == NULL || sceneId == NULL){
+		ERROR_PRINT("kk_scene_parse_scene_action failed\n");
+		return INVALID_PARAMETER;
+	}
+
+	cJSON *action = cJSON_GetObjectItem(str,MSG_SCENE_ACTIONS);
+	if(action == NULL) return FAIL_RETURN;
+	
+	//cJSON *items = cJSON_GetObjectItem(conditon,MSG_SCENE_ITEMS);
+	//if(items == NULL) return FAIL_RETURN;
+	cJSON * item = action->child;
+	while(item != NULL){
+		cJSON *type = cJSON_GetObjectItem(item,MSG_SCENE_TYPE);
+		if(type == NULL) return FAIL_RETURN;	
+		cJSON *deviceCode = cJSON_GetObjectItem(item,MSG_DEVICE_CODE_STR);
+		if(deviceCode == NULL) return FAIL_RETURN;	
+		cJSON *epNum = cJSON_GetObjectItem(item,MSG_SCENE_EPNUM);
+		if(epNum == NULL) return FAIL_RETURN;	
+		cJSON *propertyName = cJSON_GetObjectItem(item,MSG_SCENE_PROPERTYNAME);
+		if(propertyName == NULL) return FAIL_RETURN;
+		cJSON *propertyValue = cJSON_GetObjectItem(item,MSG_SCENE_PROPERTYVALUE);
+		if(propertyValue == NULL) return FAIL_RETURN;
+		cJSON *delay = cJSON_GetObjectItem(item,MSG_SCENE_DELAY);
+		if(delay == NULL) return FAIL_RETURN;
+		
+		res = kk_scene_insert_scene_action(type->valuestring,deviceCode->valuestring,epNum->valueint,
+				propertyName->valuestring,propertyValue->valuestring,delay->valueint,sceneId);
+		if(res != SUCCESS_RETURN){
+			INFO_PRINT("kk_scene_insert_scene_action fail!!!\n");
+			return res;
+		}		
+		item = item->next;
+	}
+	INFO_PRINT("kk_scene_parse_scene_action success!!!\n");
+	return SUCCESS_RETURN;
+}
+
+
+int kk_scene_parse_addscene(const cJSON* args,char *sceneId,int isUpdate)
+{
+	int res = 0;
+
+	if(args == NULL||sceneId == NULL){
+		ERROR_PRINT("[%d]kk_scene_parse_addscene fail!!!\n",__LINE__);
+		return INVALID_PARAMETER;
+	}
+	
+	cJSON *name = cJSON_GetObjectItem(args,MSG_SCENE_NAME);
+	if(name == NULL) return FAIL_RETURN;
+	cJSON *sceneType = cJSON_GetObjectItem(args,MSG_SCENE_SCENCTYPE);
+	if(sceneType == NULL) return FAIL_RETURN;
+	cJSON *enable = cJSON_GetObjectItem(args,MSG_SCENE_ENABLE);
+	if(enable == NULL) return FAIL_RETURN;	
+	if(!isUpdate){
+		HAL_GetTimeMs(sceneId);//use time to create the sceneId
+	}
+	//sprintf(sceneId,"%lld",u64SceneKeyId);
+	
+	res = kk_scene_insert_scene_info(name->valuestring,sceneType->valueint,enable->valueint,sceneId);
+	if(res != SUCCESS_RETURN){
+		INFO_PRINT("kk_scene_insert_scene_info fail!!!\n");
+		return res;
+	}	
+
+	res = kk_scene_parse_scene_trigger(args,sceneId);
+	if(res != SUCCESS_RETURN){
+		ERROR_PRINT("kk_scene_parse_scene_trigger failed\n");
+		return FAIL_RETURN;
+	}
+	res = kk_scene_parse_scene_condition(args,sceneId);
+	if(res != SUCCESS_RETURN){
+		ERROR_PRINT("kk_scene_parse_scene_condition failed\n");
+		return FAIL_RETURN;
+	}	
+
+	res = kk_scene_parse_scene_action(args,sceneId);
+	if(res != SUCCESS_RETURN){
+		ERROR_PRINT("kk_scene_parse_scene_action failed\n");
+		return FAIL_RETURN;
+	}		
+	return SUCCESS_RETURN;
+
+}
+static void kk_scenec_delete(char* sceneId)
+{
+	kk_scene_delete_scene_info(sceneId);
+	kk_scene_delete_scene_trigger(sceneId);
+	kk_scene_delete_scene_condition(sceneId);	
+	kk_scene_delete_scene_action(sceneId);
+}
+int kk_scene_parse_updatescene(const cJSON* arg,char *sceneId)
+{
+
+	if(arg == NULL||sceneId == NULL){
+		ERROR_PRINT("[%d]kk_scene_parse_addscene fail!!!\n",__LINE__);
+		return INVALID_PARAMETER;
+	}
+	kk_scenec_delete(sceneId);
+	return kk_scene_parse_addscene(arg,sceneId,1);
+}
+int kk_scene_parse_deletescene(char *sceneId)
+{
+
+	if(sceneId == NULL){
+		ERROR_PRINT("[%d]kk_scene_parse_deletescene fail!!!\n",__LINE__);
+		return INVALID_PARAMETER;
+	}
+	kk_scenec_delete(sceneId);	
+	return SUCCESS_RETURN;
+}
+
+

midware/midware/scene/kk_scene_handle.h

+#ifndef __KK_SCENE_H__
+#define __KK_SCENE_H__
+
+#include "kk_tsl_common.h"
+
+
+int kk_scene_init(void);
+
+#endif
+

midware/tsl/tsl_handle/kk_tsl_load.c

@@ -7,6 +7,7 @@
 #define TSL_SUBDEVICE_PATH_FILE "/usr/kk/tsl/product_%s.json"
 #define TSL_GATEWAY_PATH_FILE "/usr/kk/tsl/gateway-%s.json"
 #define TSL_CCU_PATH_FILE "/usr/kk/tsl/ccu-%s.json"
+#define TSL_SCENE_PATH_FILE "/usr/kk/tsl/ccu_%s_scene.json"
 
 char* kk_load_json(const char *productCode,int type)
 {
@@ -22,10 +23,12 @@ char* kk_load_json(const char *productCode,int type)
 	else if(type == KK_DM_DEVICE_GATEWAY){
 		path_len = strlen(TSL_GATEWAY_PATH_FILE)+strlen(productCode)+1;
 	}
-	else{
+	else if(type == KK_DM_DEVICE_SUBDEV){
 		path_len = strlen(TSL_SUBDEVICE_PATH_FILE)+strlen(productCode)+1;
 	}
-
+	else{
+		path_len = strlen(TSL_SCENE_PATH_FILE)+strlen(productCode)+1;
+	}
 	tslPath = malloc(path_len);
 	if(tslPath == NULL){
 		return NULL;
@@ -38,9 +41,12 @@ char* kk_load_json(const char *productCode,int type)
 	else if(type == KK_DM_DEVICE_GATEWAY){
 		snprintf(tslPath,path_len,TSL_GATEWAY_PATH_FILE,productCode);
 	}
-	else{
+	else if(type == KK_DM_DEVICE_SUBDEV){
 		snprintf(tslPath,path_len,TSL_SUBDEVICE_PATH_FILE,productCode);
 	}
+	else{
+		snprintf(tslPath,path_len,TSL_SCENE_PATH_FILE,productCode);
+	}
 	
 	
 	INFO_PRINT("\n[%s][%d]tslPath:%s!!!\n",__FUNCTION__,__LINE__,tslPath);