Merge branch 'cwc' into 'master'

Cwc

See merge request chenweican/k-sdk!33

application/kcloud/kcloud_data_handle.c

@@ -30,6 +30,8 @@
 #define KK_CLOUDSTATE_MSG                      "/thing/ccu/cloudstate"
 #define KK_CLOUDSTATE_MSG_REPLY                "/thing/ccu/cloudstate_reply"
 #define KK_TOPO_CHANGE_MSG_STR                 "/thing/topo/change"
+#define KK_FILTER_SERVICE_CALL_TOPIC          "/thing/service/"
+#define KK_FILTER_SERVICE_CALL_REPLY           "_reply"
 
 const char DM_MSG_TO_MIDDWARE[] = "{\"msgtype\":\"%s\",\"productCode\":\"%s\",\"deviceCode\":\"%s\"}";
 #define KK_TOPIC_SERVICE_DELIMITER 			  '/'
@@ -220,9 +222,6 @@ static int _check_invalid_topic(const char* topic)
 	else if(strstr(topic, KK_FILTER_LOGIN_TOPIC) != NULL && \
 		strstr(topic,KK_FILTER_LOGIN_TOPIC_REPLY) == NULL){
 		return 1;
-	}	
-	else if(strstr(topic, KK_FILTER_SET_TOPIC_REPLY) != NULL){
-		return 1;
 	}		
 	else if(strstr(topic,KK_FILTER_TOPO_CHANEG_REPLY) != NULL){
 		return 1;
@@ -232,6 +231,10 @@ static int _check_invalid_topic(const char* topic)
 		strstr(topic,KK_FILTER_EVENT_POST_REPLY) == NULL){
 		return 1;
 	}
