add

application/klansdk/kk_ccu_msg.c

+#include "kk_ccu_msg.h"
+
+cJSON *bool_type_convert(cJSON *n_id,cJSON *n_dataType);
+cJSON *int_type_convert(cJSON *n_id,cJSON *n_dataType);
+cJSON *double_type_convert(cJSON *n_id,cJSON *n_dataType);
+cJSON *string_bool_type_convert(cJSON *n_id,cJSON *n_dataType);
+cJSON *string_int_type_convert(cJSON *n_id,cJSON *n_dataType);
+cJSON *string_double_type_convert(cJSON *n_id,cJSON *n_dataType);
+cJSON *string_time_type_convert(cJSON *n_id,cJSON *n_dataType);
+
+typedef cJSON *(*convert_func)(cJSON *,cJSON *);
+
+typedef struct
+{
+	char *type;
+	convert_func func;
+}CONVERT_ITEM_S;
+
+
+static CONVERT_ITEM_S convert_table[] = {
+	{"bool",bool_type_convert},
+	{"int",int_type_convert},
+	{"double",double_type_convert},
+	{"string_bool",string_bool_type_convert},
+	{"string_int",string_int_type_convert},
+	{"string_double",string_double_type_convert},
+	{"string_time",string_time_type_convert}
+};
+	
+
+cJSON *bool_type_convert(cJSON *n_id,cJSON *n_dataType)
+{
+	cJSON *args = NULL;
+	int bVal = 0;
+	
+	printf("[%s][%d]\n",__FUNCTION__,__LINE__);
+
+	if(strcmp(n_dataType->valuestring,"dummy")==0) {
+		return NULL;
+	}
+	
+	if((strcmp(n_dataType->valuestring,"int")==0) ||
+		(strcmp(n_dataType->valuestring,"bool")==0)){
+		args = cJSON_CreateBool(n_id->valueint);
+	}else if(strcmp(n_dataType->valuestring,"double")==0) {
+		bVal = (n_id->valuedouble>0) ? 1 : 0;
+		args = cJSON_CreateBool(bVal);
+	}else if(strcmp(n_dataType->valuestring,"string_bool")==0) {
+		if(strcmp(n_id->valuestring,"true")==0 ||
+			strcmp(n_id->valuestring,"TRUE")==0){
+			args = cJSON_CreateBool(1);
+		}else if(strcmp(n_id->valuestring,"true")==0 ||
+			strcmp(n_id->valuestring,"TRUE")==0){
+			args = cJSON_CreateBool(0);
+		}
+	}else if(strcmp(n_dataType->valuestring,"string_int")==0) {
+		int iVal = atoi(n_id->valuestring);
+		bVal = (iVal>0) ? 1 : 0;
+		args = cJSON_CreateBool(bVal);
+	}else if(strcmp(n_dataType->valuestring,"string_double")==0) {
+		double dVal = atof(n_id->valuestring);
+		bVal = (dVal>0) ? 1 : 0;
+		args = cJSON_CreateBool(bVal);
+	}
+	return args;
+}
+
+cJSON *int_type_convert(cJSON *n_id,cJSON *n_dataType)
+{
+	cJSON *args = NULL;
+	
+	printf("[%s][%d]\n",__FUNCTION__,__LINE__);
+
+	if(strcmp(n_dataType->valuestring,"dummy")==0) {
+		return NULL;
+	}
+
+	if((strcmp(n_dataType->valuestring,"int")==0) ||
+		(strcmp(n_dataType->valuestring,"bool")==0)){
+		args = cJSON_CreateNumber(n_id->valueint);
+	}else if(strcmp(n_dataType->valuestring,"double")==0) {
+		args = cJSON_CreateNumber(n_id->valuedouble);
+	}else if(strcmp(n_dataType->valuestring,"string_bool")==0) {
+		if(strcmp(n_id->valuestring,"true")==0 ||
+			strcmp(n_id->valuestring,"TRUE")==0){
+			args = cJSON_CreateNumber(1);
+		}else if(strcmp(n_id->valuestring,"true")==0 ||
+			strcmp(n_id->valuestring,"TRUE")==0){
+			args = cJSON_CreateNumber(0);
+		}
+	}else if(strcmp(n_dataType->valuestring,"string_int")==0) {
+		args = cJSON_CreateNumber(atoi(n_id->valuestring));
+	}else if(strcmp(n_dataType->valuestring,"string_double")==0) {
+		args = cJSON_CreateNumber((int)atof(n_id->valuestring));
+	}
+	return args;
+}
+
+cJSON *double_type_convert(cJSON *n_id,cJSON *n_dataType)
+{
+	return int_type_convert(n_id,n_dataType);
+}
+
+cJSON *string_bool_type_convert(cJSON *n_id,cJSON *n_dataType)
+{
+	cJSON *args = NULL;
+	int flag = -1;
+	
+	printf("[%s][%d]\n",__FUNCTION__,__LINE__);
+
+	if(strcmp(n_dataType->valuestring,"dummy")==0) {
+		return NULL;
+	}
+		
+	if((strcmp(n_dataType->valuestring,"int")==0) ||
+		(strcmp(n_dataType->valuestring,"bool")==0)){
+		flag = (n_id->valueint>0) ? 1 : 0;
+	}else if(strcmp(n_dataType->valuestring,"double")==0) {
+		flag = (n_id->valuedouble>0) ? 1 : 0;
+	}else if(strcmp(n_dataType->valuestring,"string_bool")==0) {
+		if(strcmp(n_id->valuestring,"true")==0 ||
+			strcmp(n_id->valuestring,"TRUE")==0){
+			flag = 1;
+		}else if(strcmp(n_id->valuestring,"false")==0 ||
+			strcmp(n_id->valuestring,"FALSE")==0){
+			flag = 0;
+		}
+	}else if(strcmp(n_dataType->valuestring,"string_int")==0) {
+		flag = (atoi(n_id->valuestring)>0) ? 1 : 0;
+	}else if(strcmp(n_dataType->valuestring,"string_double")==0) {
+		flag = ( atof(n_id->valuestring)>0) ? 1 : 0;
+	}
+
+	if(flag==1) {
+		args = cJSON_CreateString("true");
+	}else if(flag==0){
+		args = cJSON_CreateString("false");
+	}
+	
+	return args;
+}
+
+static cJSON *string_val_type_convert(int type,cJSON *n_id,cJSON *n_dataType)
+{
+	cJSON *args = NULL;
+	char sVal[32] = {0};
+	union {
+		int iVal;
+		double dVal;
+	}val = {0};
+	memset(sVal,0,sizeof(sVal));
+	
+	printf("[%s][%d]\n",__FUNCTION__,__LINE__);
+
+	if(strcmp(n_dataType->valuestring,"dummy")==0) {
+		return NULL;
+	}
+		
+	if((strcmp(n_dataType->valuestring,"int")==0) ||
+		(strcmp(n_dataType->valuestring,"bool")==0)){
+		if(type==1){
+			val.dVal = (n_id->valueint>0) ? 1 : 0;
+		}else{
+			val.iVal = (n_id->valueint>0) ? 1 : 0;
+		}
+	}else if(strcmp(n_dataType->valuestring,"double")==0) {
+		if(type==1){
+			val.dVal = n_id->valuedouble;
+		}else{
+			val.iVal = n_id->valueint;
+		}
+	}else if(strcmp(n_dataType->valuestring,"string_bool")==0) {
+		if(strcmp(n_id->valuestring,"true")==0 ||
+			strcmp(n_id->valuestring,"TRUE")==0){
+			if(type==1){
+				val.dVal = 1;
+			}else{
+				val.iVal = 1;
+			}
+		}else if(strcmp(n_id->valuestring,"false")==0 ||
+			strcmp(n_id->valuestring,"FALSE")==0)
+			if(type==1){
+				val.dVal = 0;
+			}else{
+				val.iVal = 0;
+			}
+	}else if(strcmp(n_dataType->valuestring,"string_int")==0) {
+		if(type==1){
+			val.dVal = atoi(n_id->valuestring);
+		}else{
+			val.iVal = atoi(n_id->valuestring);
+		}
+	}else if(strcmp(n_dataType->valuestring,"string_double")==0) {
+		if(type==1){
+			val.dVal = atof(n_id->valuestring);
+		}else{
+			val.iVal = atof(n_id->valuestring);
+		}
+	}
+	
+	if(type==1){
+		snprintf(sVal,sizeof(sVal),"%f",val.dVal);
+	}else{
+		snprintf(sVal,sizeof(sVal),"%d",val.iVal);
+	}
+
+	args = cJSON_CreateString(sVal);
+
+	return args;
+}
+
+cJSON *string_int_type_convert(cJSON *n_id,cJSON *n_dataType)
+{
+	return string_val_type_convert(0,n_id,n_dataType);
+}
+cJSON *string_double_type_convert(cJSON *n_id,cJSON *n_dataType)
+{
+	return string_val_type_convert(1,n_id,n_dataType);
+}
+
+cJSON *string_time_type_convert(cJSON *n_id,cJSON *n_dataType)
+{
+	cJSON *args = NULL;
+	int val;
+	char tm[10] = {0};
+	printf("[%s][%d]\n",__FUNCTION__,__LINE__);
+
+	if(strcmp(n_dataType->valuestring,"dummy")==0) {
+		return NULL;
+	}
+
+
+	if(strcmp(n_dataType->valuestring,"double")==0){
+		val = n_id->valuedouble * 10;
+
+		memset(tm,0,sizeof(tm));
+		snprintf(tm,sizeof(tm),"%02d:%2s",(int)n_id->valuedouble,((val%10>=5)?"30":"00"));
+		args = cJSON_CreateString(tm);
+	}
+
+	
+	return args;
+}
+
+
+
+
+
+
+
+
+cJSON * msg_convert_value(cJSON *d_type,cJSON *s_type,cJSON *value)
+{
+	int i,size;
+	cJSON *rlt = NULL;
+	CONVERT_ITEM_S *crt;
+
+	printf("[%s][%d]type:%s->%s,val=%s\n",__FUNCTION__,__LINE__,d_type->valuestring,s_type->valuestring,cJSON_Print(value));
+	
+	size = sizeof(convert_table)/sizeof(CONVERT_ITEM_S);
+	crt = &convert_table[0];
+	
+	for(i=0;i<size;i++,crt++){
+		if(strcmp(d_type->valuestring,crt->type)==0) {
+			rlt = crt->func(value,s_type);
+			break;
+		}
+	}
+	return rlt;
+}
+
+cJSON *map_type_convert(cJSON *s_dataType,cJSON *s_valueRange,cJSON *value,cJSON *d_valueRange)
+{
+	cJSON *args = NULL;
+	cJSON *rlt;
+	int j;
+
+	int vra_size = cJSON_GetArraySize(s_valueRange);
+	
+	printf("[%s][%d]type:%s\n",__FUNCTION__,__LINE__,s_dataType->valuestring);
+	printf("s_valueRange=%s\n",cJSON_Print(s_valueRange));
+	printf("d_valueRange=%s\n",cJSON_Print(d_valueRange));
+	printf("value=%s\n",cJSON_Print(value));
+	for(j=0;j<vra_size;j++){
+		if(strcmp(s_dataType->valuestring,"dummy")==0){
+			continue ;
+		}
+		rlt = cJSON_GetArrayItem(s_valueRange,j);
+	
+		if(strcmp(s_dataType->valuestring,"bool")==0 ||
+			strcmp(s_dataType->valuestring,"int")==0) {
+			if(rlt->valueint == value->valueint) {
+				args = cJSON_GetArrayItem(d_valueRange,j);
+				break ;
+			}
+		}else if(strcmp(s_dataType->valuestring,"double")==0){
+			if(rlt->valuedouble == value->valuedouble) {
+				args = cJSON_GetArrayItem(d_valueRange,j);
+				break ;
+			}
+		}else if(strstr(s_dataType->valuestring,"string")){
+			if(strcmp(rlt->valuestring,value->valuestring)==0){
+				args = cJSON_GetArrayItem(d_valueRange,j);
+				break ;
+			}
+		}else if(strstr(s_dataType->valuestring,"map")){
+			printf("rlt=%d\n",rlt->type);
+			if(rlt->type==cJSON_String){
+				printf("111111\n");
+				if(strcmp(rlt->valuestring,value->valuestring)==0){
+					printf("22222\n");
+					args = cJSON_GetArrayItem(d_valueRange,j);
+					break ;
+				}
+			}else if(rlt->type==cJSON_Number){
+				printf("44444\n");
+				if(rlt->valueint == value->valueint) {
+					printf("33333\n");
+					args = cJSON_GetArrayItem(d_valueRange,j);
+					break ;
+				}
+			}
+			
+		}
+	}
+	return args;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

application/klansdk/kk_ccu_msg.h

+#ifndef _KK_CCU_MSG_H
+#define _KK_CCU_MSG_H
+#include "kk_log.h"
+
+#include "klist.h"
+#include "kk_product.h"
+#include "com_api.h"
+#include "kk_opcode.h"
+#include "kk_lan_ctrl.h"
+#include "kk_data_mng.h"
+#include "cJSON.h"
+
+
+
+
+
+#define SWITCH_ARG_ON					"ON"
+#define SWITCH_ARG_OFF					"OFF"
+#define HJ_SERVER						"HJ_Server"
+
+
+#define SUCCESS_STATUS_STR				"success"
+#define NODEID_STR						"nodeid"
+#define OPCODE_STR						"opcode"
+#define ARG_STR							"arg"
+#define REQUEST_STR						"requester"
+
+
+#define INFO_STRING						"info"
+#define PAYLOAD_STRING					"payload"
+
+#define PARAMS_STRING					"params"
+
+
+
+
+
+cJSON * msg_convert_value(cJSON *d_type,cJSON *s_type,cJSON *value);
+cJSON *map_type_convert(cJSON *s_dataType,cJSON *s_valueRange,cJSON *value,cJSON *d_valueRange);
+
+
+
+
+#endif
+
+

application/klansdk/kk_data_mng.c

@@ -422,12 +422,15 @@ int kk_create_devicestatus_to_sdk(cJSON *root)
 	cJSON *device_status = cJSON_CreateArray();
 	cJSON *args;
 	cJSON *sub_device;
-	list_for_each_entry(node, &ctx->dev_list, linked_list, kk_map_dev_node_t){
+	
+	kk_map_dev_node_t *n = NULL;
+	
+	list_for_each_entry_safe(node,n, &ctx->dev_list, linked_list, kk_map_dev_node_t){
 
 		if(node->syn_type==1){
 			kk_creater_nodeid(node->deviceCode,1,nodeid);
-			
 			if((args = kk_devicestatus_build(node))!=NULL){
+				
 				sub_device=old_ccu_msg_build_json_node_int(atoi(nodeid),node->syn_opcode,NULL,args);
 				if(sub_device){
 					cJSON_AddItemToArray(device_status,sub_device);

application/klansdk/kk_lan_ctrl.c

+#include "kk_log.h"
+
+#include "klist.h"
+#include "kk_product.h"
+#include "com_api.h"
+#include "kk_opcode.h"
+#include "kk_lan_ctrl.h"
+#include "kk_data_mng.h"
+#include "cJSON.h"
+#include "kk_ccu_msg.h"
+#include "kk_oldccu_msg.h"
+#include "kk_newccu_msg.h"
+
+
+
+int find_match_pos(cJSON *array,const char *tag,const char *match)
+{
+	int i = 0;
+	int pos = -1;
+	cJSON *item;
+	cJSON *mh;
+
+	int size = cJSON_GetArraySize(array);
+	for(;i<size;i++){
+		item = cJSON_GetArrayItem(array,i);
+		mh = cJSON_GetObjectItem(item,tag);
+		if(strcmp(mh->valuestring,match)==0){
+			pos = i;
+			break;
+		}
+	}
+	return pos;
+}
+
+int match_opcode_pos(cJSON *array,const char *opcode,int ch)
+{
+	int i = 0;
+	int pos = -1;
+	cJSON *item;
+	cJSON *mh;
+	cJSON *channel;
+	
+	int size = cJSON_GetArraySize(array);
+	for(;i<size;i++){
+		item = cJSON_GetArrayItem(array,i);
+		mh = cJSON_GetObjectItem(item,"opcode");
+		channel = cJSON_GetObjectItem(item,"channel");
+		if((strcmp(mh->valuestring,opcode)==0) &&
+			(atoi(channel->valuestring)==ch)){
+			pos = i;
+			break;
+		}
+	}
+	return pos;
+}
+
+
+int match_value_string(cJSON *valueRange,const char *val)
+{
+	cJSON *item;
+	int i = 0;
+	int pos = -1;
+	int size = cJSON_GetArraySize(valueRange);
+	
+	for(;i<size;i++){
+		item = cJSON_GetArrayItem(valueRange,i);
+		
+		if(strcmp(item->valuestring,val)==0){
+			pos = i;
+			break;
+		}
+	}
+	return pos;
+}
+
+
+cJSON * ctrl_conver(kk_map_dev_node_t *devNode,int nodeId,cJSON *arg,cJSON *opcode)
+{
+	cJSON *params = cJSON_CreateObject();
+	cJSON *val;
+
+	cJSON *newccuItem;
+	cJSON *oldccuItem;
+
+	cJSON *o_dataType;
+	cJSON *n_dataType;
+
+	cJSON *n_valueRange;
+	cJSON *o_valueRange;
+
+	cJSON *n_identifier;
+
+	int pos;
+	int channel;
+	char ch[33];
+	
+	printf("[%s][%d]\n",__FUNCTION__,__LINE__);
+
+	kk_lan_db_channel_get(nodeId,&channel);
+	
+	snprintf(ch,33,"%d",channel);
+	printf("nodeId=%d,channel=%d,ch=%s\n",nodeId,channel,ch);
+	
+	pos = match_opcode_pos(devNode->oldccu,opcode->valuestring,channel);
+	printf("[opcode->valuestring]%s\n",opcode->valuestring);
+	printf("[match pos]%d\n",pos);
+	
+	if(pos==-1){
+		return NULL;
+	}
+	
+	newccuItem = cJSON_GetArrayItem(devNode->newccu,pos);
+	oldccuItem = cJSON_GetArrayItem(devNode->oldccu,pos);
+
+	o_dataType = cJSON_GetObjectItem(oldccuItem,"dataType");
+	o_valueRange = cJSON_GetObjectItem(oldccuItem,"valueRange");
+	
+	n_dataType = cJSON_GetObjectItem(newccuItem,"dataType");
+	n_valueRange = cJSON_GetObjectItem(newccuItem,"valueRange");
+	n_identifier =  cJSON_GetObjectItem(newccuItem,"identifier");
+
+
+
+	printf("1111\n");
+	if(strcmp(o_dataType->valuestring,"map")==0){
+		printf("2222\n");
+		val = map_type_convert(o_dataType,o_valueRange,arg,n_valueRange);
+	}else{
+		printf("3333\n");
+		val = msg_convert_value(o_dataType,n_dataType,arg);
+	}
+	printf("4444-->%d\n",val->type);
+		if(val->type==cJSON_False){
+			cJSON_AddFalseToObject(params,n_identifier->valuestring);
+		}else if(val->type==cJSON_True){
+			cJSON_AddTrueToObject(params,n_identifier->valuestring);
+		}else if(val->type==cJSON_NULL){
+			cJSON_AddNullToObject(params,n_identifier->valuestring);
+		}else if(val->type==cJSON_Number){
+			cJSON_AddNumberToObject(params,n_identifier->valuestring,val->valuedouble);
+		}else if(val->type==cJSON_String){
+			cJSON_AddStringToObject(params,n_identifier->valuestring,val->valuestring);
+		}else if(val->type==cJSON_Array){
+			printf("......................\n");
+		}
+	
+
+	return params;
+}
+
+typedef int(*match_func)(cJSON *);
+
+typedef struct
+{
+	char *Opcode;
+	match_func func;
+}MATCH_ITEM_S;
+
+int opcode_switch(cJSON *root);
+
+static MATCH_ITEM_S match_table[] = {
+	{SWITCH_OPCODE,opcode_switch}
+};
+
+MATCH_ITEM_S *get_match_table(void)
+{
+	return &match_table;
+}
+
+int kk_ccu_opcode_handle(cJSON *root)
+{
+	int i;
+	//int size = sizeof(match_table)/sizeof(MATCH_ITEM_S);
+	cJSON *opcode = cJSON_GetObjectItem(root,OPCODE_STR);
+	//MATCH_ITEM_S *pMh = get_match_table();
+	
+	printf("[%s][%d]\n",__FUNCTION__,__LINE__);
+
+	if(opcode==NULL||opcode->type!=cJSON_String){
+		return -1;
+	}
+	
+	/*for(i=0;i<size;i++,pMh++) {
+		if(strcmp(opcode->valuestring,pMh->Opcode)==0){
+			if(pMh->func){
+				printf("[%s][%d]match table[%d]\n",__FUNCTION__,__LINE__,i);
+				pMh->func(root);
+			}
+		}
+	}*/
+	opcode_switch(root);
+}
+
+//向midware发送数据
+int kk_ipc_send_json(cJSON *root)
+{
+	char *msg;
+
+	if(root==NULL){
+		return -1;
+	}
+	
+	msg=cJSON_Print(root);
+	printf("[lan->midware]json:\n%s\n",msg);
+	cJSON_Minify(msg);
+	kk_ipc_send(IPC_APP2MID, msg, strlen(msg)+1);
+	free(msg);
+	
+	return 0;
+}
+
+
+int opcode_switch(cJSON *root)
+{
+	cJSON *msg;
+
+	cJSON *nodeId;
+	cJSON *opcode;
+	cJSON *arg;
+	cJSON *requester;
+	char deviceCode[33]={0};
+
+	kk_map_dev_node_t *dev;
+	
+	printf("[%s][%d]\n",__FUNCTION__,__LINE__);
+	nodeId = cJSON_GetObjectItem(root,NODEID_STR);
+	opcode = cJSON_GetObjectItem(root,OPCODE_STR);
+	arg = cJSON_GetObjectItem(root,ARG_STR);
+	requester= cJSON_GetObjectItem(root,REQUEST_STR);
+
+	if(nodeId==NULL||opcode==NULL||arg==NULL ){
+		printf("[%s][%d]\n",__FUNCTION__,__LINE__);
+		return;
+	}
+	
+	if((requester!=NULL) &&(strcmp(requester->valuestring,HJ_SERVER)!=0)){
+		WARNING_PRINT("[%s] err,%s,%s\n",REQUEST_STR,HJ_SERVER,requester->valuestring);
+	}
+
+
+	kk_lan_db_deviceCode_get(atoi(nodeId->valuestring),deviceCode);
+
+	if(kk_map_dev_search_by_deviceCode(deviceCode, &dev)==0){
+		printf("[%s][%d]\n",__FUNCTION__,__LINE__);
+		cJSON *params=ctrl_conver(dev,atoi(nodeId->valuestring),arg,opcode);
+	
+		msg=property_set(dev->productCode,dev->deviceCode,"*","*",params);
+		kk_ipc_send_json(msg);
+	
+		
+	}else{
+		printf("[%s][%d]\n",__FUNCTION__,__LINE__);
+	}
+}
+
+
+
+
+
+
+
+
+
+char *node_string(int nodeId)
+{
+	char *node = (char *)malloc(33);
+	memset(node,0,33);
+	
+	snprintf(node,32,"%d",nodeId);
+	return node;
+}
+
+char *double_string(double dVal,int size)
+{
+	char *buff = (char *)malloc(size+1);
+	memset(buff,0,size+1);
+	
+	snprintf(buff,size,"%6f",dVal);
+	return buff;
+}
+
+
+
+
+
+int update_device_status_2_oldccu(int nodeId,const char *opcode,const char *arg)
+{
+	cJSON *msg;
+	char *nodeStr;
+
+	if(arg==NULL){
+		return -1;
+	}
+	printf("[%s][%d]nodeId=%d,status=%s\n",__FUNCTION__,__LINE__,nodeId,arg);
+
+	if((nodeStr=node_string(nodeId))!=NULL){
+		msg = old_ccu_msg_build(nodeStr,opcode,"success",arg);
+		send_msg_to_module(msg);
+		cJSON_Delete(msg);
+		free(nodeStr);
+		return 0;
+	}
+
+	return -1;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

application/klansdk/kk_lan_ctrl.h

+#ifndef _KK_LAN_CTRL_H
+#define _KK_LAN_CTRL_H
+#include "cJSON.h"
+
+
+
+
+
+
+
+
+
+
+int kk_ccu_opcode_handle(cJSON *root);
+
+void property_post_deal(const char *deviceCode,cJSON *payload);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#endif
+

application/klansdk/kk_lan_main.c

@@ -37,6 +37,7 @@ static void sig_handler(int sig)
 
 
 extern void ttttt_test();
+extern void kk_scene_build_test(void);
 
 int main(int argc, char* argv[])
 {
@@ -44,6 +45,7 @@ int main(int argc, char* argv[])
 	char *ppp;
 	open("kk_lan",LOG_PID,LOG_USER);
 	ttttt_test();
+	kk_scene_build_test();
 	/*set the callback to get the device date to cloud*/
 	kk_ipc_init(IPC_APP2MID,(ipc_cb*)KK_Data_FromMid,NULL,NULL);
 	kk_findccu_handle_init();
@@ -63,8 +65,7 @@ int main(int argc, char* argv[])
 
 
 	while(1){
-		extern void kk_scene_build_test(void);
-		kk_scene_build_test();
+		
 		//count++;
 		//if(count == 10){
 			//kk_ipc_send(IPC_APP2MID, "wooooooooooooooooooooooooooooooooooollllll!", strlen("wooooooooooooooooooooooooooooooooooollllll!")+1);

application/klansdk/kk_lan_new_dev_notify.c

+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "kk_data_mng.h"
+#include "kk_lan_node_db.h"
+
+#include "kk_log.h"
+
+#include "klist.h"
+#include "kk_product.h"
+#include "com_api.h"
+#include "kk_opcode.h"
+#include "kk_lan_ctrl.h"
+#include "kk_data_mng.h"
+
+#include "kk_oldccu_msg.h"
+#include "kk_ccu_msg.h"
+#include "kk_lan_new_dev_notify.h"
+
+
+static cJSON * _new_device_build(void* arg);
+static cJSON * _new_hue_light_build(void* arg);
+static cJSON * _new_ipc_build(void* arg);
+static cJSON * _new_konke_socket_build(void* arg);
+static cJSON * _new_konke_light_build(void* arg);
+static cJSON * _new_cnwise_music_controller_build(void* arg);
+static cJSON * _new_modbus_dev_build(void* arg);
+static cJSON * _new_modbus_daikin_indoorunit_build(void* arg);
+static cJSON * _new_konke_humidifier_build(void* arg);
+static cJSON * _new_konke_aircleaner_build(void* arg);
+static cJSON * _new_central_ac_gw_build(void* arg);
+static cJSON * _new_central_ac_gw_indoor_build(void* arg);
+static cJSON * _new_youzhuan_music_controllers_build(void* arg);
+
+
+typedef cJSON *(*build_func)(void** items);
+typedef struct {
+	
+#define NEW_DEVICES_BUILD_TYPE							0
+#define NEW_HUE_LIGHTS_BUILD_TYPE						1
+#define NEW_IPCS_BUILD_TYPE								2
+#define NEW_KONKE_SOCKETS_BUILD_TYPE					3
+#define NEW_KONKE_LIGHTS_BUILD_TYPE						4
+#define NEW_CNWISE_MUSIC_CONTROLLERS_BUILD_TYPE			5
+#define NEW_MODBUS_DEVS_BUILD_TYPE						6
+#define NEW_MODBUS_DAIKIN_INDOORUNIT_BUILD_TYPE			7
+#define NEW_KONKE_HUMIDIFIERS_BUILD_TYPE				8
+#define NEW_KONKE_AIRCLEANERS_BUILD_TYPE				9
+#define NEW_CENTRAL_AC_GWS_BUILD_TYPE					10
+#define NEW_CENTRAL_AC_GW_INDOORS_BUILD_TYPE			11
+#define NEW_YOUZHUAN_MUSIC_CONTROLLERS_BUILD_TYPE		12
+
+	int type;
+	build_func func;
+}BUILD_FUNC;
+
+
+
+
+
+static BUILD_FUNC new_dev_build_table[]={
+	{NEW_DEVICES_BUILD_TYPE,_new_device_build},
+	{NEW_HUE_LIGHTS_BUILD_TYPE,_new_hue_light_build},
+	{NEW_IPCS_BUILD_TYPE,_new_ipc_build},
+	{NEW_KONKE_SOCKETS_BUILD_TYPE,_new_konke_socket_build},
+	{NEW_KONKE_LIGHTS_BUILD_TYPE,_new_konke_light_build},
+	{NEW_CNWISE_MUSIC_CONTROLLERS_BUILD_TYPE,_new_cnwise_music_controller_build},
+	{NEW_MODBUS_DEVS_BUILD_TYPE,_new_modbus_dev_build},
+	{NEW_MODBUS_DAIKIN_INDOORUNIT_BUILD_TYPE,_new_modbus_daikin_indoorunit_build},
+	{NEW_KONKE_HUMIDIFIERS_BUILD_TYPE,_new_konke_humidifier_build},
+	{NEW_KONKE_AIRCLEANERS_BUILD_TYPE,_new_konke_aircleaner_build},
+	{NEW_CENTRAL_AC_GWS_BUILD_TYPE,_new_central_ac_gw_build},
+	{NEW_CENTRAL_AC_GW_INDOORS_BUILD_TYPE,_new_central_ac_gw_indoor_build},
+	{NEW_YOUZHUAN_MUSIC_CONTROLLERS_BUILD_TYPE,_new_youzhuan_music_controllers_build},
+};
+
+build_func* find_build_func(int type)
+{
+	int i,size;
+	BUILD_FUNC*func = NULL;
+	
+	size = sizeof(new_dev_build_table)/sizeof(BUILD_FUNC);
+	func = &new_dev_build_table;
+	
+	for(i=0;i<size;i++,func++){
+		if(func->type==type){
+			return func->func;
+		}
+	}
+	return NULL;
+}
+static cJSON * new_devices_build(int type,int num,void** items)
+{
+	cJSON *ary = cJSON_CreateArray();
+	cJSON *dev;
+	build_func func;
+	int i;
+	
+	if(items==NULL||*items==NULL){
+		return ary;
+	}
+
+	if((func = find_build_func(type))==NULL){
+		return ary;
+	}
+
+	
+	for(i=0;i<num;i++){
+		dev = func(items[i]);
+		cJSON_AddItemToArray(ary,dev);
+	}
+	return ary;
+}
+
+
+
+
+static cJSON * _new_device_build(void* arg)
+{
+	cJSON *dev = cJSON_CreateObject();
+	new_dev_item* item = arg;
+	cJSON_AddStringToObject(dev,"channel",item->channel);
+	cJSON_AddStringToObject(dev,"mac",item->mac);
+	cJSON_AddStringToObject(dev,"nodeid",item->nodeid);
+	cJSON_AddStringToObject(dev,"operate_type",item->operate_type);
+	cJSON_AddStringToObject(dev,"gw_mac",item->gw_mac);
+	cJSON_AddStringToObject(dev,"status",item->status);
+	return dev;
+}
+static cJSON * _new_hue_light_build(void* arg)
+{
+	cJSON *dev = cJSON_CreateObject();
+	HUE_LIGHT_ITEM* item = arg;
+	cJSON_AddStringToObject(dev,"hue_light_id",item->hue_light_id);
+	cJSON_AddStringToObject(dev,"hue_gw_id",item->hue_gw_id);
+	cJSON_AddStringToObject(dev,"hue_light_status",item->hue_light_status);
+
+	return dev;
+}
+static cJSON * _new_ipc_build(void* arg)
+{
+	cJSON *dev = cJSON_CreateObject();
+	const char* item = arg;
+	cJSON_AddStringToObject(dev,"ipcid",item);
+
+	return dev;
+}
+
+static cJSON * _new_konke_socket_build(void* arg)
+{
+	cJSON *dev = cJSON_CreateObject();
+	KK_SOCKET_ITEM* item = arg;
+	cJSON_AddStringToObject(dev,"konke_socket_id",item->konke_socket_id);
+	cJSON_AddStringToObject(dev,"konke_socket_mac",item->konke_socket_mac);
+	cJSON_AddStringToObject(dev,"konke_socket_online",item->konke_socket_online);
+	cJSON_AddStringToObject(dev,"konke_socket_status",item->konke_socket_status);
+
+	return dev;
+}
+
+static cJSON * _new_konke_light_build(void* arg)
+{
+	cJSON *dev = cJSON_CreateObject();
+	KK_LIGHT_ITEM* item = arg;
+	cJSON_AddStringToObject(dev,"konke_light_id",item->konke_light_id);
+	cJSON_AddStringToObject(dev,"konke_light_mac",item->konke_light_mac);
+	cJSON_AddStringToObject(dev,"konke_light_online",item->konke_light_online);
+	cJSON_AddStringToObject(dev,"konke_light_status",item->konke_light_status);
+
+	return dev;
+}
+static cJSON * _new_cnwise_music_controller_build(void* arg)
+{
+	cJSON *dev = cJSON_CreateObject();
+	MC_CTRL_ITEM* item = arg;
+	cJSON_AddStringToObject(dev,"id",item->id);
+	cJSON_AddStringToObject(dev,"music_controller_mac",item->music_controller_mac);
+	cJSON_AddStringToObject(dev,"music_controller_type",item->music_controller_type);
+	cJSON_AddStringToObject(dev,"music_controller_online",item->music_controller_online);
+	cJSON_AddStringToObject(dev,"music_controller_status",item->music_controller_status);
+
+	return dev;
+}
+
+static cJSON * _new_modbus_dev_build(void* arg)
+{
+	cJSON *dev = cJSON_CreateObject();
+	MODBUS_DEV_ITEM* item=arg;
+	cJSON_AddStringToObject(dev,"id",item->id);
+	cJSON_AddStringToObject(dev,"dev_type",item->dev_type);
+	cJSON_AddStringToObject(dev,"daikin_gw",item->daikin_gw);
+	cJSON_AddStringToObject(dev,"dev_addr",item->dev_addr);
+	cJSON_AddStringToObject(dev,"bind_modbus_gw_node_id",item->bind_modbus_gw_node_id);
+
+	return dev;
+}
+
+static cJSON * _new_modbus_daikin_indoorunit_build(void* arg)
+{
+	cJSON *dev = cJSON_CreateObject();
+	MODBUS_DAIKIN_INDOORUNIT_ITEM* item = arg;
+	cJSON_AddStringToObject(dev,"id",item->id);
+	cJSON_AddStringToObject(dev,"indooruint_addr",item->indooruint_addr);
+	cJSON_AddStringToObject(dev,"bind_daikin_gw_devid",item->bind_daikin_gw_devid);
+
+	return dev;
+}
+
+static cJSON * _new_konke_humidifier_build(void* arg)
+{
+	cJSON *dev = cJSON_CreateObject();
+	KK_HUMIDIFIER_ITEM* item=arg;
+	cJSON_AddStringToObject(dev,"konke_humidifier_id",item->konke_humidifier_id);
+	cJSON_AddStringToObject(dev,"konke_humidifier_mac",item->konke_humidifier_mac);
+	cJSON_AddStringToObject(dev,"konke_humidifier_online",item->konke_humidifier_online);
+	cJSON_AddStringToObject(dev,"konke_humidifier_status",item->konke_humidifier_status);
+
+	return dev;
+}
+
+
+static cJSON * _new_konke_aircleaner_build(void* arg)
+{
+	cJSON *dev = cJSON_CreateObject();
+	KK_AIRCLEANER_ITEM* item =arg;
+	cJSON_AddStringToObject(dev,"konke_aircleaner_id",item->konke_aircleaner_id);
+	cJSON_AddStringToObject(dev,"konke_aircleaner_mac",item->konke_aircleaner_mac);
+	cJSON_AddStringToObject(dev,"konke_aircleaner_online",item->konke_aircleaner_online);
+	cJSON_AddStringToObject(dev,"konke_aircleaner_status",item->konke_aircleaner_status);
+
+	return dev;
+}
+
+static cJSON * _new_central_ac_gw_build(void* arg)
+{
+	cJSON *dev = cJSON_CreateObject();
+	CENTRAL_AC_ITEM* item =arg;
+	cJSON_AddStringToObject(dev,"id",item->id);
+	cJSON_AddStringToObject(dev,"bind_central_ac_gw_node_id",item->bind_central_ac_gw_node_id);
+	cJSON_AddStringToObject(dev,"ac_gw_status",item->ac_gw_status);
+
+	return dev;
+}
+
+
+
+
+
+
+static cJSON * _new_central_ac_gw_indoor_build(void* arg)
+{
+	cJSON *dev = cJSON_CreateObject();
+	CENTRAL_AC_INDOOR_ITEM* item=arg;
+	cJSON_AddStringToObject(dev,"id",item->id);
+	cJSON_AddStringToObject(dev,"bind_central_ac_gw_node_id",item->bind_central_ac_gw_node_id);
+	cJSON_AddStringToObject(dev,"ac_gw_status",item->ac_gw_status);
+
+	return dev;
+}
+
+
+
+
+
+
+static cJSON * _new_youzhuan_music_controllers_build(void* arg)
+{
+	cJSON *dev = cJSON_CreateObject();
+	YOUZHUAN_MC_CTRL_ITEM* item =arg;
+	cJSON_AddStringToObject(dev,"id",item->id);
+	cJSON_AddStringToObject(dev,"music_controller_mac",item->music_controller_mac);
+	cJSON_AddStringToObject(dev,"music_controller_type",item->music_controller_type);
+	cJSON_AddStringToObject(dev,"music_controller_online",item->music_controller_online);
+	cJSON_AddStringToObject(dev,"music_controller_status",item->music_controller_status);
+
+	return dev;
+}
+
+
+
+
+
+
+cJSON *new_device_notify_msg_build(NEW_DEVICE_NOTIFY *info)
+{
+	cJSON *arg;
+	cJSON *msg;
+
+	if(info==NULL){
+		return ;
+	}
+	
+	arg = cJSON_CreateObject();
+	cJSON_AddItemToObject(arg,"new_device_count",info->new_device_count);
+	cJSON_AddItemToObject(arg,"new_devices",info->new_devices);
+	cJSON_AddItemToObject(arg,"new_hue_lights_count",info->new_hue_lights_count);
+	cJSON_AddItemToObject(arg,"new_hue_lights",info->new_hue_lights);
+	cJSON_AddItemToObject(arg,"new_ipc_count",info->new_ipc_count);
+	cJSON_AddItemToObject(arg,"new_ipcs",info->new_ipcs);
+	cJSON_AddItemToObject(arg,"new_konke_count",info->new_konke_count);
+	cJSON_AddItemToObject(arg,"new_konke_sockets",info->new_konke_sockets);
+	cJSON_AddItemToObject(arg,"new_konke_lights_count",info->new_konke_lights_count);
+	cJSON_AddItemToObject(arg,"new_konke_lights",info->new_konke_lights);
+	cJSON_AddItemToObject(arg,"new_cnwise_music_controllers_count",info->new_cnwise_music_controllers_count);
+	cJSON_AddItemToObject(arg,"new_cnwise_music_controllers",info->new_cnwise_music_controllers);
+	cJSON_AddItemToObject(arg,"new_modbus_devs_count",info->new_modbus_devs_count);
+	cJSON_AddItemToObject(arg,"new_modbus_devs",info->new_modbus_devs);
+	cJSON_AddItemToObject(arg,"new_modbus_daikin_indoorunits_count",info->new_modbus_daikin_indoorunits_count);
+	cJSON_AddItemToObject(arg,"new_modbus_daikin_indoorunits",info->new_modbus_daikin_indoorunits);
+	cJSON_AddItemToObject(arg,"new_konke_humidifiers_count",info->new_konke_humidifiers_count);
+	cJSON_AddItemToObject(arg,"new_konke_humidifiers",info->new_konke_humidifiers);
+	cJSON_AddItemToObject(arg,"new_konke_aircleaners_count",info->new_konke_aircleaners_count);
+	cJSON_AddItemToObject(arg,"new_konke_aircleaners",info->new_konke_aircleaners);
+	cJSON_AddItemToObject(arg,"new_central_ac_gws_count",info->new_central_ac_gws_count);
+	cJSON_AddItemToObject(arg,"new_central_ac_gws",info->new_central_ac_gws);
+
+	cJSON_AddItemToObject(arg,"new_central_ac_indoorunits_count",info->new_central_ac_indoorunits_count);
+	cJSON_AddItemToObject(arg,"new_central_ac_indoorunits",info->new_central_ac_indoorunits);
+
+
+	cJSON_AddItemToObject(arg,"new_youzhuan_music_controllers_count",info->new_youzhuan_music_controllers_count);
+	cJSON_AddItemToObject(arg,"new_youzhuan_music_controllers",info->new_youzhuan_music_controllers);
+
+	msg = old_ccu_msg_build_json("*","NEW_DEVICES",NULL,arg);
+
+	return msg;
+}
+
+
+void ttttt_test()
+{
+	NEW_DEVICE_NOTIFY info;
+	cJSON *msg;
+
+	info.new_device_count = cJSON_CreateString("0");
+	info.new_devices = new_devices_build(NEW_DEVICES_BUILD_TYPE,0,NULL);
+
+
+	info.new_hue_lights_count = cJSON_CreateString("0");
+	info.new_hue_lights = new_devices_build(NEW_HUE_LIGHTS_BUILD_TYPE,0,NULL);
+	
+	info.new_ipc_count = cJSON_CreateString("0");
+	info.new_ipcs =new_devices_build(NEW_IPCS_BUILD_TYPE,0,NULL);
+
+	info.new_konke_count = cJSON_CreateString("0");
+	info.new_konke_sockets = new_devices_build(NEW_KONKE_SOCKETS_BUILD_TYPE,0,NULL);
+
+	info.new_konke_lights_count = cJSON_CreateString("0");
+	info.new_konke_lights = new_devices_build(NEW_KONKE_LIGHTS_BUILD_TYPE,0,NULL);
+
+	info.new_cnwise_music_controllers_count = cJSON_CreateString("0");
+	info.new_cnwise_music_controllers =  new_devices_build(NEW_CNWISE_MUSIC_CONTROLLERS_BUILD_TYPE,0,NULL);
+
+	info.new_modbus_devs_count = cJSON_CreateString("0");
+	info.new_modbus_devs = new_devices_build(NEW_MODBUS_DEVS_BUILD_TYPE,0,NULL);
+
+	info.new_modbus_daikin_indoorunits_count = cJSON_CreateString("0");
+	info.new_modbus_daikin_indoorunits = new_devices_build(NEW_MODBUS_DAIKIN_INDOORUNIT_BUILD_TYPE,0,NULL);
+
+	info.new_konke_humidifiers_count = cJSON_CreateString("0");
+	info.new_konke_humidifiers =new_devices_build(NEW_KONKE_HUMIDIFIERS_BUILD_TYPE,0,NULL);
+
+	info.new_konke_aircleaners_count = cJSON_CreateString("0");
+	info.new_konke_aircleaners = new_devices_build(NEW_KONKE_AIRCLEANERS_BUILD_TYPE,0,NULL);
+
+	info.new_central_ac_gws_count = cJSON_CreateString("0");
+	info.new_central_ac_gws = new_devices_build(NEW_CENTRAL_AC_GWS_BUILD_TYPE,0,NULL);
+
+	info.new_central_ac_indoorunits_count = cJSON_CreateString("0");
+	info.new_central_ac_indoorunits = new_devices_build(NEW_CENTRAL_AC_GW_INDOORS_BUILD_TYPE,0,NULL);
+
+	info.new_youzhuan_music_controllers_count = cJSON_CreateString("0");
+	info.new_youzhuan_music_controllers =  new_devices_build(NEW_YOUZHUAN_MUSIC_CONTROLLERS_BUILD_TYPE,0,NULL);
+
+	
+
+	
+	msg = new_device_notify_msg_build(&info);
+
+	printf("\n\n----------------------------------->%s\n\n",cJSON_Print(msg));
+}
+
+
+
+
+
+
+
+
+
+
+
+

application/klansdk/kk_lan_new_dev_notify.h

+#ifndef __KK_LAN_NEW_DEV_NOTIFY_H
+#define __KK_LAN_NEW_DEV_NOTIFY_H
+#include "kk_ccu_msg.h"
+
+typedef struct {
+	cJSON *new_device_count;
+	cJSON *new_devices;
+
+	cJSON *new_hue_lights_count;
+	cJSON *new_hue_lights;
+	
+	cJSON *new_ipc_count;
+	cJSON *new_ipcs;
+
+	cJSON *new_konke_count;
+	cJSON *new_konke_sockets;
+
+	cJSON *new_konke_lights_count;
+	cJSON *new_konke_lights;
+
+	cJSON *new_cnwise_music_controllers_count;
+	cJSON *new_cnwise_music_controllers;
+
+	cJSON *new_modbus_devs_count;
+	cJSON *new_modbus_devs;
+
+	cJSON *new_modbus_daikin_indoorunits_count;
+	cJSON *new_modbus_daikin_indoorunits;
+
+	cJSON *new_konke_humidifiers_count;
+	cJSON *new_konke_humidifiers;
+
+	cJSON *new_konke_aircleaners_count;
+	cJSON *new_konke_aircleaners;
+
+	cJSON *new_central_ac_gws_count;
+	cJSON *new_central_ac_gws;
+
+	cJSON *new_central_ac_indoorunits_count;
+	cJSON *new_central_ac_indoorunits;
+
+	cJSON *new_youzhuan_music_controllers_count;
+	cJSON *new_youzhuan_music_controllers;
+	
+}NEW_DEVICE_NOTIFY;
+
+
+typedef struct{
+	char *channel;
+	char *mac;
+	char *nodeid;
+	char *operate_type;
+	char *gw_mac;
+	char *status;
+}new_dev_item;
+
+typedef struct{
+	char *hue_light_id;
+	char *hue_gw_id;
+	char *hue_light_status;
+}HUE_LIGHT_ITEM;
+
+typedef struct{
+	char *konke_socket_id;
+	char *konke_socket_mac;
+	char *konke_socket_online;
+	char *konke_socket_status;
+}KK_SOCKET_ITEM;
+
+
+typedef struct{
+	char *konke_light_id;
+	char *konke_light_mac;
+	char *konke_light_online;
+	char *konke_light_status;
+}KK_LIGHT_ITEM;
+
+
+
+typedef struct{
+	char *id;
+	char *music_controller_mac;
+	char *music_controller_type;
+	char *music_controller_online;
+	char *music_controller_status;
+}MC_CTRL_ITEM;
+
+typedef struct{
+	char *id;
+	char *dev_type;
+	char *daikin_gw;
+	char *dev_addr;
+	char *bind_modbus_gw_node_id;
+}MODBUS_DEV_ITEM;
+
+
+
+typedef struct{
+	char *id;
+	char *indooruint_addr;
+	char *bind_daikin_gw_devid;
+}MODBUS_DAIKIN_INDOORUNIT_ITEM;
+
+
+
+
+
+typedef struct{
+	char *konke_humidifier_id;
+	char *konke_humidifier_mac;
+	char *konke_humidifier_online;
+	char *konke_humidifier_status;
+}KK_HUMIDIFIER_ITEM;
+
+typedef struct{
+	char *konke_aircleaner_id;
+	char *konke_aircleaner_mac;
+	char *konke_aircleaner_online;
+	char *konke_aircleaner_status;
+}KK_AIRCLEANER_ITEM;
+
+
+typedef struct{
+	char *id;
+	char *bind_central_ac_gw_node_id;
+	char *ac_gw_status;
+}CENTRAL_AC_ITEM;
+
+
+typedef struct{
+	char *id;
+	char *bind_central_ac_gw_node_id;
+	char *ac_gw_status;
+}CENTRAL_AC_INDOOR_ITEM;
+
+
+typedef struct{
+	char *id;
+	char *music_controller_mac;
+	char *music_controller_type;
+	char *music_controller_online;
+	char *music_controller_status;
+}YOUZHUAN_MC_CTRL_ITEM;
+
+#endif
+
+
+
+

application/klansdk/kk_lan_node_db.c

+#include <stdio.h>
+#include "kk_tsl_api.h"
+
+#include "kk_log.h"
+#include "kk_dm_mng.h"
+#include "kk_lan_node_db.h"
+
+
+
+
+
+static sqlite3 *g_lan_pDb;
+static kk_lan_node_db_ctx_t s_kk_lan_node_db_ctx = {0};
+static kk_lan_node_db_ctx_t *_kk_lan_node_db_get_ctx(void)
+{
+	return &s_kk_lan_node_db_ctx;
+}
+static void _kk_lan_node_db_lock(void)
+{
+	kk_lan_node_db_ctx_t *ctx = _kk_lan_node_db_get_ctx();
+	if (ctx->mutex) {
+		HAL_MutexLock(ctx->mutex);
+	}
+}
+
+static void _kk_lan_node_db_unlock(void)
+{
+	kk_lan_node_db_ctx_t *ctx = _kk_lan_node_db_get_ctx();
+	if (ctx->mutex) {
+		HAL_MutexUnlock(ctx->mutex);
+	}
+}
+
+/************************************************************
+*功能描述： 属性数据表初始化
+*输入参数： 无
+*输出参数： 无
+*返 回 值：  0：成功；其他：失败
+*其他说明：
+*************************************************************/
+static int _kk_lan_node_db_Init(void)
+{
+	kk_lan_node_db_ctx_t *ctx = _kk_lan_node_db_get_ctx();
+
+	const char *pNodeTable = "CREATE TABLE IF NOT EXISTS Map2Node( \
+		idx INTEGER PRIMARY KEY, \
+		deviceCode varchar(33), \
+		channel INTEGER, \
+		nodeId INTEGER)"; 
+
+	char *pcErr;
+
+	_kk_lan_node_db_lock();
+	
+	if (sqlite3_open_v2(KK_LAN_NODE_DB_FILE, &g_lan_pDb, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | SQLITE_OPEN_FULLMUTEX, NULL) != SQLITE_OK)
+	{
+		ERROR_PRINT("Error initialising linkage database fail!!!\n");
+		return -1; 
+	}
+	
+	ctx->pDb = g_lan_pDb;
+	
+	if (sqlite3_exec(ctx->pDb, pNodeTable, NULL, NULL, &pcErr) != SQLITE_OK)
+	{
+		ERROR_PRINT("Error creating table (%s)\n", pcErr);
+		sqlite3_free(pcErr);
+		_kk_lan_node_db_unlock();
+		return -1;
+	}
+	
+	_kk_lan_node_db_unlock();
+	return 0;
+}
+
+/************************************************************
+*功能描述： 属性模块初始化
+*输入参数： 无
+*输出参数： 无
+*返 回 值：  0：成功；其他：失败
+*其他说明：
+*************************************************************/
+int kk_lan_db_node_init(void)
+{
+	int res = 0;
+	kk_lan_node_db_ctx_t *ctx = _kk_lan_node_db_get_ctx();
+	
+	ctx->mutex = HAL_MutexCreate();
+	if (ctx->mutex == NULL) {
+		return -1;
+	}
+
+	res = _kk_lan_node_db_Init();
+	if(res != 0){
+		ERROR_PRINT("[%s][%d]kk_lan_node_db_init FAIL!!!\n",__FUNCTION__,__LINE__);
+		return res;
+	}
+
+	return 0;
+}
+
+
+
+int kk_check_lan_node(int nodeId)
+{
+	int isExist = 0;
+	sqlite3_stmt *stmt;
+	char *pDeviceCode = NULL;
+	int node = 0;
+	kk_lan_node_db_ctx_t *ctx = _kk_lan_node_db_get_ctx();
+	const char *searchCmd = "select * from Map2Node;";	
+	_kk_lan_node_db_lock();
+	sqlite3_prepare_v2(ctx->pDb, searchCmd, strlen(searchCmd), &stmt, NULL);
+
+	while(sqlite3_step(stmt) == SQLITE_ROW){
+		node = sqlite3_column_int(stmt, LAN_DB_NODE);
+		printf("$$$$$$$$$$$$$$$$$$check node=%d,nodeId=%d\n",node,nodeId);
+		if( node==nodeId)
+		{
+			isExist = 1;
+			break;
+		}
+	}
+
+	sqlite3_finalize(stmt);
+	_kk_lan_node_db_unlock();
+	return isExist;
+}
+
+
+/************************************************************
+*功能描述： check属性是否重复
+*输入参数： deviceCode：设备deviceCode
+          identifier：属性名称
+*输出参数： 无
+*返 回 值：  1：已经存在；0：不存在
+*其他说明：
+*************************************************************/
+int kk_check_lan_node_exist(const char* deviceCode,int channel)
+{
+	int isExist = 0;
+	sqlite3_stmt *stmt;
+	char *pDeviceCode = NULL;
+	int ch = 0;
+	int node = 0;
+	kk_lan_node_db_ctx_t *ctx = _kk_lan_node_db_get_ctx();
+	const char *searchCmd = "select * from Map2Node;";	
+	_kk_lan_node_db_lock();
+	sqlite3_prepare_v2(ctx->pDb, searchCmd, strlen(searchCmd), &stmt, NULL);
+
+	while(sqlite3_step(stmt) == SQLITE_ROW){
+		pDeviceCode = sqlite3_column_text(stmt, LAN_DB_DEVICECODE);
+		ch = sqlite3_column_int(stmt, LAN_DB_CHANNEL);
+		if(!strcmp(deviceCode,pDeviceCode) && ch==channel)
+		{
+			isExist = 1;
+			break;
+		}
+	}
+
+	sqlite3_finalize(stmt);
+	_kk_lan_node_db_unlock();
+	return isExist;
+}
+static int _kk_check_lan_node_same(const char* deviceCode,int channel,int nodeId)
+{
+	int same = 0;
+	sqlite3_stmt *stmt;
+	char *pDeviceCode = NULL;
+	int ch = 0;
+	int node = 0;
+	kk_lan_node_db_ctx_t *ctx = _kk_lan_node_db_get_ctx();
+	const char *searchCmd = "select * from Map2Node;";	
+	_kk_lan_node_db_lock();
+	sqlite3_prepare_v2(ctx->pDb, searchCmd, strlen(searchCmd), &stmt, NULL);
+
+	while(sqlite3_step(stmt) == SQLITE_ROW){
+		pDeviceCode = sqlite3_column_text(stmt, LAN_DB_DEVICECODE);
+		ch = sqlite3_column_int(stmt, LAN_DB_CHANNEL);
+		node = sqlite3_column_int(stmt, LAN_DB_NODE);
+		if(!strcmp(deviceCode,pDeviceCode) && ch==channel &&node==nodeId)
+		{
+			same = 1;
+			break;
+		}
+	}
+
+	sqlite3_finalize(stmt);
+	_kk_lan_node_db_unlock();
+	return same;
+}
+
+
+/************************************************************
+*功能描述： 更新属性值
+*输入参数： deviceCode：设备deviceCode
+          identifier：属性名称
+          value：属性值
+*输出参数： 无
+*返 回 值：  0：成功；其他：失败
+*其他说明：
+*************************************************************/
+static int kk_lan_db_node_update(const char *deviceCode,int channel,int node)
+{
+	char *sqlCmd = NULL;
+	int rc = 0;
+	char *zErrMsg = 0;
+	kk_lan_node_db_ctx_t *ctx = _kk_lan_node_db_get_ctx();
+
+	_kk_lan_node_db_lock();
+
+	sqlCmd = sqlite3_mprintf("UPDATE Map2Node SET nodeId='%d'  WHERE deviceCode= '%s' and channel = '%d'",node,deviceCode,channel);	
+
+
+	rc = sqlite3_exec(ctx->pDb, sqlCmd, NULL, NULL, &zErrMsg);
+	if( rc != SQLITE_OK ){
+		ERROR_PRINT("SQL error: %s\n", zErrMsg);
+		sqlite3_free(zErrMsg);
+	}else{
+		DEBUG_PRINT("kk_lan_node_db_update_value successfully\n");
+	}
+	sqlite3_free(sqlCmd);
+	_kk_lan_node_db_unlock();
+	return SUCCESS_RETURN;
+}
+
+/************************************************************
+*功能描述： 插入属性到数据库
+*输入参数： deviceCode：设备deviceCode
+          identifier：属性名称
+          valuetype：属性值类型
+          devtype：设备类型
+*输出参数： 无
+*返 回 值：  0：成功；其他：失败
+*其他说明：属性的值插入的时候先置空，后续再update
+*************************************************************/
+int kk_lan_db_node_insert(const char *deviceCode,int channel,int node)
+{
+	const char *insertCmd = "insert into Map2Node (deviceCode,channel,nodeId) \
+								values ('%s','%d','%d');";
+	char *sqlCmd = NULL;
+	int rc = 0;
+	char *zErrMsg = 0;
+	kk_lan_node_db_ctx_t *ctx = _kk_lan_node_db_get_ctx();
+
+	if(kk_check_lan_node_exist(deviceCode,channel)){
+		if(_kk_check_lan_node_same(deviceCode,channel,node)){
+			kk_lan_db_node_update(deviceCode,channel,node);
+		}
+		return 0;
+	}
+	
+	_kk_lan_node_db_lock();
+	sqlCmd = sqlite3_mprintf(insertCmd,deviceCode,channel,node);	
+
+	rc = sqlite3_exec(ctx->pDb, sqlCmd, NULL, NULL, &zErrMsg);
+	if( rc != SQLITE_OK ){
+		ERROR_PRINT("SQL error: %s\n", zErrMsg);
+		sqlite3_free(zErrMsg);
+	}else{
+
+	}
+	sqlite3_free(sqlCmd);
+	_kk_lan_node_db_unlock();
+	return SUCCESS_RETURN;
+}
+
+
+
+/*
+int kk_lan_db_node_get_max(const char *deviceCode,int channel)
+{
+	char *sqlCmd = NULL;
+	int rc = 0;
+	char *zErrMsg = 0;
+	sqlite3_stmt *stmt;
+	int node = -1;
+	kk_lan_node_db_ctx_t *ctx = _kk_lan_node_db_get_ctx();
+
+	_kk_lan_node_db_lock();
+	sqlCmd = sqlite3_mprintf("select Max(cast(nodeId as int)) from Map2Node",);	
+	sqlite3_prepare_v2(ctx->pDb, sqlCmd, strlen(sqlCmd), &stmt, NULL);
+	while(sqlite3_step(stmt) == SQLITE_ROW){
+		node = sqlite3_column_value(stmt, LAN_DB_NODE);
+	}
+	sqlite3_free(sqlCmd);
+	_kk_lan_node_db_unlock();
+	sqlite3_finalize(stmt);
+
+	return node;
+}
+*/
+
+/************************************************************
+*功能描述： 获取属性值
+*输入参数： deviceCode：设备deviceCode
+          identifier：属性名称
+*输出参数： value：属性值,返回的是字串
+*返 回 值：  0：成功；其他：失败
+*其他说明：
+*************************************************************/
+int kk_lan_db_node_get_all(const char *deviceCode,int *nodes)
+{
+	char *sqlCmd = NULL;
+	int rc = 0;
+	char *zErrMsg = 0;
+	sqlite3_stmt *stmt;
+	int num = 0;
+	kk_lan_node_db_ctx_t *ctx = _kk_lan_node_db_get_ctx();
+
+	_kk_lan_node_db_lock();
+	sqlCmd = sqlite3_mprintf("select * from Map2Node WHERE deviceCode= '%s'",deviceCode);
+
+	sqlite3_prepare_v2(ctx->pDb, sqlCmd, strlen(sqlCmd), &stmt, NULL);
+	while(sqlite3_step(stmt) == SQLITE_ROW){
+		nodes[num++] = sqlite3_column_int(stmt, LAN_DB_NODE);
+	}
+	sqlite3_free(sqlCmd);
+	_kk_lan_node_db_unlock();
+	sqlite3_finalize(stmt);
+
+	return num;
+}
+
+
+int kk_lan_db_node_get(const char *deviceCode,int channel)
+{
+	char *sqlCmd = NULL;
+	int rc = 0;
+	char *zErrMsg = 0;
+	sqlite3_stmt *stmt;
+	int node = -1;
+	kk_lan_node_db_ctx_t *ctx = _kk_lan_node_db_get_ctx();
+
+	_kk_lan_node_db_lock();
+	sqlCmd = sqlite3_mprintf("select * from Map2Node WHERE deviceCode= '%s' and channel = '%d'",deviceCode,channel);	
+
+	sqlite3_prepare_v2(ctx->pDb, sqlCmd, strlen(sqlCmd), &stmt, NULL);
+	while(sqlite3_step(stmt) == SQLITE_ROW){
+		node = sqlite3_column_int(stmt, LAN_DB_NODE);
+	}
+	sqlite3_free(sqlCmd);
+	_kk_lan_node_db_unlock();
+	sqlite3_finalize(stmt);
+
+	return node;
+}
+
+
+
+int kk_lan_db_get_item_by_node(int node,char *deviceCode,int *channel)
+{
+	char *sqlCmd = NULL;
+	int rc = 0;
+	char *zErrMsg = 0;
+	sqlite3_stmt *stmt;
+	kk_lan_node_db_ctx_t *ctx = _kk_lan_node_db_get_ctx();
+	char *dCode = 0;
+	
+	_kk_lan_node_db_lock();
+	sqlCmd = sqlite3_mprintf("select * from Map2Node WHERE nodeId= '%d' ",node);	
+	sqlite3_prepare_v2(ctx->pDb, sqlCmd, strlen(sqlCmd), &stmt, NULL);
+	while(sqlite3_step(stmt) == SQLITE_ROW){
+		if(deviceCode!=NULL){
+			dCode = sqlite3_column_text(stmt, LAN_DB_DEVICECODE);
+			memcpy(deviceCode,dCode,strlen(dCode));
+			
+		}
+		if(channel!=NULL){
+			*channel = sqlite3_column_int(stmt, LAN_DB_CHANNEL);
+		}
+	}
+	sqlite3_free(sqlCmd);
+	_kk_lan_node_db_unlock();
+	sqlite3_finalize(stmt);
+
+	return 0;
+
+}
+int kk_lan_db_channel_get(int node,int *channel)
+{
+	kk_lan_db_get_item_by_node(node,NULL,channel);
+}
+
+int kk_lan_db_deviceCode_get(int node,char *deviceCode)
+{
+	kk_lan_db_get_item_by_node(node,deviceCode,NULL);
+}
+
+
+
+/************************************************************
+*功能描述：通过deviceCode删除设备属性
+*输入参数： deviceCode：设备deviceCode
+*输出参数： 无
+*返 回 值：  0：成功；其他：失败
+*其他说明：
+*************************************************************/
+int kk_lan_db_node_delete(char *deviceCode)
+{
+	const char *deleteCmd = "delete from Map2Node where deviceCode = '%s';";
+	char *sqlCmd = NULL;
+	int rc = 0;
+	char *zErrMsg = 0;
+	kk_lan_node_db_ctx_t *ctx = _kk_lan_node_db_get_ctx();
+
+	_kk_lan_node_db_lock();
+	sqlCmd = sqlite3_mprintf(deleteCmd,deviceCode);	
+
+	INFO_PRINT("Table delete data sqlCmd:%s\n",sqlCmd);
+	rc = sqlite3_exec(ctx->pDb, sqlCmd, NULL, NULL, &zErrMsg);
+	if( rc != SQLITE_OK ){
+		ERROR_PRINT("SQL error: %s\n", zErrMsg);
+		sqlite3_free(zErrMsg);
+	}else{
+		INFO_PRINT("Table delete data successfully\n");
+	}
+	sqlite3_free(sqlCmd);
+	_kk_lan_node_db_unlock();
+	return SUCCESS_RETURN;
+}
+
+
+
+
+
+
+

application/klansdk/kk_lan_node_db.h

+#ifndef __KK_LAN_NODE_DB_H_
+#define __KK_LAN_NODE_DB_H_
+
+#include "sqlite3.h"
+
+#define KK_LAN_NODE_DB_FILE					"./kk_lan_node.db"
+
+typedef struct {
+	void *mutex;
+	sqlite3 *pDb;	
+} kk_lan_node_db_ctx_t;
+
+enum{
+	LAN_DB_IDX = 0,
+	LAN_DB_DEVICECODE,
+	LAN_DB_CHANNEL,
+	LAN_DB_NODE,
+};
+
+int kk_lan_db_node_init(void);
+int kk_lan_db_node_insert(const char *deviceCode,int channel,int node);
+int kk_lan_db_node_get(const char *deviceCode,int channel);
+int kk_lan_db_node_get_all(const char *deviceCode,int *nodes);
+
+int kk_lan_db_deviceCode_get(int node,char *deviceCode);
+int kk_lan_db_channel_get(int node,int *channel);
+int kk_lan_db_get_item_by_node(int node,char *deviceCode,int *channel);
+
+int kk_lan_db_node_delete(char *deviceCode);
+int kk_check_lan_node_exist(const char* deviceCode,int channel);
+int kk_check_lan_node(int nodeId);
+
+
+
+#endif
+

application/klansdk/kk_lan_queue.c

+#include <pthread.h>
+#include "kk_lan_queue.h"
+#include "kk_log.h"
+
+static lan_queue_s g_lan_queue[LAN_QUEUE_END];
+
+static lan_queue_s *_lan_queue_get_ctx(LAN_QUEUE_ENUM ix)
+{
+	return &g_lan_queue[ix];
+}
+
+static void _lan_queue_lock(LAN_QUEUE_ENUM ix)
+{
+	int err_num;
+	lan_queue_s *ctx = _lan_queue_get_ctx(ix);
+	
+	if (0 != (err_num = pthread_mutex_lock((pthread_mutex_t *)ctx->mutex))) {
+		WARNING_PRINT("\nlock queue mutex[%d] failed: - '%s' (%d)\n",ix,strerror(err_num), err_num);
+	}
+}
+static void _lan_queue_unlock(LAN_QUEUE_ENUM ix)
+{
+	int err_num;
+	lan_queue_s *ctx = _lan_queue_get_ctx(ix);
+	
+	if (0 != (err_num = pthread_mutex_unlock((pthread_mutex_t *)ctx->mutex))) {
+		WARNING_PRINT("unlock queue mutex[%d] failed - '%s' (%d)\n",ix, strerror(err_num), err_num);
+	}
+}
+
+
+static int _lan_queue_init(LAN_QUEUE_ENUM ix,int max_size)
+{
+	int err_num;
+	lan_queue_s *ctx = _lan_queue_get_ctx(ix);
+
+	memset(ctx, 0, sizeof(lan_queue_s));
+
+	ctx->mutex = (pthread_mutex_t *)malloc(sizeof(pthread_mutex_t));
+	if (ctx->mutex == NULL) {
+		WARNING_PRINT("\nmalloc queue mutex[%d] failed: - '%s' (%d)\n",ix, strerror(err_num), err_num);
+		return -1;
+	}
+	
+	if (0 != (err_num = pthread_mutex_init(ctx->mutex, NULL))) {
+		WARNING_PRINT("\ninit queue mutex[%d] failed\n",ix);
+		free(ctx->mutex);
+		return -2;
+	}
+	
+	ctx->max_size = max_size;
+	INIT_LIST_HEAD(&ctx->list);
+	INFO_PRINT("\nlan queue[%d] init success~~~\n",ix);
+
+	return 0;
+}
+
+
+
+int lan_queue_init(void)
+{
+	_lan_queue_init(NODE_MAP,LAN_QUEUE_SIZE(1));
+}
+void lan_queue_deinit(void)
+{
+	//do it;
+}
+
+
+int lan_queue_enqueue(LAN_QUEUE_ENUM ix,void *data)
+{
+	lan_queue_s *ctx = _lan_queue_get_ctx(ix);
+	lan_queue_msg_s *node = NULL;
+
+	if (data == NULL) {
+		INFO_PRINT("\nenqueue-[%d] fail,data is NULL!!!\n",ix);
+		return -2;
+	}
+
+	_lan_queue_lock(ix);
+	INFO_PRINT("\nlist size: %d, max size: %d\n", ctx->size, ctx->max_size);
+	if (ctx->size >= ctx->max_size) {
+		INFO_PRINT("\nenqueue-[%d] fail,queue full!!!\n",ix);
+		_lan_queue_unlock(ix);
+		return -3;
+	}
+
+	node = malloc(sizeof(lan_queue_msg_s));
+
+	if (node == NULL) {
+		INFO_PRINT("\nenqueue-[%d] fail,node is NULL!!!\n",ix);
+		_lan_queue_unlock(ix);
+		return -4;
+	}
+	memset(node, 0, sizeof(lan_queue_msg_s));
+
+
+	node->data = data;
+
+	INIT_LIST_HEAD(&node->list);
+	ctx->size++;
+	list_add_tail(&node->list, &ctx->list);
+
+	_lan_queue_unlock(ix);
+
+	INFO_PRINT("\nenqueue-[%d] success~~~\n",ix);
+
+	return 0;
+}
+
+int lan_queue_dequeue(LAN_QUEUE_ENUM ix,void **data)
+{
+	lan_queue_s *ctx = _lan_queue_get_ctx(ix);
+	lan_queue_msg_s *node = NULL;
+
+
+
+	if (data == NULL) {
+		return -2;
+	}
+
+	_lan_queue_lock(ix);
+
+	if (list_empty(&ctx->list)) {
+		_lan_queue_unlock(ix);
+		return -3;
+	}
+
+	node = list_first_entry(&ctx->list, lan_queue_msg_s, list);
+	list_del(&node->list);
+
+	ctx->size--;
+
+	*data = node->data;
+	free(node);
+
+	_lan_queue_unlock(ix);
+
+	INFO_PRINT("\ndequeue queue[%d] success~~~\n",ix);
+	return 0;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

application/klansdk/kk_lan_queue.h

+#ifndef _LAN_QUEUE_H_
+#define _LAN_QUEUE_H_
+
+#include "klist.h"
+
+typedef struct {
+	void *data;
+	struct list_head list;
+} lan_queue_msg_s;
+
+typedef struct {
+	void *mutex;
+	int max_size;
+	int size;
+	struct list_head list;
+}lan_queue_s;
+
+typedef enum{
+	NODE_MAP = 0,
+	LAN_QUEUE_END
+}LAN_QUEUE_ENUM;
+#define LAN_QUEUE1_SIZE				50
+#define LAN_QUEUE2_SIZE				20
+#define LAN_QUEUE_SIZE(x)			LAN_QUEUE##x##_SIZE
+
+int lan_queue_init(void);
+int lan_queue_dequeue(LAN_QUEUE_ENUM ix,void **data);
+int lan_queue_enqueue(LAN_QUEUE_ENUM ix,void *data);
+
+#endif

application/klansdk/kk_newccu_msg.c

+
+
+#include "kk_log.h"
+
+#include "klist.h"
+#include "kk_product.h"
+#include "com_api.h"
+#include "kk_opcode.h"
+#include "kk_lan_ctrl.h"
+#include "kk_data_mng.h"
+
+#include "kk_newccu_msg.h"
+
+
+
+
+cJSON *property_info_build(const char *msgtype,const char *productCode,const char *deviceCode)
+{
+	cJSON *info=cJSON_CreateObject();
+
+	cJSON_AddStringToObject(info, "msgtype", msgtype);
+	cJSON_AddStringToObject(info, "productCode",productCode);
+	cJSON_AddStringToObject(info, "deviceCode",deviceCode);
+	
+	return info;
+}
+cJSON *property_payload_build(const char*method,const char *msgId,const char *version,cJSON *params)
+{
+	cJSON *payload=cJSON_CreateObject();
+
+	cJSON_AddStringToObject(payload, "msgId",msgId);
+	cJSON_AddStringToObject(payload, "version",version);
+	cJSON_AddItemToObject(payload,PARAMS_STRING,params);
+	cJSON_AddStringToObject(payload, "method",method);
+	
+	return payload;
+}
+
+
+
+cJSON * property_set(const char *productCode,const char *deviceCode,const char *msgId,const char *version,cJSON *params)
+{
+	cJSON *root = cJSON_CreateObject();
+	cJSON *info = property_info_build("/thing/service/property/set",productCode,deviceCode);
+	cJSON *payload = property_payload_build("thing.service.property.set",msgId,version,params);
+
+	cJSON_AddItemToObject(root,INFO_STRING,info);
+	cJSON_AddItemToObject(root,PAYLOAD_STRING,payload);
+
+	return root;
+}
+
+
+cJSON * property_report(const char *productCode,const char *deviceCode,const char *msgId,const char *version,cJSON *params)
+{
+	cJSON *root=cJSON_CreateObject();
+	cJSON *info = property_info_build("/thing/event/{tsl.event.identifier}/post",productCode,deviceCode);
+	cJSON *payload = property_payload_build("thing.event.{tsl.event.identifier}.post",msgId,version,params);
+
+	cJSON_AddItemToObject(root,INFO_STRING,info);
+	cJSON_AddItemToObject(root,PAYLOAD_STRING,payload);
+
+	return root;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

application/klansdk/kk_newccu_msg.h

+#ifndef _KK_NEWCCU_MSG_H
+#define _KK_NEWCCU_MSG_H
+
+#include "kk_ccu_msg.h"
+
+cJSON *property_info_build(const char *msgtype,const char *productCode,const char *deviceCode);
+cJSON *property_payload_build(const char*method,const char *msgId,const char *version,cJSON *params);
+cJSON * property_set(const char *productCode,const char *deviceCode,const char *msgId,const char *version,cJSON *params);
+cJSON * property_report(const char *productCode,const char *deviceCode,const char *msgId,const char *version,cJSON *params);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#endif
+
+

application/klansdk/kk_oldccu_msg.c

+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "kk_data_mng.h"
+#include "kk_lan_node_db.h"
+
+#include "kk_log.h"
+
+#include "klist.h"
+#include "kk_product.h"
+#include "com_api.h"
+#include "kk_opcode.h"
+#include "kk_lan_ctrl.h"
+#include "kk_data_mng.h"
+
+#include "kk_oldccu_msg.h"
+
+
+
+cJSON *old_ccu_msg_build_json_node_int(int nodeid,const char*  opcode,const char*  status,cJSON * arg)
+{
+	cJSON *root;
+
+	if(nodeid==NULL||opcode==NULL||arg==NULL) {
+		return NULL;
+	}
+	
+	root=cJSON_CreateObject();
+	if(root){
+		cJSON_AddNumberToObject(root, "nodeid", nodeid);
+		cJSON_AddStringToObject(root, "opcode", opcode);
+		cJSON_AddStringToObject(root, "status", "success");
+		cJSON_AddItemToObject(root, "arg", arg);
+	}
+	return root;
+}
+
+
+cJSON *old_ccu_msg_build_json(const char* nodeid,const char*  opcode,const char*  status,cJSON * arg)
+{
+	cJSON *root;
+
+	if(nodeid==NULL||opcode==NULL||arg==NULL) {
+		return NULL;
+	}
+	
+	root=cJSON_CreateObject();
+	if(root){
+		cJSON_AddStringToObject(root, "nodeid", nodeid);
+		cJSON_AddStringToObject(root, "opcode", opcode);
+		cJSON_AddStringToObject(root, "status", "success");
+		cJSON_AddItemToObject(root, "arg", arg);
+	}
+	return root;
+}
+
+cJSON *old_ccu_msg_build(const char* nodeid,const char* opcode,const char* status,const char* arg)
+{
+	cJSON *root;
+
+	if(nodeid==NULL||opcode==NULL||arg==NULL) {
+		return NULL;
+	}
+	
+	root=cJSON_CreateObject();
+	if(root){
+		cJSON_AddStringToObject(root, "nodeid", nodeid);
+		cJSON_AddStringToObject(root, "opcode", opcode);
+		if(status==NULL){
+			cJSON_AddStringToObject(root, "status", "success");
+		}else{
+			cJSON_AddStringToObject(root, "status", status);
+		}
+		cJSON_AddStringToObject(root, "arg", arg);
+	}
+	return root;
+}
+
+int send_msg_to_module(cJSON *root)
+{
+	char *msg;
+	
+	if(root==NULL){
+		return -1;
+	}
+
+	if((msg = cJSON_Print(root))!=NULL){
+		printf("[lan->module]json:\n%s\n",msg);
+		cJSON_Minify(msg);
+		kk_send_data_to_sdk(msg);
+		free(msg);
+	}
+
+	return 0;
+}
+
+
+
+
+
+
+
+
+cJSON * val_conver_new2old(cJSON *newccuItem,cJSON *oldccuItem,int syn_type)
+{
+	cJSON *n_dataType = cJSON_GetObjectItem(newccuItem,DATATYPE_STRING);
+	cJSON * n_value  = cJSON_GetObjectItem(newccuItem,"value");
+
+	cJSON *o_dataType;
+	cJSON *val;
+
+
+	cJSON *o_valueRange = cJSON_GetObjectItem(oldccuItem,"valueRange");
+	cJSON *n_valueRange = cJSON_GetObjectItem(newccuItem,"valueRange");
+
+	if(syn_type==1){
+		o_dataType = cJSON_GetObjectItem(oldccuItem,"synType");
+	}else{
+		o_dataType = cJSON_GetObjectItem(oldccuItem,DATATYPE_STRING);
+	}
+	
+	if(strcmp(o_dataType->valuestring,"map")==0){
+		val = map_type_convert(n_dataType,n_valueRange,n_value,o_valueRange);
+	}else{
+		val = msg_convert_value(o_dataType,n_dataType,n_value);
+	}
+	return val;
+}
+
+
+typedef struct {
+	char *area;
+	char *name;
+	char *delay;
+	char *nodeid;
+	char *operate_type;
+	char *operation;
+	char *room_id;
+}SCENE_ACTION;
+
+typedef struct{
+	char *scene_id;
+	char *name;
+	char *pannel_id;
+	char *room_id;
+	char *time;
+	char *week;
+	SCENE_ACTION **act;
+	int act_num;
+}SCENE_BUILD;
+
+
+
+cJSON *kk_action_build(SCENE_ACTION *act)
+{
+	cJSON *action = cJSON_CreateObject();
+	if(act->nodeid==NULL || act->operation==NULL ||
+		act->operation==NULL ||act->room_id==NULL){
+		return ;
+	}
+	cJSON_AddStringToObject(action, "area",(act->area==NULL)?"":act->area);
+	cJSON_AddStringToObject(action, "name",(act->name==NULL)?"":act->name);
+	cJSON_AddStringToObject(action, "delay",(act->delay==NULL)?"0":act->delay);
+	cJSON_AddStringToObject(action, "nodeid",act->nodeid);
+	cJSON_AddStringToObject(action, "operate_type",act->operate_type);
+	cJSON_AddStringToObject(action, "operation",act->operation);
+	cJSON_AddStringToObject(action, "room_id",act->room_id);
+	return action;
+}
+
+
+cJSON *kk_actions_build(SCENE_ACTION **act,int num)
+{
+	int i;
+	cJSON *actions = cJSON_CreateArray();
+	cJSON *action;
+	for(i=0;i<num;i++){
+		action=kk_action_build(act[i]);
+		cJSON_AddItemToArray(actions,action);
+	}
+	return actions;
+}
+
+cJSON *kk_scene_build(SCENE_BUILD *content)
+{
+	cJSON *scene = cJSON_CreateObject();
+	cJSON *actions = kk_actions_build(content->act,content->act_num);
+	
+	cJSON_AddItemToObject(scene, "actions",actions);
+	cJSON_AddStringToObject(scene, "id",content->scene_id);
+	cJSON_AddStringToObject(scene, "name",content->name);
+	cJSON_AddStringToObject(scene, "pannel_id",(content->pannel_id==NULL)?"*":content->pannel_id);
+	cJSON_AddStringToObject(scene, "room_id",content->room_id);
+	cJSON_AddStringToObject(scene, "scene_image","");
+	cJSON_AddStringToObject(scene, "scene_type","");
+	if(content->time==NULL){
+		cJSON_AddStringToObject(scene, "timer_enable","0");
+		cJSON_AddStringToObject(scene, "time","");
+	}else{
+		cJSON_AddStringToObject(scene, "timer_enable","1");
+		cJSON_AddStringToObject(scene, "time",content->time);
+	}
+	
+	cJSON_AddStringToObject(scene, "week",content->week);
+	
+	return scene;
+	
+}
+
+void kk_scene_build_test(void)
+{
+	cJSON *msg;
+	SCENE_BUILD scene;
+	scene.name = calloc(1,20);
+	memcpy(scene.name,"离家",strlen("离家"));
+	scene.scene_id = calloc(1,20);
+	memcpy(scene.scene_id,"123",strlen("123"));
+
+	scene.pannel_id= calloc(1,20);
+	memcpy(scene.pannel_id,"*",strlen("*"));
+	scene.room_id = calloc(1,20);
+	memcpy(scene.room_id,"456",strlen("456"));
+	scene.time = calloc(1,20);
+	memcpy(scene.time,"",strlen(""));
+	scene.week = calloc(1,20);
+	memcpy(scene.week,"",strlen(""));
+
+
+	scene.act_num = 1;
+	
+	SCENE_ACTION *act = calloc(1,sizeof(SCENE_ACTION)*scene.act_num);
+	scene.act=&act;
+	scene.act[0]->area=calloc(1,20);
+	memcpy(scene.act[0]->area,"",strlen(""));
+
+	scene.act[0]->delay=calloc(1,20);
+	memcpy(scene.act[0]->delay,"",strlen(""));
+	
+	scene.act[0]->name=calloc(1,20);
+	memcpy(scene.act[0]->name,"",strlen(""));
+
+	scene.act[0]->nodeid=calloc(1,20);
+	memcpy(scene.act[0]->nodeid,"",strlen(""));
+
+	scene.act[0]->operate_type=calloc(1,20);
+	memcpy(scene.act[0]->operate_type,"",strlen(""));
+
+	scene.act[0]->operation=calloc(1,20);
+	memcpy(scene.act[0]->operation,"",strlen(""));
+
+	scene.act[0]->room_id=calloc(1,20);
+	memcpy(scene.act[0]->room_id,"",strlen(""));
+
+	msg = kk_scene_build(&scene);
+
+	printf("--------scene--------->\n%s\n",cJSON_Print(msg));
+
+}
+
+
+
+cJSON *kk_devicestatus_build(kk_map_dev_node_t *node)
+{
+	char nodeid[32] = {0};
+	char indxId[4] = {0};
+	int idx = 1;
+	int syn_type = 0;
+
+	cJSON *dev_status;
+
+	if (node == NULL) return NULL;
+
+	dev_status = cJSON_CreateObject();
+
+	kk_map_dev_ctx *ctx = _kk_map_dev_ctx();
+
+	#if 1
+
+	cJSON * newccuItem = node->newccu->child;
+	cJSON * oldccuItem = node->oldccu->child;
+
+	syn_type = node->syn_type;
+
+	{
+		cJSON *status = cJSON_CreateObject();
+
+		cJSON *synKey;
+		cJSON *synType;
+	
+
+		printf("yyy-1\n");
+		memset(nodeid,0x0,sizeof(nodeid));
+			printf("yyy-2\n");
+		kk_creater_nodeid(node->deviceCode,1,nodeid);
+		printf("yyy-3,%s\n",nodeid);
+
+		if(node->syn_opcode){
+			cJSON_AddStringToObject(status, OPCODE_STRING, node->syn_opcode);
+		}
+		printf("yyy-4\n");
+		cJSON_AddNumberToObject(status, NODEID_STRING, atoi(nodeid));
+		printf("yyy-5\n");
+		sprintf(indxId,"%d",idx++);
+		printf("yyy-6\n");
+		cJSON_AddStringToObject(status, "index", indxId);
+		printf("yyy-7\n");
+
+		while(newccuItem != NULL){
+		
+			//printf("oldccuItem--->%s\n",cJSON_Print(oldccuItem));
+
+			synType = cJSON_GetObjectItem(oldccuItem,"synType");
+
+			printf("synType->valuestring--->%s\n",synType->valuestring);
+		
+			if(strcmp(synType->valuestring,"dummy")){
+				synKey = cJSON_GetObjectItem(oldccuItem,"syn");
+
+				if(strcmp(synType->valuestring,"timing_shutdown")==0) {
+
+					cJSON *syn_obj = cJSON_CreateObject();
+
+					double t=cJSON_GetObjectItem(newccuItem,"value")->valuedouble;
+					char buff[32]={0};
+
+					snprintf(buff,32,"%f",t);
+					printf("&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&%s\n",buff);
+						
+					if(t>0){
+						cJSON_AddBoolToObject(syn_obj, "enable",1);
+						cJSON_AddStringToObject(syn_obj, "time",buff);
+					}else{
+						cJSON_AddBoolToObject(syn_obj, "enable",0);
+						cJSON_AddNullToObject(syn_obj, "time");
+					}
+
+						cJSON_AddItemToObject(dev_status, synKey->valuestring,syn_obj);
+					
+				}else{
+					cJSON *val = val_conver_new2old(newccuItem,oldccuItem,1);
+
+					
+
+					if(val){
+						printf("val--->%s\n",cJSON_Print(val));
+						printf("val->type=%d,%d,%d\n",val->type,cJSON_String,cJSON_Number);
+						if(val->type==cJSON_String) {
+							cJSON_AddStringToObject(dev_status, synKey->valuestring,val->valuestring);
+						}else if(val->type==cJSON_Number) {
+							cJSON_AddNumberToObject(dev_status, synKey->valuestring,val->valuedouble);
+						}else{
+							cJSON_AddItemToObject(dev_status, synKey->valuestring,val);
+						}
+					}
+
+				}
+			}
+
+			newccuItem = newccuItem->next;
+			oldccuItem = oldccuItem->next;
+			
+		}
+	}
+		
+
+	 
+	#endif
+
+	printf("@##$%^&&*(*(((*^%$$#@@@--->%s\n",cJSON_Print(dev_status));
+
+	return dev_status;
+}
+
+
+int kk_devicestatus_build_aaa(cJSON *Array,kk_map_dev_node_t *node)
+{
+	char nodeid[32] = {0};
+	char indxId[4] = {0};
+	int idx = 1;
+
+
+	cJSON *dev_status;
+
+	if (node == NULL) return -1;
+
+	
+
+	kk_map_dev_ctx *ctx = _kk_map_dev_ctx();
+
+
+	cJSON * newccuItem = node->newccu->child;
+	cJSON * oldccuItem = node->oldccu->child;
+
+	
+	while(newccuItem != NULL){
+		dev_status = cJSON_CreateObject();
+
+		memset(nodeid,0x0,sizeof(nodeid));
+
+		char *opcodemap = cJSON_GetObjectItem(newccuItem,OPCODEMAP_STRING)->valuestring;
+		char *channel = cJSON_GetObjectItem(newccuItem,CHANNEL_STRING)->valuestring;
+		char *dataType = cJSON_GetObjectItem(newccuItem,DATATYPE_STRING)->valuestring;
+		cJSON *range = cJSON_GetObjectItem(newccuItem,VALUERANGE_STRING);
+
+		char *o_dataType = cJSON_GetObjectItem(oldccuItem,DATATYPE_STRING)->valuestring;
+		
+		printf("identifier=%s\n",cJSON_GetObjectItem(newccuItem,"identifier")->valuestring);
+	
+		printf("newccuItem=%s\n",cJSON_Print(newccuItem));
+
+			
+		kk_creater_nodeid(node->deviceCode,atoi(channel),nodeid);
+
+		cJSON_AddStringToObject(dev_status, OPCODE_STRING, opcodemap);
+		cJSON_AddNumberToObject(dev_status, NODEID_STRING, atoi(nodeid));
+		
+		sprintf(indxId,"%d",idx++);
+		cJSON_AddStringToObject(dev_status, "index", indxId);
+		printf("index=%s,dataType=%s,o_dataType=%s\n",indxId,dataType,o_dataType);
+
+
+		if(strcmp(o_dataType,"string") == 0){
+			if(strcmp(dataType,"int") == 0 || strcmp(dataType,"double") == 0){
+				int value  = cJSON_GetObjectItem(newccuItem,"value")->valueint;
+				if(range != NULL){
+					int index = kk_get_int_value_idx(range,value);
+					if(index==-1){
+						index = 0;
+					}
+					cJSON * ary=cJSON_GetObjectItem(oldccuItem,"valueRange");
+					cJSON * def=cJSON_GetArrayItem(ary,index);
+					cJSON_AddStringToObject(dev_status, "arg",def->valuestring);
+					printf("yjq=%d\n",index);
+					
+				}
+			}else if(strcmp(dataType,"double") == 0){
+				
+			}
+
+		}else if(strcmp(o_dataType,"string_double") == 0){
+
+			double value = cJSON_GetObjectItem(newccuItem,"value")->valuedouble;
+			char *val = double_value_string(value);
+			cJSON_AddNumberToObject(dev_status, "arg",value);
+			free(val);
+		}
+
+		cJSON_AddItemToArray(Array,dev_status);
+
+		
+		//todo 
+		newccuItem = newccuItem->next;
+		oldccuItem = oldccuItem->next;
+		
+
+	}
+	
+
+	return 0;
+}
+
+
+
+
+
+
+cJSON * attr_report_conver(const char *deviceCode,kk_map_dev_node_t *devNode,cJSON *params)
+{
+	cJSON *root;
+	//
+	cJSON *newccu;
+	cJSON *n_item;
+	cJSON *n_id,*n_valueRange,*n_dataType;
+	cJSON *n_value;
+
+
+	//
+	cJSON *oldccu;
+	cJSON *o_item;
+	cJSON *o_id_map,*o_valueRange,*o_dataType;
+	cJSON *o_value;
+
+
+	cJSON *val;
+	cJSON *item_size;
+	cJSON *channel;
+	cJSON *opcode;
+	
+
+	int i,j;
+	int ch;
+	int nodeId;
+	char *node_str;
+	cJSON *msg;
+	cJSON *args;
+
+
+
+	
+	
+	oldccu = devNode->oldccu;
+	newccu = devNode->newccu;
+
+	item_size = cJSON_GetArraySize(oldccu);
+	
+	printf("item_size=%d\n",item_size);
+	
+
+	
+	for(i=0;i<item_size;i++){
+		
+
+		o_item = cJSON_GetArrayItem(oldccu,i);
+		n_item = cJSON_GetArrayItem(newccu,i);
+	
+		o_id_map = cJSON_GetObjectItem(o_item,"identifiermap");
+		printf("o_id_map=%s\n",o_id_map->valuestring);
+
+	
+		if(o_id_map){
+			printf("o_id_map=%s\n",cJSON_Print(o_id_map));
+		}
+		n_id = cJSON_GetObjectItem(params,o_id_map->valuestring);
+		printf("[%s][%d]n_id=%s\n",__FUNCTION__,__LINE__,cJSON_Print(n_id));
+
+		if(n_id!=NULL){
+			if(params){
+				printf("21-params=%s\n",cJSON_Print(params));
+			}
+			n_dataType = cJSON_GetObjectItem(n_item,"dataType");
+			n_valueRange = cJSON_GetObjectItem(n_item,"valueRange");
+		
+			o_dataType = cJSON_GetObjectItem(o_item,"dataType");
+			o_valueRange = cJSON_GetObjectItem(o_item,"valueRange");
+			
+
+
+			printf("[%s][%d]\n",__FUNCTION__,__LINE__);
+			channel = cJSON_GetObjectItem(o_item,"channel");
+			ch = atoi(channel->valuestring);
+			nodeId = kk_lan_db_node_get(deviceCode,ch);
+			
+			opcode =cJSON_GetObjectItem(o_item,"opcode");
+			
+			printf("[%s][%d]n_dataType->valuestring=%s,opcode->valuestring=%s\n",__FUNCTION__,__LINE__,n_dataType->valuestring,opcode->valuestring);
+
+			
+			printf("\nn_id->type=%d\n",n_id->type);
+			//cJSON_ReplaceItemInObject(n_item, "value", cJSON_CreateString(""));//
+			if(n_id->type==cJSON_False){
+				cJSON_ReplaceItemInObject(n_item, "value", cJSON_CreateFalse());
+			}else if(n_id->type==cJSON_True){
+				cJSON_ReplaceItemInObject(n_item, "value", cJSON_CreateTrue());
+			}else if(n_id->type==cJSON_NULL){
+				cJSON_ReplaceItemInObject(n_item, "value", cJSON_CreateNull());
+			}else if(n_id->type==cJSON_Number){
+				if(strcmp(n_dataType->valuestring,"double")==0){
+					cJSON_ReplaceItemInObject(n_item, "value", cJSON_CreateNumber(n_id->valuedouble));
+				}else {
+					cJSON_ReplaceItemInObject(n_item, "value", cJSON_CreateNumber(n_id->valueint));
+				}
+				
+			}else if(n_id->type==cJSON_String){
+				cJSON_ReplaceItemInObject(n_item, "value", cJSON_CreateString(n_id->valuestring));
+			}else if(n_id->type==cJSON_Array){
+				//cJSON_ReplaceItemInObject(n_item, "value", cJSON_CreateArray(n_id->valuestring));
+				/*
+				#define cJSON_Array  (1 << 5)
+				#define cJSON_Object (1 << 6)
+				#define cJSON_Raw    (1 << 7) 
+				*/
+				printf("......................\n");
+			}
+			
+		
+			//cJSON_ReplaceItemInObject(newccuItem, "value", cJSON_CreateNumber(val));
+
+
+			
+			printf("o_dataType=%s\n",o_dataType->valuestring);
+
+			if(strcmp(o_dataType->valuestring,"map")==0){
+				args = map_type_convert(n_dataType,n_valueRange,n_id,o_valueRange);
+			}else{
+				args = msg_convert_value(o_dataType,n_dataType,n_id);
+			}
+			
+			if(args){
+				printf("yy111y,args=%s\n",cJSON_Print(args));
+				update_device_status_2_oldccu(nodeId,opcode->valuestring,args->valuestring);
+			}else{
+				printf("yy111y,args=NULL\n");
+			}
+			
+
+	
+			
+		}
+	}
+	printf("yy2222y\n");
+
+	if(devNode->syn_type==1){
+		cJSON *arg;
+		char *node_str;
+
+		arg = kk_devicestatus_build(devNode);
+		printf("yy444y\n");
+		nodeId = kk_lan_db_node_get(deviceCode,1);
+		printf("yy555y\n");
+		node_str=node_string(nodeId);
+		printf("yy666y\n");
+
+	
+		msg=old_ccu_msg_build_json(node_str,devNode->syn_opcode,NULL,arg);
+		printf("66666666666=%s\n",cJSON_Print(msg));
+		send_msg_to_module(msg);
+		free(node_str);
+		cJSON_Delete(msg);
+	}	
+	
+	return root;
+}
+
+
+
+
+
+int del_device(const char *deviceCode,const char *nodeid)
+{
+	cJSON *msg;
+	cJSON *arg;
+
+	kk_map_dev_node_t *dev;
+
+	if(deviceCode==NULL||nodeid==NULL){
+		return -1;
+	}
+
+	arg = cJSON_CreateObject();
+	cJSON_AddStringToObject(arg,"mac",deviceCode);
+	msg = old_ccu_msg_build_json(nodeid,"DEL_DEVICE",NULL,arg);
+	send_msg_to_module(msg);
+	cJSON_Delete(msg);
+
+	return 0;
+}
+
+int del_device_all_node(const char *deviceCode)
+{
+	#define MAX_CHANNEL_NUM 				32
+	int list[MAX_CHANNEL_NUM] = {0};
+	int i,num = 0;
+	char *nodeid;
+	
+	//删除数据库
+	kk_lan_db_node_delete(deviceCode);
+	
+	num = kk_lan_db_node_get_all(deviceCode,list);
+	for(i=0;i<num;i++){
+		nodeid = node_string(list[i]);
+		del_device(deviceCode,nodeid);
+		free(nodeid);
+	}
+	if(num){
+		kk_handle_sync_info();
+	}
+}
+
+
+
+void device_delete_sync(cJSON *payload)
+{
+	cJSON *params;
+	cJSON *deviceCode;
+
+	printf("[%s][%d]\n",__FUNCTION__,__LINE__);
+	
+	params = cJSON_GetObjectItem(payload,"params");
+	
+	deviceCode = cJSON_GetObjectItem(params, "deviceCode");
+	del_device_all_node(deviceCode->valuestring);
+	
+
+
+}
+void device_add_sync(cJSON *payload)
+{
+
+	//NEW_DEVICES
+	printf("[%s][%d]\n",__FUNCTION__,__LINE__);
+	kk_handle_sync_info();
+}
+
+
+
+
+
+
+
+
+void device_new_device_sync(cJSON *payload)
+{
+
+	//NEW_DEVICES
+	printf("[%s][%d]\n",__FUNCTION__,__LINE__);
+	kk_handle_sync_info();
+}
+
+
+void property_post_deal(const char *deviceCode,cJSON *payload)
+{
+	cJSON *params;
+
+	kk_map_dev_node_t *dev;
+	printf("[%s][%d]\n",__FUNCTION__,__LINE__);
+
+	if(kk_map_dev_search_by_deviceCode(deviceCode, &dev)==0){
+		
+		params = cJSON_GetObjectItem(payload,"params");
+		attr_report_conver(deviceCode,dev,params);
+	}
+}
+
+void property_syn_deal(const char *deviceCode,cJSON *properties)
+{
+	cJSON *params;
+
+	kk_map_dev_node_t *dev;
+
+	if(kk_map_dev_search_by_deviceCode(deviceCode, &dev)==0){
+		attr_report_conver(deviceCode,dev,properties);
+	}
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+

application/klansdk/kk_oldccu_msg.h

+#ifndef _KK_OLDCCU_MSG_H
+#define _KK_OLDCCU_MSG_H
+#include "kk_ccu_msg.h"
+
+
+
+cJSON *old_ccu_msg_build_json(const char* nodeid,const char*  opcode,const char*  status,cJSON * arg);
+
+cJSON *old_ccu_msg_build(const char* nodeid,const char* opcode,const char* status,const char* arg);
+int send_msg_to_module(cJSON *root);
+
+
+
+
+
+
+
+
+
+
+
+
+
+#endif
+
+
+