【修改内容】1，增加kk_tsl_get_value接口；2，调整tsl文件load;3，上传mqtt测试服务器的url,name,PASSWORD

【提交人】陈伟灿

application/kcloud/kcloud_config.h

@@ -2,15 +2,15 @@
 #ifndef MQTT_CONF_H_
 #define MQTT_CONF_H_
 
-#define ADDRESS     "tcp://106.13.117.117:1883"
+#define ADDRESS     "tcp://172.25.240.31:1983"
 #define CLIENTID    "1234"
 #define TOPIC       "/sys/a1OYuSBt23u/aIqEbWno8yDdsjCX15iq/thing/service/property/set"
 
 #define PAYLOAD     "Hello cwc World!"
 #define QOS         2
 #define TIMEOUT     10000L
-#define USRNAME     ""
-#define PASSWORD    ""
+#define USRNAME     "hangzhou_gateway "
+#define PASSWORD    "2ca1442865ff4cb99870f60f2c646190"
 #define AUTO_CONN   1
 #define CONNECT_TIMEOUT   3
 #endif

application/kcloud/kcloud_data_handle.c

@@ -5,7 +5,7 @@
 #include "com_api.h"
 #include "cJSON.h"
 
-static char * data_create(const char *topic,const char *data)
+static char * _kk_data_create(const char *topic,const char *data)
 {
 	cJSON *root;
 	char *out;
@@ -46,7 +46,7 @@ void KK_Sendto_CloudData(void *data,int len)
 
 void KK_Sendto_DevData(const char *topic,const char *data)
 {
-	char *send_data = data_create(topic,data);
+	char *send_data = _kk_data_create(topic,data);
 	
 	kk_ipc_send(IPC_APP2MID, send_data, strlen(send_data)+1);
 }

application/kcloud/mqtt_api.c

@@ -118,7 +118,7 @@ static void mqttTraceCallback(enum MQTTASYNC_TRACE_LEVELS level, char *message)
 }
 static void onDeliveryComplete(void* context, MQTTAsync_token token)
 {
-	INFO_PRINT("onDeliveryComplete,token:%d \n",token);
+	//INFO_PRINT("onDeliveryComplete,token:%d \n",token);
 }
 static void onConnectBuild(void *context, char *cause)
 {

midware/midware/dm/kk_dm_mng.c

@@ -83,6 +83,7 @@ int dm_mgr_device_create(_IN_ int dev_type, _IN_ char product_key[PRODUCT_KEY_MA
     dm_mgr_dev_node_t *node = NULL;
 	char *tsl_str = NULL;
 	int idx = 0;
+	char name[TSL_PATH_MAXLEN] = {0};
     if (product_key == NULL || device_name == NULL ||
         strlen(product_key) >= PRODUCT_KEY_MAXLEN ||
         strlen(device_name) >= DEVICE_NAME_MAXLEN) {
@@ -119,16 +120,15 @@ int dm_mgr_device_create(_IN_ int dev_type, _IN_ char product_key[PRODUCT_KEY_MA
         memcpy(node->device_secret, device_secret, strlen(device_secret));
     }
     //node->dev_status = IOTX_DM_DEV_STATUS_AUTHORIZED;
-    idx = kk_get_tslIdx_by_productKey(product_key);
-	if(dev_type == KK_DM_DEVICE_SUBDEV){
-		tsl_str = load_json(idx);
-		res = kk_tsl_create(tsl_str,strlen(tsl_str),&node->dev_shadow);
-		free(tsl_str);
-		if(res != 0)
-		{
-			return FAIL_RETURN;
-		}
+    memset(name,0x0,sizeof(name));
+    kk_get_tsl_by_productKey(product_key,name);
+	tsl_str = kk_load_json(name);
+	res = kk_tsl_create(tsl_str,strlen(tsl_str),&node->dev_shadow);
+	free(tsl_str);
+	if(res != 0){
+		return FAIL_RETURN;
 	}
+	
     INIT_LIST_HEAD(&node->linked_list);
     list_add_tail(&node->linked_list, &ctx->dev_list);
 
@@ -188,7 +188,7 @@ int dm_mgr_init(void)
     memset(device_name,0x0,sizeof(device_name));	
 	memcpy(product_key,"a1OYuSBt23u",strlen("a1OYuSBt23u"));
 	memcpy(device_name,"aIqEbWno8yDdsjCX15iq",strlen("aIqEbWno8yDdsjCX15iq"));
-	kk_set_tsl_by_productKey("a1OYuSBt23u","model.json");
+	kk_set_tsl_by_productKey("a1OYuSBt23u","ccu.json");
     //_dm_mgr_legacy_thing_created(IOTX_DM_LOCAL_NODE_DEVID);
 	res = dm_mgr_device_create(KK_DM_DEVICE_SUBDEV,product_key,device_name,device_secret,&devId);
 	if (res != SUCCESS_RETURN) {
@@ -245,7 +245,7 @@ int dm_mgr_upstream_thing_property_post(_IN_ int devid, _IN_ char *payload, _IN_
 
     memset(&request, 0, sizeof(dm_msg_request_t));
     res = _dm_mgr_upstream_request_assemble(iotx_report_id(), devid, DM_URI_SYS_PREFIX, DM_URI_THING_EVENT_PROPERTY_POST,
-                                            payload, payload_len, "thing.event.property.post", &request);
+                                            payload, payload_len, DM_URI_THING_EVENT_PROPERTY_POST_METHOD, &request);
     if (res != SUCCESS_RETURN) {
         return FAIL_RETURN;
     }

midware/midware/dm/kk_dm_msg.c

@@ -12,6 +12,7 @@ const char DM_URI_THING_EVENT_PROPERTY_POST[]		  DM_READ_ONLY = "thing/event/pro
 const char DM_URI_THING_SERVICE_PROPERTY_SET_REPLY[]  DM_READ_ONLY = "thing/service/property/set_reply";
 const char DM_URI_THING_EVENT_POST[]				  DM_READ_ONLY = "thing/event/%.*s/post";
 const char DM_URI_THING_SERVICE_RESPONSE[]			  DM_READ_ONLY = "thing/service/%.*s_reply";
+const char DM_URI_THING_EVENT_PROPERTY_POST_METHOD[]  DM_READ_ONLY = "thing.event.property.post";
 
 
 

midware/midware/dm/kk_dm_msg.h

@@ -59,6 +59,7 @@ extern const char DM_URI_THING_EVENT_PROPERTY_POST[]		 DM_READ_ONLY;
 const char DM_URI_THING_SERVICE_PROPERTY_SET_REPLY[]  DM_READ_ONLY;
 const char DM_URI_THING_EVENT_POST[]				  DM_READ_ONLY;
 const char DM_URI_THING_SERVICE_RESPONSE[]			  DM_READ_ONLY;
+const char DM_URI_THING_EVENT_PROPERTY_POST_METHOD[]  DM_READ_ONLY;
 
 
 #endif

midware/tsl/tsl_handle/kk_tsl_api.h

@@ -74,6 +74,13 @@ typedef enum {
     kk_tsl_set_service_output_value,
     kk_tsl_set_number,
 } kk_tsl_set_t;
+typedef enum {
+	kk_tsl_get_property_value = 0,
+	kk_tsl_get_event_output_value,
+	kk_tsl_get_service_input_value,
+	kk_tsl_get_service_output_value,
+	kk_tsl_get_number,
+} kk_tsl_get_t;
 
 typedef struct {
     void *mutex;
@@ -84,6 +91,10 @@ extern int kk_tsl_api_init(void);
 extern int kk_tsl_set_value(kk_tsl_set_t set, int devId, const char *identifier, \
                                        const void *value, \
                                        const char *value_str);
+extern int kk_tsl_get_value(kk_tsl_get_t method_get, int devId, const char *identifier, \
+                                       void *value, \
+                                       char **value_str);
+
 extern int kk_msg_uri_parse_pkdn(_IN_ char *uri, _IN_ int uri_len, _IN_ int start_deli, _IN_ int end_deli, \
                           _OU_ char product_key[PRODUCT_KEY_MAXLEN], _OU_ char device_name[DEVICE_NAME_MAXLEN]);
 extern int kk_tsl_service_property_set(const char *topic, const char *payload, unsigned int payload_len,

midware/tsl/tsl_handle/kk_tsl_func.c

@@ -984,6 +984,152 @@ int kk_tsl_get_data_type(_IN_ void *data, _OU_ kk_tsl_data_type_e *type)
 
     return SUCCESS_RETURN;
 }
+static int _kk_tsl_data_array_get(_IN_ kk_tsl_data_value_t *data_value, _IN_ void *value, _IN_ int index)
+{
+    kk_tsl_data_value_complex_t *complex_array = data_value->value;
+
+    if (complex_array == NULL || index < 0 || index >= complex_array->size) {
+        return FAIL_RETURN;
+    }
+
+    if (g_iotx_data_type_mapping[complex_array->type].func_array_get == NULL) {
+        return FAIL_RETURN;
+    }
+
+    return g_iotx_data_type_mapping[complex_array->type].func_array_get(data_value, value, index);
+}
+static int _kk_tsl_data_get(_IN_ kk_tsl_data_value_t *data_value, _IN_ void *value)
+{
+    if (g_iotx_data_type_mapping[data_value->type].func_get == NULL) {
+        return FAIL_RETURN;
+    }
+
+    return g_iotx_data_type_mapping[data_value->type].func_get(data_value, value);
+}
+
+
+int kk_tsl_get_property_value_ex(_IN_ kk_tsl_t *shadow, _IN_ char *key, _IN_ int key_len, _OU_ void *value)
+{
+    int res = 0, array_index = 0;
+    kk_tsl_data_t *data = NULL;
+
+    if (shadow == NULL || key == NULL || key_len <= 0) {
+        return INVALID_PARAMETER;
+    }
+
+    res = _kk_tsl_property_search(shadow, key, key_len, &data, &array_index);
+    if (res != SUCCESS_RETURN) {
+        return FAIL_RETURN;
+    }
+    printf("Current Found Data: %s\n", data->identifier);
+    if (data->data_value.type == KK_TSL_DATA_TYPE_ARRAY) {
+        printf("Current Found Data Index: %d\n", array_index);
+        res = _kk_tsl_data_array_get(&data->data_value, value, array_index);
+        if (res != SUCCESS_RETURN) {
+            return TSL_PROPERTY_GET_FAILED;
+        }
+    } else {
+        res = _kk_tsl_data_get(&data->data_value, value);
+        if (res != SUCCESS_RETURN) {
+            return TSL_PROPERTY_GET_FAILED;
+        }
+    }
+
+    return SUCCESS_RETURN;
+}
+int kk_tsl_get_event_oput_value(_IN_ kk_tsl_t *shadow, _IN_ char *key, _IN_ int key_len, _IN_ void *value)
+{
+    int res = 0;
+    int offset = 0, array_index = 0;
+    char *pos = NULL;
+    kk_tsl_event_t *event = NULL;
+    kk_tsl_data_t *event_data = NULL;
+
+    if (shadow == NULL || key == NULL || key_len <= 0) {
+        return INVALID_PARAMETER;
+    }
+
+    res = kk_utils_memtok(key, key_len, KK_MSG_KEY_DELIMITER, 1, &offset);
+    if (res != SUCCESS_RETURN) {
+        return FAIL_RETURN;
+    }
+
+    printf("Key: %.*s\n", key_len, key);
+
+    res = _kk_tsl_event_search(shadow, key, offset, &event);
+    if (res != SUCCESS_RETURN) {
+        return TSL_EVENT_NOT_EXIST;
+    }
+
+    pos = key + offset + 1;
+    printf("TSL Event Output Data Search, Event Data ID: %s", pos);
+
+    res = _kk_tsl_event_output_search(event->output_datas, event->output_data_number, pos, strlen(pos), &event_data,
+                                      &array_index);
+    if (res != SUCCESS_RETURN) {
+        return TSL_EVENT_NOT_EXIST;
+    }
+
+    if (event_data->data_value.type == KK_TSL_DATA_TYPE_ARRAY) {
+        res = _kk_tsl_data_array_get(&event_data->data_value, value, array_index);
+        if (res != SUCCESS_RETURN) {
+            return TSL_EVENT_GET_FAILED;
+        }
+    } else {
+        res = _kk_tsl_data_get(&event_data->data_value, value);
+        if (res != SUCCESS_RETURN) {
+            return TSL_EVENT_GET_FAILED;
+        }
+    }
+
+    return SUCCESS_RETURN;
+}
+int kk_tsl_get_service_input_output_value(_IN_ kk_tsl_data_target_e type, _IN_ kk_tsl_t *shadow, _IN_ char *key,
+        _IN_ int key_len, _IN_ void *value)
+{
+    int res = 0;
+    int offset = 0, array_index = 0;
+    char *pos = NULL;
+    kk_tsl_service_t *service = NULL;
+    kk_tsl_data_t *service_data = NULL;
+
+    if (shadow == NULL || key == NULL || key_len <= 0) {
+        return INVALID_PARAMETER;
+    }
+
+    res = kk_utils_memtok(key, key_len, KK_MSG_KEY_DELIMITER, 1, &offset);
+    if (res != SUCCESS_RETURN) {
+        return FAIL_RETURN;
+    }
+
+    printf("key: %.*s\n", key_len, key);
+
+    res = _kk_tsl_service_search(shadow, key, offset, &service);
+    if (res != SUCCESS_RETURN) {
+        return TSL_SERVICE_NOT_EXIST;
+    }
+
+    pos = key + offset + 1;
+    printf("TSL Service Input/Output Data Search, Event Data ID: %s", pos);
 
+    res = _kk_tsl_service_input_output_search(type, service, pos, strlen(pos), &service_data, &array_index);
+    if (res != SUCCESS_RETURN) {
+        return TSL_SERVICE_NOT_EXIST;
+    }
+
+    if (service_data->data_value.type == KK_TSL_DATA_TYPE_ARRAY) {
+        res = _kk_tsl_data_array_get(&service_data->data_value, value, array_index);
+        if (res != SUCCESS_RETURN) {
+            return TSL_SERVICE_GET_FAILED;
+        }
+    } else {
+        res = _kk_tsl_data_get(&service_data->data_value, value);
+        if (res != SUCCESS_RETURN) {
+            return TSL_SERVICE_GET_FAILED;
+        }
+    }
+
+    return SUCCESS_RETURN;
+}
 
 

midware/tsl/tsl_handle/kk_tsl_load.c

@@ -28,7 +28,7 @@ int kk_set_tsl_by_productKey(const char* key,const char* name)
 	s_tsl_num++;
 	return SUCCESS_RETURN;
 }
-int kk_get_tslIdx_by_productKey(const char* key)
+int kk_get_tsl_by_productKey(const char* key, char* name)
 {
 	int index = 0;
 	if(key == NULL)
@@ -41,7 +41,8 @@ int kk_get_tslIdx_by_productKey(const char* key)
 		if((strlen(key) == strlen(s_tsl_list[index].product_key))&&
 			(memcmp(s_tsl_list[index].product_key,key,strlen(key)) == 0))
 		{
-			return index;
+			memcpy(name,s_tsl_list[index].name,strlen(s_tsl_list[index].product_key));
+			return SUCCESS_RETURN;
 		}
 	}
 	printf("[%s][%d]Not exist!!!\n",__FUNCTION__,__LINE__);
@@ -49,13 +50,13 @@ int kk_get_tslIdx_by_productKey(const char* key)
 }
 
 
-char* load_json(int idx)
+char* kk_load_json(const char *tslFile)
 {
 	FILE *fp;
 	char *buf = NULL;
 	unsigned int filesize;
-	
-	if(!(fp =  fopen(s_tsl_list[idx].name,"a+")))
+	printf("[%s][%d]tslFile:%s!!!\n",__FUNCTION__,__LINE__,tslFile);
+	if(!(fp =  fopen(tslFile,"a+")))
 	{
 		printf("can't open the file account.txt\n");
 		return -1;

midware/tsl/tsl_handle/kk_tsl_load.h

 #ifndef __TSL_DATA_LOAD__
 #define __TSL_DATA_LOAD__
 
-extern char* load_json(int idx);
-extern int kk_get_tslIdx_by_productKey(const char* key);
+extern char* kk_load_json(const char *tslFile);
+extern int kk_get_tsl_by_productKey(const char* key, char* name);
 extern int kk_set_tsl_by_productKey(const char* key,const char* name);
 
 #endif

midware/tsl/tsl_handle/kk_utils.c

@@ -215,4 +215,51 @@ int kk_utils_service_name(_IN_ const char *prefix, _IN_ const char *name, _IN_ c
     return SUCCESS_RETURN;
 }
 
+int kk_utils_itoa_direct(_IN_ int input, _OU_ char **output)
+{
+  int res = 0;
+  char temp_output[10 + 1] = {0};
+
+  if (output == NULL || *output != NULL) {
+	  return INVALID_PARAMETER;
+  }
+
+  res = snprintf(temp_output, 10, "%d", input);
+  if (res < 0) {
+	  return FAIL_RETURN;
+  }
+
+  *output = malloc(strlen(temp_output) + 1);
+  if (*output == NULL) {
+	  return MEMORY_NOT_ENOUGH;
+  }
+  memset(*output, 0, strlen(temp_output) + 1);
+  memcpy(*output, temp_output, strlen(temp_output));
+
+  return SUCCESS_RETURN;
+}
+int kk_utils_ftoa_direct(_IN_ double input, _OU_ char **output)
+{
+    int res = 0;
+    char temp_output[30 + 1] = {0};
+
+    if (output == NULL || *output != NULL) {
+        return INVALID_PARAMETER;
+    }
+
+    res = snprintf(temp_output, 30, "%f", input);
+    if (res < 0) {
+        return FAIL_RETURN;
+    }
+
+    *output = malloc(strlen(temp_output) + 1);
+    if (*output == NULL) {
+        return MEMORY_NOT_ENOUGH;
+    }
+    memset(*output, 0, strlen(temp_output) + 1);
+    memcpy(*output, temp_output, strlen(temp_output));
+
+    return SUCCESS_RETURN;
+}
+
 

midware/tsl/tsl_handle/kk_utils.h

@@ -12,5 +12,7 @@ void *kk_MutexCreate(void);
 void kk_MutexLock(void *mutex);
 void kk_MutexUnLock(void *mutex);
 void kk_MutexDestroy(void *mutex);
+int kk_utils_itoa_direct(_IN_ int input, _OU_ char **output);
+
 
 #endif