+	else if(strstr(topic, KK_FILTER_SERVICE_CALL_TOPIC) != NULL && \
+		strstr(topic,KK_FILTER_SERVICE_CALL_REPLY) != NULL){
+		return 1;
+	}		
 	else if(strstr(topic, KK_FILTER_STATUS_ONLINE) != NULL && \
 		strstr(topic,KK_FILTER_STATUS_ONLINE_REPLY) == NULL){
 		return 1;

common/api/com_api.h

@@ -47,6 +47,20 @@ typedef enum {
 #define MSG_AREA_ROOM_ACTION     	  				"action"
 #define MSG_AREA_ADDROOM_NOTIFICATION         		"addRoomNotification"
 #define MSG_AREA_ADDROOM_NOTIFICATION_ROOMID        "addRoomNotification.roomId"
+#define MSG_TIMER_SETLOCALTIMER_LOCALTIMER          "LocalTimer"
+#define MSG_TIMER_SETLOCALTIMER_TIMER               "Timer"
+#define MSG_TIMER_SETLOCALTIMER_ENABLE              "Enable"
+#define MSG_TIMER_SETLOCALTIMER_ISVALID             "IsValid"
+#define MSG_TIMER_SETLOCALTIMER_ZONEOFFSET          "TimezoneOffset"
+#define MSG_TIMER_SETLOCALTIMER_TARGETS             "Targets"
+#define MSG_TIMER_GETLOCALTIMER_GETLOCALTIMER       "getLocalTimer"
+#define MSG_REBOOT_REBOOTNOTIFICATION               "rebootNotification"
+#define MSG_TIMER_SETCOUNTDOWN_COUNTDOWN            "CountDown"
+#define MSG_TIMER_SETCOUNTDOWN_DELAYTIME            "DelayTime"
+#define MSG_TIMER_SETCOUNTDOWN_CURRENTTIME          "CurrentTime"
+#define MSG_TIMER_SETCOUNTDOWN_GETCOUNTDOWN         "getCountDown"
+#define MSG_PROPERTY_STR                            "property"
+
 
 
 

midware/midware/area/id.c

+#include "id.h"
+ 
+struct globle g_info;
+#define   sequenceMask  (-1L ^ (-1L << 12L))
+void set_workid(int workid)
+{
+ g_info.workid = workid;
+}
+pid_t gettid( void )
+{
+	return syscall( __NR_gettid );
+}
+uint64_t get_curr_ms()
+{
+	struct timeval time_now;
+	gettimeofday(&time_now,NULL);
+	uint64_t ms_time =time_now.tv_sec*1000+time_now.tv_usec/1000;
+	return ms_time;
+}
+ 
+uint64_t wait_next_ms(uint64_t lastStamp)
+{
+	uint64_t cur = 0;
+	do {
+		cur = get_curr_ms();
+	} while (cur <= lastStamp);
+	return cur;
+}
+int atomic_incr(int id)
+{
+	__sync_add_and_fetch( &id, 1 );
+	return id;
+}
+uint64_t get_unique_id()
+{
+	uint64_t  uniqueId=0;
+	uint64_t nowtime = get_curr_ms();
+	uniqueId = nowtime<<22;
+	uniqueId |=(g_info.workid&0x3ff)<<12;
+ 
+	if (nowtime <g_info.last_stamp)
+	{
+		perror("error");
+		exit(-1);
+	}
+	if (nowtime == g_info.last_stamp)
+	{
+		g_info.seqid = atomic_incr(g_info.seqid)& sequenceMask;
+		if (g_info.seqid ==0)
+		{
+			nowtime = wait_next_ms(g_info.last_stamp);
+		}
+	}
+	else
+	{
+		g_info.seqid  = 0;
+	}
+	g_info.last_stamp = nowtime;
+	uniqueId |=g_info.seqid;
+	return uniqueId;
+}

midware/midware/area/id.h

+/*
+	snowflake
+	
+	ID 生成策略
+	毫秒级时间41位+机器ID 10位+毫秒内序列12位。
+	0 41 51 64 +-----------+------+------+ |time |pc |inc | +-----------+------+------+
+	前41bits是以微秒为单位的timestamp。
+	接着10bits是事先配置好的机器ID。
+	最后12bits是累加计数器。
+	macheine id(10bits)标明最多只能有1024台机器同时产生ID，sequence number(12bits)也标明1台机器1ms中最多产生4096个ID， *
+	  注意点，因为使用到位移运算，所以需要64位操作系统，不然生成的ID会有可能不正确
+*/
+ 
+#include <stdio.h>
+#include <pthread.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <sched.h>
+#include <linux/unistd.h>
+#include <sys/syscall.h>
+#include <errno.h>
+#include<linux/types.h>
+#include<time.h>
+#include <stdint.h>
+#include <sys/time.h>
+ 
+struct  globle
+{
+	int global_int:12;
+	uint64_t last_stamp;
+	int workid;
+	int seqid;
+};
+ 
+void set_workid(int workid);
+pid_t gettid( void );
+uint64_t get_curr_ms();
+uint64_t wait_next_ms(uint64_t lastStamp);
+int atomic_incr(int id);
+uint64_t get_unique_id();
\ No newline at end of file

midware/midware/area/kk_area_handle.c

@@ -5,7 +5,7 @@
 #include "kk_log.h"
 #include "kk_area_handle.h"
 
-#define KK_AREA_DB_FILE                                   "kk_area.db"
+#define KK_AREA_DB_FILE                                   "/usr/kk/kk_area.db"
 
 static kk_dev_list_t *s_device_list = NULL;
 
@@ -105,7 +105,7 @@ int kk_area_init(void)
 {
 	int res = 0;
     kk_area_ctx_t *ctx = _kk_area_get_ctx();
-	
+	set_workid(100);
     /* Create Mutex */
     ctx->mutex = HAL_MutexCreate();
     if (ctx->mutex == NULL) {
@@ -122,19 +122,21 @@ int kk_area_init(void)
 }
 
 
-int kk_room_add(const char *name)
+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[10] = {0};
+	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++;
-	sprintf(roomId,"%d",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);
@@ -146,7 +148,7 @@ int kk_room_add(const char *name)
 	}
 	sqlite3_free(sqlCmd);
 	_kk_area_unlock();
-	return ctx->roomNum;
+	return u64RoomId;
 }
 
 int kk_room_delete(const char *roomId)

midware/midware/dm/kk_dm_mng.c

@@ -549,6 +549,52 @@ static int _dm_mgr_upstream_request_assemble(_IN_ int msgid, _IN_ int devid,
 
     return SUCCESS_RETURN;
 }
+
+const char DM_URI_THING_SERVICE_POST[] = "/thing/service/%s_reply";
+const char DM_MSG_THING_UPSTREAM_SERVICE_PARAMS[] DM_READ_ONLY = "%s";
+static int _dm_mgr_upstream_service_assemble(_IN_ int msgid, _IN_ int devid,
+		_IN_ char *identify,
+		_IN_ char *params, _IN_ int params_len, _IN_ char *method, _OU_ dm_msg_request_t *request)
+{
+	int res = 0;
+	dm_mgr_dev_node_t *node = NULL;
+	int paramLen = 0;
+	int msgTypeLen = 0;
+	char *payload_param = NULL;
+	res = dm_mgr_search_dev_by_devid(devid, &node);
+	if (res != SUCCESS_RETURN) {
+		return FAIL_RETURN;
+	}
+
+	/* dm_log_debug("Time Stamp: %s", timestamp); */
+	paramLen = strlen(DM_MSG_THING_UPSTREAM_SERVICE_PARAMS) +
+					params_len + 1;
+	payload_param = malloc(paramLen);
+	if (payload_param == NULL) {
+	  return MEMORY_NOT_ENOUGH;
+	}
+
+	memset(payload_param, 0, paramLen);
+	HAL_Snprintf(payload_param, paramLen, DM_MSG_THING_UPSTREAM_REQUEST_PARAMS, params);
+
+	request->msgid = msgid;
+	request->devid = devid;
+	msgTypeLen = strlen(DM_URI_THING_SERVICE_POST) + strlen(identify) + 1;
+	request->msgTypeStr = malloc(msgTypeLen);
+	if(request->msgTypeStr == NULL){
+		return MEMORY_NOT_ENOUGH;
+	}
+	memset(request->msgTypeStr,0x0,msgTypeLen);
+	snprintf(request->msgTypeStr,msgTypeLen,DM_URI_THING_SERVICE_POST,identify);
+	memcpy(request->productCode, node->productCode, strlen(node->productCode)); 
+	memcpy(request->deviceCode, node->deviceCode, strlen(node->deviceCode));
+	request->params = payload_param;
+	request->params_len = paramLen;
+	request->method = method;
+
+	return SUCCESS_RETURN;
+}
+
 static unsigned int g_report_id = 1;
 
 int iotx_report_id(void)
@@ -609,6 +655,34 @@ int dm_mgr_upstream_thing_event_post(_IN_ int devid, _IN_ char *identifier, _IN_
     return res;
 }
 
+int dm_mgr_upstream_thing_service_post(_IN_ int devid, _IN_ char *identifier, _IN_ int identifier_len, _IN_ char *method,
+                                     _IN_ char *payload, _IN_ int payload_len)
+{
+    int res = 0;
+
+    dm_msg_request_t request;
+
+    if (devid < 0 || identifier == NULL || identifier_len <= 0 ||
+        method == NULL || payload == NULL || payload_len <= 0) {
+        return INVALID_PARAMETER;
+    }
+    memset(&request, 0, sizeof(dm_msg_request_t));
+    res = _dm_mgr_upstream_service_assemble(iotx_report_id(), devid,identifier,
+                                            payload, payload_len, method, &request);
+    if (res != SUCCESS_RETURN) {
+        return FAIL_RETURN;
+    }
+
+    /* Callback */
+    //request.callback = dm_client_thing_event_post_reply;
+
+    /* Send Message To Cloud */
+    res = dm_msg_request(&request,0);
+	free(request.msgTypeStr);
+	free(request.params);
+    return res;
+}
+
 const char DM_URI_THING_SERVICE_RESPONSE[] = "/thing/service/%.*s_reply";
 static int _kk_mgr_upstream_response_assemble(_IN_ int devid, _IN_ char *msgid, _IN_ int msgid_len,
         _IN_ const char *identfy, _IN_ int code, _OU_ kk_msg_request_payload_t *request, _OU_ kk_msg_response_t *response)

midware/midware/dm/kk_dm_msg.c

@@ -777,14 +777,15 @@ int dm_msg_thing_event_post(const char *deviceCode, const char *identifier)
 	}
 	return SUCCESS_RETURN;
 }
-int dm_msg_thing_service_post(const char *deviceCode, const char *identifier,int response_id,int code)
+int dm_msg_thing_service_post(const char *deviceCode, const char *identifier)
 {
 	int res = 0;
 	int nums = 0;
 	int idx = 0; 
 	char *payload = NULL;
 	dm_mgr_dev_node_t *node = NULL; 
-
+	char *method = NULL;
+    void *service = NULL;
 
 	if(deviceCode == NULL){
 		return FAIL_RETURN;
@@ -796,9 +797,23 @@ int dm_msg_thing_service_post(const char *deviceCode, const char *identifier,int
 	}
 	payload = kk_tsl_get_post_service_str(node->dev_shadow,identifier);
 	if(payload != NULL){	
-	    dm_mgr_deprecated_upstream_thing_service_response(node->devid,response_id,code, identifier, strlen(identifier), payload, strlen(payload));
+	    res = kk_tsl_get_service_by_identifier(node->dev_shadow, identifier, &service);
+	    if (res != SUCCESS_RETURN) {
+	        free(payload);
+			return FAIL_RETURN;
+
+	    }			
+		res = kk_tsl_get_service_method(service,&method);
+	    if (res != SUCCESS_RETURN) {
+	        free(payload);
+			return FAIL_RETURN;
+	    }		
+	    dm_mgr_upstream_thing_service_post(node->devid, identifier, strlen(identifier),method, payload, strlen(payload));
+		free(method);
+		method = NULL;
 		free(payload);
 		payload = NULL;
+
 	}
 	return SUCCESS_RETURN;
 }

midware/midware/dm/kk_dm_msg.h

@@ -61,6 +61,12 @@ const char DM_MSG_INFO[] DM_READ_ONLY;
 #define KK_THING_SERVICE_ADDDEVICETOROOM          "/thing/service/addDeviceToRoom"
 #define KK_THING_SERVICE_REMOVEDEVICEFROMROOM     "/thing/service/removeDeviceFromRoom"
 #define KK_THING_SERVICE_EXECUTEROOM              "/thing/service/executeRoom"
+#define KK_THING_SERVICE_SETLOCALTIMER            "/thing/service/setLocalTimer"
+#define KK_THING_SERVICE_GETLOCALTIMER            "/thing/service/getLocalTimer"
+#define KK_THING_SERVICE_SETCOUNTDOWN             "/thing/service/setCountDown"
+#define KK_THING_SERVICE_GETCOUNTDOWN             "/thing/service/getCountDown"
+#define KK_THING_EVENT_MESSAGE                    "/thing/event/"
+#define KK_THING_EVENT_POST                       "/post"
 
 
 

midware/midware/dm/kk_linkkit.c

@@ -262,7 +262,7 @@ static int kk_topo_delete_handle(cJSON *payload)
 static int kk_service_addRoom_handle(const char *deviceCode, cJSON *params)
 {
 	dm_mgr_dev_node_t *node = NULL;
-	char roomId[10] = {0};
+	char roomId[32] = {0};
 	int res = 0;
 	int idx = 0,idxIpt = 0;
 	int start  = 0,serverNum = 0;
@@ -281,8 +281,8 @@ static int kk_service_addRoom_handle(const char *deviceCode, cJSON *params)
 	if(roomInfoStr == NULL){
 		return FAIL_RETURN;
 	}
-	int id = kk_room_add(roomInfoStr->valuestring);
-	sprintf(roomId,"%d",id);
+	uint64_t id = kk_room_add(roomInfoStr->valuestring);
+	sprintf(roomId,"%u",id);
 	kk_tsl_set_value(kk_tsl_set_event_output_value,node->dev_shadow,MSG_AREA_ADDROOM_NOTIFICATION_ROOMID,NULL,roomId);	
 	return SUCCESS_RETURN;
 	
@@ -406,6 +406,102 @@ static int kk_service_executeRoom_handle(cJSON *params)
 	kk_free_room_dev_list();
 	return SUCCESS_RETURN;
 }
+static int kk_service_setLocalTimer_handle(cJSON *params,const char *deviceCode)
+{
+	int res = 0;
+	kk_dev_list_t *pList = NULL;
+	dm_mgr_dev_node_t *search_node = NULL;	
+	char *timer = NULL,*targets = NULL;
+	int isEnable  = 0, isValid = 0, zoneOffset = 0;
+	int size = 0	;
+
+	if(params == NULL || deviceCode == NULL){
+		return INVALID_PARAMETER;
+	}
+	res = dm_mgr_get_device_by_devicecode(deviceCode,&search_node);	
+    if (res < SUCCESS_RETURN) {
+		ERROR_PRINT("dm_mgr_get_device_by_devicecode failed\n");
+        return res;
+    }
+
+	size = kk_service_get_array_size(search_node->dev_shadow);
+	
+	cJSON *LocalTimerArray = cJSON_GetObjectItem(params, MSG_TIMER_SETLOCALTIMER_LOCALTIMER);	
+	if(LocalTimerArray == NULL){
+		return FAIL_RETURN;
+	}
+	cJSON * item = LocalTimerArray->child;
+	while(item != NULL){
+
+		timer = cJSON_GetObjectItem(item,MSG_TIMER_SETLOCALTIMER_TIMER)->valuestring;
+	    isEnable = cJSON_GetObjectItem(item,MSG_TIMER_SETLOCALTIMER_ENABLE)->valueint;
+		isValid = cJSON_GetObjectItem(item,MSG_TIMER_SETLOCALTIMER_ISVALID)->valueint;
+		zoneOffset = cJSON_GetObjectItem(item,MSG_TIMER_SETLOCALTIMER_ZONEOFFSET)->valueint;
+		targets = cJSON_GetObjectItem(item,MSG_TIMER_SETLOCALTIMER_TARGETS)->valuestring;
+		kk_service_localtimer_set(search_node->dev_shadow,timer,isEnable,isValid,zoneOffset,targets,size);
+		item = item->next;
+	}
+	return SUCCESS_RETURN;
+}
+static int kk_service_getLocalTimer_handle(const char *deviceCode)
+{
+	if(deviceCode == NULL){
+		return INVALID_PARAMETER;
+	}
+	dm_msg_thing_service_post(deviceCode,MSG_TIMER_GETLOCALTIMER_GETLOCALTIMER);
+
+	return SUCCESS_RETURN;
+}
+
+static int kk_service_setCountDown_handle(cJSON *params,const char *deviceCode)
+{
+	int res = 0;
+	kk_dev_list_t *pList = NULL;
+	dm_mgr_dev_node_t *search_node = NULL;	
+	char *targets = NULL;
+	int isEnable  = 0, isValid = 0, delaytimer = 0,current = 0;
+	int size = 0	;
+
+	if(params == NULL || deviceCode == NULL){
+		return INVALID_PARAMETER;
+	}
+	res = dm_mgr_get_device_by_devicecode(deviceCode,&search_node);	
+    if (res < SUCCESS_RETURN) {
+		ERROR_PRINT("dm_mgr_get_device_by_devicecode failed\n");
+        return res;
+    }
+
+	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;
+	}
+	cJSON * item = LocalTimerArray->child;
+	while(item != NULL){
+		printf("[%s][%d]\n",__FUNCTION__,__LINE__);
+		delaytimer = cJSON_GetObjectItem(item,MSG_TIMER_SETCOUNTDOWN_DELAYTIME)->valueint;
+	    current = cJSON_GetObjectItem(item,MSG_TIMER_SETCOUNTDOWN_CURRENTTIME)->valueint;
+		isValid = cJSON_GetObjectItem(item,MSG_TIMER_SETLOCALTIMER_ISVALID)->valueint;
+		isEnable = cJSON_GetObjectItem(item,MSG_TIMER_SETLOCALTIMER_ENABLE)->valueint;
+		targets = cJSON_GetObjectItem(item,MSG_TIMER_SETLOCALTIMER_TARGETS)->valuestring;
+		kk_service_setCountDown_set(search_node->dev_shadow,delaytimer,current,isEnable,isValid,targets,size);
+		item = item->next;
+	}
+	return SUCCESS_RETURN;
+}
+
+static int kk_service_getCountDown_handle(const char *deviceCode)
+{
+	if(deviceCode == NULL){
+		return INVALID_PARAMETER;
+	}
+	dm_msg_thing_service_post(deviceCode,MSG_TIMER_SETCOUNTDOWN_GETCOUNTDOWN);
+
+	return SUCCESS_RETURN;
+}
+
+
 static void _iotx_linkkit_event_callback(iotx_dm_event_types_t type, char *data)
 {
     //INFO_PRINT("_iotx_linkkit_event_callback ================== [%s]\n",data);
@@ -506,36 +602,63 @@ static void _iotx_linkkit_event_callback(iotx_dm_event_types_t type, char *data)
    }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);	
-		dm_msg_thing_event_post(deviceCode->valuestring,"rebootNotification");
+		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(" addRoom called!!!\n");
+		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);
    }
    else if(strcmp(typeJson->valuestring,KK_THING_SERVICE_DELETEROOM) == 0){
+   	    INFO_PRINT(" delete room  \n");
    		cJSON *paramStr = cJSON_GetObjectItem(payload, MSG_PARAMS_STR);	
    		kk_service_deleteRoom_handle(paramStr);
 
    }
    else if(strcmp(typeJson->valuestring,KK_THING_SERVICE_ADDDEVICETOROOM) == 0){
+   	    INFO_PRINT(" adddevicetoroom  \n");
    		cJSON *paramStr = cJSON_GetObjectItem(payload, MSG_PARAMS_STR);	
    		kk_service_addDeviceToRoom_handle(paramStr);
    }  
    else if(strcmp(typeJson->valuestring,KK_THING_SERVICE_REMOVEDEVICEFROMROOM) == 0){
+   		INFO_PRINT(" removedevicefromroom  \n");
    		cJSON *paramStr = cJSON_GetObjectItem(payload, MSG_PARAMS_STR);	
    		kk_service_removeDeviceFromRoom_handle(paramStr);
    }   
    else if(strcmp(typeJson->valuestring,KK_THING_SERVICE_EXECUTEROOM) == 0){
-   	   INFO_PRINT(" executeroom  \n");
-	   cJSON *paramStr = cJSON_GetObjectItem(payload, MSG_PARAMS_STR); 
-	   kk_service_executeRoom_handle(paramStr);
+   	    INFO_PRINT(" executeroom  \n");
+	    cJSON *paramStr = cJSON_GetObjectItem(payload, MSG_PARAMS_STR); 
+	    kk_service_executeRoom_handle(paramStr);
 
    }
+   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);
+   		printf("[%s][%d]deviceCode->valuestring:%s\n",__FUNCTION__,__LINE__,deviceCode->valuestring);
+		kk_service_getCountDown_handle(deviceCode->valuestring);
+   }     
    else{
         INFO_PRINT("Error msgtype!!! \n");
         

midware/midware/timer/kk_timer_handle.c

+#include <stdio.h>
+#include "kk_tsl_api.h"
+#include "kk_dm_mng.h"
+#include "sqlite3.h"
+#include "kk_log.h"
+#include "kk_timer_handle.h"
+
+//#define KK_AREA_DB_FILE                                   "kk_area.db"
+
+//static kk_dev_list_t *s_device_list = NULL;
+#define KK_TSL_SETLOCALTIMER_TIMER      	   "getLocalTimer.LocalTimer[%d].Timer"
+#define KK_TSL_SETLOCALTIMER_ENABLE      	   "getLocalTimer.LocalTimer[%d].Enable"
+#define KK_TSL_SETLOCALTIMER_ISVALID      	   "getLocalTimer.LocalTimer[%d].IsValid"
+#define KK_TSL_SETLOCALTIMER_ZONEOFFSET        "getLocalTimer.LocalTimer[%d].TimezoneOffset"
+#define KK_TSL_SETLOCALTIMER_TARGETS           "getLocalTimer.LocalTimer[%d].Targets"
+
+#define KK_TSL_SETCOUNTDOWN_DELAYTIME      	   "getCountDown.CountDown[%d].DelayTime"
+#define KK_TSL_SETCOUNTDOWN_CURRENTTIME        "getCountDown.CountDown[%d].CurrentTime"
+#define KK_TSL_SETCOUNTDOWN_ENABLE      	   "getCountDown.CountDown[%d].Enable"
+#define KK_TSL_SETCOUNTDOWN_ISVALID            "getCountDown.CountDown[%d].IsValid"
+#define KK_TSL_SETCOUNTDOWN_TARGETS            "getCountDown.CountDown[%d].Targets"
+
+typedef struct {
+    void *mutex;
+	void *s_timer_thread;	
+	int  timerNum;
+    int  countDownNum;	
+   // sqlite3 *pDb;	
+} kk_timer_ctx_t;
+
+typedef struct kk_timer_list{
+	char deviceCode[DEVICE_CODE_MAXLEN];	
+    uint64_t startTime;
+	uint64_t endTime;	
+	int isValid;
+    int isEnable;	
+	int action;
+	struct kk_timer_list *next;
+   // sqlite3 *pDb;	
+} kk_timer_info_t;
+   
+static kk_timer_info_t *p_timer_info_list = NULL;
+
+static kk_timer_ctx_t s_kk_timer_ctx = {NULL,0,0};
+
+static kk_timer_ctx_t *_kk_timer_get_ctx(void)
+{
+    return &s_kk_timer_ctx;
+}
+static void _kk_timer_lock(void)
+{
+    kk_timer_ctx_t *ctx = _kk_timer_get_ctx();
+    if (ctx->mutex) {
+        HAL_MutexLock(ctx->mutex);
+    }
+}
+
+static void _kk_timer_unlock(void)
+{
+    kk_timer_ctx_t *ctx = _kk_timer_get_ctx();
+	
+    if (ctx->mutex) {
+        HAL_MutexUnlock(ctx->mutex);
+    }
+}
+void *kk_timer_yield(void *args)
+{
+	uint64_t current_time = 0;
+    kk_timer_info_t *ptr = NULL,*ptemp = NULL;	
+    while (1) {
+		
+		kk_timer_info_t *ptr = p_timer_info_list;
+		while(ptr){
+
+		}
+		sleep(5);
+    }
+
+    return NULL;
+}
+
+int kk_timer_init(void)
+{
+	int res = 0;
+    kk_timer_ctx_t *ctx = _kk_timer_get_ctx();
+	
+    /* Create Mutex */
+    ctx->mutex = HAL_MutexCreate();
+    if (ctx->mutex == NULL) {
+        return FAIL_RETURN;
+    }
+    res = pthread_create(&ctx->s_timer_thread, NULL, kk_timer_yield, NULL);
+    if (res < 0) {
+        ERROR_PRINT("HAL_ThreadCreate mid Failed\n");
+        //IOT_Linkkit_Close(mid_ctx->master_devid);
+        return -1;
+    }	
+	return SUCCESS_RETURN;
+}
+
+int kk_service_get_array_size(kk_tsl_t *shadow)
+{
+	int idx = 0,index = 0,num = 0,outputNum = 0;
+	kk_tsl_service_t *serviceItem = NULL;
+	kk_tsl_data_t *serviceData = NULL;
+	if(shadow == NULL){
+		return FAIL_RETURN;
+	}
+	num = shadow->service_number;
+	for(idx = 0; idx < num; idx++){
+		serviceItem = shadow->services + idx;
+		if(strcmp(serviceItem->identifier,MSG_TIMER_GETLOCALTIMER_GETLOCALTIMER) == 0){
+			outputNum = serviceItem->output_data_number;
+			for(index = 0; index < outputNum; index ++){
+				serviceData = serviceItem->output_datas + index;
+				if(strcmp(serviceData->identifier,MSG_TIMER_SETLOCALTIMER_LOCALTIMER) == 0){
+					kk_tsl_data_value_complex_t *complex_struct = serviceData->data_value.value;
+					return complex_struct->size;
+				}
+			}
+			
+
+		}
+	}
+	return FAIL_RETURN;
+}
+int kk_service_localtimer_set(kk_tsl_t *shadow,const char *timer,int isEnable,int isValid,int TimezoneOffset,const char *Targets,int size)
+{
+    kk_timer_ctx_t *ctx = _kk_timer_get_ctx();	
+	int res = 0;
+	int index  = 0;
+	char identifier_name[256] = {0};	
+	if(shadow == NULL){
+		return INVALID_PARAMETER;
+	}
+
+	if(ctx->timerNum >= size){
+		ctx->timerNum = 0;
+	}
+	_kk_timer_lock();
+	sprintf(identifier_name,KK_TSL_SETLOCALTIMER_TIMER,ctx->timerNum);
+	kk_tsl_set_value(kk_tsl_set_service_output_value,shadow,identifier_name,NULL,timer);
+	
+	memset(identifier_name,0x0,sizeof(identifier_name));
+	sprintf(identifier_name,KK_TSL_SETLOCALTIMER_ENABLE,ctx->timerNum);
+	kk_tsl_set_value(kk_tsl_set_service_output_value,shadow,identifier_name,&isEnable,NULL);
+
+	memset(identifier_name,0x0,sizeof(identifier_name));
+	sprintf(identifier_name,KK_TSL_SETLOCALTIMER_ISVALID,ctx->timerNum);
+	kk_tsl_set_value(kk_tsl_set_service_output_value,shadow,identifier_name,&isValid,NULL);
+
+	memset(identifier_name,0x0,sizeof(identifier_name));
+	sprintf(identifier_name,KK_TSL_SETLOCALTIMER_ZONEOFFSET,ctx->timerNum);
+	kk_tsl_set_value(kk_tsl_set_service_output_value,shadow,identifier_name,&TimezoneOffset,NULL);
+
+
+	memset(identifier_name,0x0,sizeof(identifier_name));
+	sprintf(identifier_name,KK_TSL_SETLOCALTIMER_TARGETS,ctx->timerNum);
+	kk_tsl_set_value(kk_tsl_set_service_output_value,shadow,identifier_name,NULL,Targets);
+
+	_kk_timer_unlock();
+	ctx->timerNum++;
+	return SUCCESS_RETURN;
+	
+}
+
+int kk_service_setCountDown_set(kk_tsl_t *shadow,int delaytime,int CurrentTime,int isEnable,int isValid,const char *Targets,int size)
+{
+    kk_timer_ctx_t *ctx = _kk_timer_get_ctx();	
+	int res = 0;
+	int index  = 0;
+	char identifier_name[256] = {0};	
+	if(shadow == NULL){
+		return INVALID_PARAMETER;
+	}
+
+	if(ctx->countDownNum >= size){
+		ctx->countDownNum = 0;
+	}
+	_kk_timer_lock();
+	sprintf(identifier_name,KK_TSL_SETCOUNTDOWN_DELAYTIME,ctx->countDownNum);
+	kk_tsl_set_value(kk_tsl_set_service_output_value,shadow,identifier_name,&delaytime,NULL);
+	
+	memset(identifier_name,0x0,sizeof(identifier_name));
+	sprintf(identifier_name,KK_TSL_SETCOUNTDOWN_CURRENTTIME,ctx->countDownNum);
+	kk_tsl_set_value(kk_tsl_set_service_output_value,shadow,identifier_name,&CurrentTime,NULL);
+
+	memset(identifier_name,0x0,sizeof(identifier_name));
+	sprintf(identifier_name,KK_TSL_SETCOUNTDOWN_ENABLE,ctx->countDownNum);
+	kk_tsl_set_value(kk_tsl_set_service_output_value,shadow,identifier_name,&isEnable,NULL);
+
+	memset(identifier_name,0x0,sizeof(identifier_name));
+	sprintf(identifier_name,KK_TSL_SETCOUNTDOWN_ISVALID,ctx->countDownNum);
+	kk_tsl_set_value(kk_tsl_set_service_output_value,shadow,identifier_name,&isValid,NULL);
+
+
+	memset(identifier_name,0x0,sizeof(identifier_name));
+	sprintf(identifier_name,KK_TSL_SETCOUNTDOWN_TARGETS,ctx->countDownNum);
+	kk_tsl_set_value(kk_tsl_set_service_output_value,shadow,identifier_name,NULL,Targets);
+
+	_kk_timer_unlock();
+	ctx->countDownNum++;
+	return SUCCESS_RETURN;
+	
+}
+
+int kk_add_timer_to_list(uint64_t startTime,uint64_t endTime,int isValid, int isEnable, int action,const char *deviceCode)
+{
+	kk_timer_info_t *ptr = NULL,*ptemp = NULL;
+
+	ptemp = ptr = p_timer_info_list;
+	while(ptr){
+		ptemp = ptr;
+		ptr = ptr->next;
+	}
+	ptr = (kk_timer_info_t*)malloc(sizeof(kk_timer_info_t));
+	if(ptr == NULL){
+		return FAIL_RETURN;
+	}
+	memcpy(ptr->deviceCode,deviceCode,strlen(deviceCode));
+	ptr->startTime = startTime;
+	ptr->endTime = endTime;
+	ptr->isValid = isValid;
+	ptr->isEnable = isEnable;	
+	ptr->action = action;	
+	if(p_timer_info_list == NULL){
+		p_timer_info_list = ptr;
+	}else{
+		ptemp->next = ptr;
+	}
+	return SUCCESS_RETURN;
+}
+
+int kk_del_timer_from_list(uint64_t startTime,uint64_t endTime,const char *deviceCode)
+{
+	kk_timer_info_t *ptr = NULL,*ptemp = NULL;
+
+	ptemp = ptr = p_timer_info_list;
+	while(ptr){
+		ptemp = ptr;
+		if(strcmp(ptr->deviceCode,deviceCode) ==0 && \
+			ptr->startTime == startTime && \
+			ptr->endTime == endTime){
+				ptemp->next = ptr->next;
+				free(ptr);
+				ptr = NULL;
+				return SUCCESS_RETURN;
+			}
+			
+		ptr = ptr->next;
+	}
+	return FAIL_RETURN;
+}
+
+
+
+

midware/midware/timer/kk_timer_handle.h

+#ifndef __KK_TIMER_H__
+#define __KK_TIMER_H__
+
+#include "kk_tsl_common.h"
+typedef struct kk_dev_list{
+	char  deviceCode[DEVICE_CODE_MAXLEN];
+	struct kk_dev_list * next;
+}kk_dev_list_t;
+
+
+#endif
+

midware/tsl/tsl_handle/kk_tsl_api.c

@@ -419,7 +419,6 @@ static int _kk_set_event_output_value(_IN_ kk_tsl_t *dev_shadow, _IN_ char *key,
     void *data = NULL;
     kk_tsl_data_type_e type;
 	
-
     if (dev_shadow == NULL || key == NULL || key_len <= 0 || ((value == NULL) && (value_str == NULL))) {
         return INVALID_PARAMETER;
     }
@@ -1363,6 +1362,40 @@ int kk_tsl_get_event_by_identifier(_IN_ kk_tsl_t *dev_shadow, _IN_ char *identif
 
     return _kk_tsl_get_event_by_identifier(dev_shadow, identifier, event);
 }
+
+static int _kk_tsl_get_service_by_identifier(_IN_ kk_tsl_t *shadow, _IN_ char *identifier, _OU_ void **service)
+{
+    int index = 0;
+    kk_tsl_event_t *search_event = NULL;
+
+    if (shadow == NULL || identifier == NULL ||
+        service == NULL || *service != NULL) {
+        return INVALID_PARAMETER;
+    }
+
+    for (index = 0; index < shadow->service_number; index++) {
+        search_event = shadow->services + index;
+        if ((strlen(search_event->identifier) == strlen(identifier)) &&
+            (memcmp(search_event->identifier, identifier, strlen(identifier)) == 0)) {
+            *service = (void *)search_event;
+            return SUCCESS_RETURN;
+        }
+    }
+
+    return FAIL_RETURN;
+}
+
+int kk_tsl_get_service_by_identifier(_IN_ kk_tsl_t *dev_shadow, _IN_ char *identifier, _OU_ void **service)
+{
+    int res = 0;
+
+    if (dev_shadow == NULL || identifier == NULL || service == NULL || *service != NULL) {
+        return INVALID_PARAMETER;
+    }
+
+    return _kk_tsl_get_service_by_identifier(dev_shadow, identifier, service);
+}
+
 int kk_tsl_get_event_method(_IN_ void *event, _OU_ char **method)
 {
     int event_method_len = 0;
@@ -1477,6 +1510,31 @@ static char* _kk_tsl_send_service_response(_IN_ kk_tsl_t *dev_shadow,
     //free(payload);
     return payload;
 }
+int kk_tsl_get_service_method(_IN_ void *service, _OU_ char **method)
+{
+	int service_method_len = 0;
+	const char *identifier = NULL;
+	const char *service_method_fmt = "thing.service.%s_reply";
+	kk_tsl_service_t *service_item = (kk_tsl_service_t *)service;
+
+	if (service_item == NULL || method == NULL || *method != NULL) {
+		return INVALID_PARAMETER;
+	}
+
+
+	identifier = (const char *)service_item->identifier;
+	
+
+	service_method_len = (strlen(service_method_fmt) + strlen(identifier) + 1);
+	*method = malloc(service_method_len);
+	if (*method == NULL) {
+		return MEMORY_NOT_ENOUGH;
+	}
+	memset(*method, 0, service_method_len);
+	snprintf(*method, service_method_len, service_method_fmt, identifier);
+
+	return SUCCESS_RETURN;
+}
 
 char * kk_tsl_get_post_service_str(kk_tsl_t *dev_shadow, const char *service_identifier)
 {

platform/zigbee/app/builder/Z3GatewayHost/ZB/kk_device_manager.c

@@ -206,6 +206,9 @@ void kk_add_device_to_table(EmberEUI64 mac,EmberNodeId nodeId,uint16_t deviceId)
 	
 	kk_device_table_add(mac,nodeId,NULL,deviceId);
 	kk_device_db_insert(mac,nodeId,deviceId,"");
+	//kk_msg_report_dev_joined(mac,"85");
+	//kk_device_db_update(mac,nodeId,deviceId,"85");
+	//kk_device_config_map_add("85");	
 }
 
 
@@ -329,6 +332,7 @@ void kk_device_map_print(void )
 		}
 		ptr = ptr->next;
 	}
+	
 }
 void kk_load_dev_map_table(void)
 {
@@ -752,7 +756,7 @@ void kk_add_dev_config_map_table_to_list(cJSON * root,const char *productCode)
 			
 			for(j=0;j<extraSize;j++){
 				extraData = rpc_cJSON_GetArrayItem(extraRoot,j);
-				if(!strcmp("3073",productCode)){
+				if(!strcmp("1022",productCode)){
 					char buffer[20] = {0};
 					sprintf(buffer,"mode_%d",j+1);
 
@@ -878,6 +882,8 @@ bool kk_device_config_map_add(const char *productCode)
 	emberAfCorePrintln("devfile:%s\n",devfile);
 	kk_device_config_map_load(devfile,productCode);
 
+
+
 	return true;
 }
 void kk_device_config_map_print(void)