【修改内容】增加物模型event事件上报功能

【提交人】陈伟灿

src/midware/dm/kk_dm_mng.c

@@ -165,7 +165,8 @@ int dm_mgr_init(void)
 	char device_secret[DEVICE_SECRET_MAXLEN]= {0};
 	int devId = 0;
     memset(ctx, 0, sizeof(dm_mgr_ctx));
-
+	
+	//kk_tsl_api_init();
     /* Create Mutex */
     ctx->mutex = kk_MutexCreate();
     if (ctx->mutex == NULL) {
@@ -253,4 +254,40 @@ int dm_mgr_upstream_thing_property_post(_IN_ int devid, _IN_ char *payload, _IN_
     res = dm_msg_request(&request);
     return res;
 }
+int dm_mgr_upstream_thing_event_post(_IN_ int devid, _IN_ char *identifier, _IN_ int identifier_len, _IN_ char *method,
+                                     _IN_ char *payload, _IN_ int payload_len)
+{
+    int res = 0, service_name_len = 0;
+    char *service_name = NULL;
+    dm_msg_request_t request;
+
+    if (devid < 0 || identifier == NULL || identifier_len <= 0 ||
+        method == NULL || payload == NULL || payload_len <= 0) {
+        return INVALID_PARAMETER;
+    }
+
+    service_name_len = strlen(DM_URI_THING_EVENT_POST) + identifier_len + 1;
+    service_name = malloc(service_name_len);
+    if (service_name == NULL) {
+        return MEMORY_NOT_ENOUGH;
+    }
+    memset(service_name, 0, service_name_len);
+    snprintf(service_name, service_name_len, DM_URI_THING_EVENT_POST, identifier_len, identifier);
+
+    memset(&request, 0, sizeof(dm_msg_request_t));
+    res = _dm_mgr_upstream_request_assemble(iotx_report_id(), devid, DM_URI_SYS_PREFIX, service_name,
+                                            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);
+    free(service_name);
+
+    return res;
+}
 

src/midware/dm/kk_dm_msg.c

@@ -10,6 +10,7 @@
 const char DM_URI_SYS_PREFIX[]                        DM_READ_ONLY = "/sys/%s/%s/";
 const char DM_URI_THING_EVENT_PROPERTY_POST[]		  DM_READ_ONLY = "thing/event/property/post";
 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";
 
 
 

src/midware/dm/kk_dm_msg.h

@@ -57,6 +57,7 @@ typedef enum {
 extern const char DM_URI_SYS_PREFIX[]          DM_READ_ONLY;
 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;
 
 
 #endif

src/midware/tsl_handle/kk_tsl_api.c

@@ -437,12 +437,18 @@ int kk_set_event_output_value(_IN_ int devid, _IN_ char *key, _IN_ int key_len,
     int res = 0;
     void *data = NULL;
     kk_tsl_data_type_e type;
+    dm_mgr_dev_node_t *node = NULL;	
 
     if (devid < 0 || key == NULL || key_len <= 0 || ((value == NULL) && (value_str == NULL))) {
         return INVALID_PARAMETER;
     }
 
-    res = kk_msg_get_event_output_data(devid, key, key_len, &data);
+    res = dm_mgr_search_dev_by_devid(devid, &node);
+    if (res != SUCCESS_RETURN) {
+        return FAIL_RETURN;
+    }
+
+    res = dm_tsl_get_event_output_data(node->dev_shadow, key, key_len, data);
     if (res != SUCCESS_RETURN) {
         return FAIL_RETURN;
     }
@@ -457,23 +463,23 @@ int kk_set_event_output_value(_IN_ int devid, _IN_ char *key, _IN_ int key_len,
         case KK_TSL_DATA_TYPE_ENUM:
         case KK_TSL_DATA_TYPE_BOOL: {
             int value_int = (value == NULL) ? (atoi(value_str)) : (*(int *)value);
-            res = dm_tls_set_event_output_value(devid, key, key_len, &value_int, sizeof(int));
+            res = dm_tls_set_event_output_value(node->dev_shadow, key, key_len, &value_int, sizeof(int));
         }
         break;
         case KK_TSL_DATA_TYPE_FLOAT: {
             float value_float = (value == NULL) ? (atof(value_str)) : (*(float *)value);
-            res = dm_tls_set_event_output_value(devid, key, key_len, &value_float, sizeof(float));
+            res = dm_tls_set_event_output_value(node->dev_shadow, key, key_len, &value_float, sizeof(float));
         }
         break;
         case KK_TSL_DATA_TYPE_DOUBLE: {
             double value_double = (value == NULL) ? (atof(value_str)) : (*(double *)value);
-            res = dm_tls_set_event_output_value(devid, key, key_len, &value_double, sizeof(double));
+            res = dm_tls_set_event_output_value(node->dev_shadow, key, key_len, &value_double, sizeof(double));
         }
         break;
         case KK_TSL_DATA_TYPE_TEXT:
         case KK_TSL_DATA_TYPE_DATE: {
             char *value_string = (value == NULL) ? (value_str) : (value);
-            res = dm_tls_set_event_output_value(devid, key, key_len, value_string, strlen(value_string));
+            res = dm_tls_set_event_output_value(node->dev_shadow, key, key_len, value_string, strlen(value_string));
         }
         break;
         default: {
@@ -590,7 +596,7 @@ int kk_tsl_set_value(kk_tsl_set_t set, int devId, const char *identifier,
                                        const void *value,
                                        const char *value_str)
 {
-    int res = 0, devid = 0;
+    int res = 0;
     kk_tsl_api_ctx_t *kk_tsl_api_ctx = _kk_tsl_api_get_ctx();
 
     if ( identifier == NULL || (value == NULL && value_str == NULL)) {
@@ -601,17 +607,17 @@ int kk_tsl_set_value(kk_tsl_set_t set, int devId, const char *identifier,
     _kk_tsl_api_lock();
     switch (set) {
         case kk_tsl_set_property_value: {
-            res = kk_msg_set_property_value(devid, (char *)identifier, strlen(identifier), (void *)value,
+            res = kk_msg_set_property_value(devId, (char *)identifier, strlen(identifier), (void *)value,
                     strlen(value));
         }
         break;
-        case kk_tsl_set_event_output_value: {
-            res = kk_set_event_output_value(devid, (char *)identifier, strlen(identifier), (void *)value,
+        case kk_tsl_set_event_output_value: {		
+            res = kk_set_event_output_value(devId, (char *)identifier, strlen(identifier), (void *)value,
                     (char *)value_str);
         }
         break;
         case kk_tsl_set_service_output_value: {
-            res = kk_set_service_output_value(devid, (char *)identifier, strlen(identifier), (void *)value,
+            res = kk_set_service_output_value(devId, (char *)identifier, strlen(identifier), (void *)value,
                     (char *)value_str);
         }
         break;
@@ -713,12 +719,23 @@ int kk_tsl_service_property_set(const char *topic, const char *payload, unsigned
     memcpy(response.product_key, product_key, strlen(product_key));
     memcpy(response.device_name, device_name, strlen(device_name));
     response.code = (res == SUCCESS_RETURN) ? (IOTX_DM_ERR_CODE_SUCCESS) : (IOTX_DM_ERR_CODE_REQUEST_ERROR);
-
 	dm_msg_response(&request, &response, "{}", strlen("{}"), NULL);
 
-
-	kk_tsl_post_property(devid,NULL);
-
+#if 0
+#define EVENT_ERROR_IDENTIFIER "Error"
+#define EVENT_ERROR_OUTPUT_INFO_IDENTIFIER "ErrorCode"
+
+	//kk_tsl_post_property(devid,NULL);
+    char event_output_identifier[64];
+    snprintf(event_output_identifier, sizeof(event_output_identifier), "%s.%s",
+             EVENT_ERROR_IDENTIFIER, EVENT_ERROR_OUTPUT_INFO_IDENTIFIER);
+
+    int errorCode = 0;
+	printf("[%s][%d]\n",__FUNCTION__,__LINE__);
+    kk_tsl_set_value(kk_tsl_set_event_output_value, devid,
+                      event_output_identifier, &errorCode, NULL);
+	kk_tsl_post_event(devid,EVENT_ERROR_IDENTIFIER);
+#endif
     return SUCCESS_RETURN;
 }
 
@@ -910,7 +927,7 @@ int kk_tsl_post_property(int devId, const char *property_identifier)
     _kk_tsl_api_lock();
     res = kk_tsl_post_property_start(devId, &property_handle);
     if (res != SUCCESS_RETURN) {
-        _kk_tsl_api_lock();
+        _kk_tsl_api_unlock();
         return FAIL_RETURN;
     }
 
@@ -918,17 +935,179 @@ int kk_tsl_post_property(int devId, const char *property_identifier)
     res = kk_tsl_post_property_add(property_handle, (char *)property_identifier, property_identifier_len);
     if (res != SUCCESS_RETURN) {
         kk_tsl_post_property_end(&property_handle);
-        _kk_tsl_api_lock();
+        _kk_tsl_api_unlock();
         return FAIL_RETURN;
     }
 
     res = kk_tsl_post_property_end(&property_handle);
     if (res < SUCCESS_RETURN) {
-        _kk_tsl_api_lock();
+        _kk_tsl_api_unlock();
+        return FAIL_RETURN;
+    }
+    _kk_tsl_api_unlock();
+
+    return SUCCESS_RETURN;
+}
+static int kk_tsl_event_output(_IN_ int devid, _IN_ char *identifier, _IN_ int identifier_len,
+        _IN_ lite_cjson_item_t *lite)
+{
+    int res = 0;
+    dm_mgr_dev_node_t *node = NULL;
+
+    if (devid < 0 || identifier == NULL || identifier_len <= 0 || lite == NULL || lite->type != cJSON_Object) {
+        return INVALID_PARAMETER;
+    }
+
+    res = dm_mgr_search_dev_by_devid(devid, &node);
+    if (res != SUCCESS_RETURN) {
+        return FAIL_RETURN;
+    }
+
+    res = kk_tsl_assemble_event_output(node->dev_shadow, identifier, identifier_len, lite);
+    if (res != SUCCESS_RETURN) {
+        return FAIL_RETURN;
+    }
+
+    return SUCCESS_RETURN;
+}
+static int _kk_tsl_get_event_by_identifier(_IN_ kk_tsl_t *shadow, _IN_ char *identifier, _OU_ void **event)
+{
+    int index = 0;
+    kk_tsl_event_t *search_event = NULL;
+
+    if (shadow == NULL || identifier == NULL ||
+        event == NULL || *event != NULL) {
+        return INVALID_PARAMETER;
+    }
+
+    for (index = 0; index < shadow->event_number; index++) {
+        search_event = shadow->events + index;
+        if ((strlen(search_event->identifier) == strlen(identifier)) &&
+            (memcmp(search_event->identifier, identifier, strlen(identifier)) == 0)) {
+            *event = (void *)search_event;
+            return SUCCESS_RETURN;
+        }
+    }
+
+    return FAIL_RETURN;
+}
+
+int kk_tsl_get_event_by_identifier(_IN_ int devid, _IN_ char *identifier, _OU_ void **event)
+{
+    int res = 0;
+    dm_mgr_dev_node_t *node = NULL;
+
+    if (devid < 0 || identifier == NULL || event == NULL || *event != NULL) {
+        return INVALID_PARAMETER;
+    }
+
+    res = dm_mgr_search_dev_by_devid(devid, &node);
+    if (res != SUCCESS_RETURN) {
+        return FAIL_RETURN;
+    }
+
+    return _kk_tsl_get_event_by_identifier(node->dev_shadow, identifier, event);
+}
+int kk_tsl_get_event_method(_IN_ void *event, _OU_ char **method)
+{
+    int event_method_len = 0;
+    const char *post_identifier = "post";
+    const char *property_identifier = "property";
+    const char *identifier = NULL;
+    const char *event_method_fmt = "thing.event.%s.post";
+    kk_tsl_event_t *event_item = (kk_tsl_event_t *)event;
+
+    if (event_item == NULL || method == NULL || *method != NULL) {
+        return INVALID_PARAMETER;
+    }
+
+    /* God Damn It Special Case! */
+    if ((strlen(event_item->identifier) == strlen(post_identifier)) &&
+        (memcmp(event_item->identifier, post_identifier, strlen(post_identifier)) == 0)) {
+        identifier = property_identifier;
+    } else {
+        identifier = (const char *)event_item->identifier;
+    }
+
+    event_method_len = (strlen(event_method_fmt) + strlen(identifier) + 1);
+    *method = malloc(event_method_len);
+    if (*method == NULL) {
+        return MEMORY_NOT_ENOUGH;
+    }
+    memset(*method, 0, event_method_len);
+    snprintf(*method, event_method_len, event_method_fmt, identifier);
+
+    return SUCCESS_RETURN;
+}
+
+static int _kk_tsl_post_event(_IN_ int devid, _IN_ char *identifier, _IN_ int identifier_len)
+{
+    int res = 0;
+    void *event = NULL;
+    lite_cjson_item_t *lite = NULL;
+    char *method = NULL, *payload = NULL;
+
+    if (devid < 0 || identifier == NULL || identifier_len <= 0) {
+        return INVALID_PARAMETER;
+    }
+
+    lite = lite_cjson_create_object();
+    if (lite == NULL) {
+        return MEMORY_NOT_ENOUGH;
+    }
+
+    res = kk_tsl_event_output(devid, identifier, identifier_len, lite);
+    if (res != SUCCESS_RETURN) {
+        lite_cjson_delete(lite);
+        return FAIL_RETURN;
+    }
+
+    payload = lite_cjson_print_unformatted(lite);
+    lite_cjson_delete(lite);
+    if (payload == NULL) {
+        return MEMORY_NOT_ENOUGH;
+    }
+
+    printf("\nCurrent Event Post Payload, Length: %d, Payload: %s\n", strlen(payload), payload);
+
+    res = kk_tsl_get_event_by_identifier(devid, identifier, &event);
+    if (res != SUCCESS_RETURN) {
+        free(payload);
         return FAIL_RETURN;
     }
+
+    res = kk_tsl_get_event_method(event, &method);
+    if (res != SUCCESS_RETURN) {
+        free(payload);
+        return FAIL_RETURN;
+    }
+
+    printf("Current Event Method: %s", method);
+
+    res = dm_mgr_upstream_thing_event_post(devid, identifier, identifier_len, method, payload, strlen(payload));
+
+    free(payload);
+    free(method);
+    return res;
+}
+
+int kk_tsl_post_event(int devId, const char *event_identifier)
+{
+    int res = 0, msgid = 0, post_event_reply = 0;
+    kk_tsl_api_ctx_t *kk_tsl_api_ctx = _kk_tsl_api_get_ctx();
+
+    if (event_identifier == NULL) {
+        return FAIL_RETURN;
+    }
+
     _kk_tsl_api_lock();
 
+    res = _kk_tsl_post_event(devId, (char *)event_identifier, strlen((char *)event_identifier));
+    if (res < SUCCESS_RETURN) {
+        _kk_tsl_api_unlock();
+        return FAIL_RETURN;
+    }
+    _kk_tsl_api_unlock();
     return SUCCESS_RETURN;
 }
 

src/midware/tsl_handle/kk_tsl_func.c

@@ -748,13 +748,14 @@ int dm_tsl_get_event_output_data(_IN_ kk_tsl_t *shadow, _IN_ char *key, _IN_ int
     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", key_len, key);
+    printf("Key: %.*s\n", key_len, key);
 
     res = _kk_tsl_event_search(shadow, key, offset, &event);
     if (res != SUCCESS_RETURN) {

src/midware/tsl_handle/kk_tsl_parse.c

@@ -1366,7 +1366,6 @@ static int _kk_tsl_data_insert_json_item(_IN_ kk_tsl_data_t *data, _IN_ lite_cjs
 {
     int res = 0;
     lite_cjson_item_t *data_object = NULL;
-	printf("--------------------------->[%s][%d]data->i:%s\n",__FUNCTION__,__LINE__,data->identifier,data->data_value);
     if (data == NULL || lite == NULL) {
         return INVALID_PARAMETER;
     }
@@ -1378,7 +1377,6 @@ static int _kk_tsl_data_insert_json_item(_IN_ kk_tsl_data_t *data, _IN_ lite_cjs
         }
     }
 
-	printf("--------------------------->[%s][%d]data->type:%d\n",__FUNCTION__,__LINE__,data->data_value.type);
     switch (data->data_value.type) {
         case KK_TSL_DATA_TYPE_INT:
         case KK_TSL_DATA_TYPE_BOOL:
@@ -1488,7 +1486,7 @@ int kk_tsl_assemble_property(_IN_ kk_tsl_t *shadow, _IN_ char *identifier, _IN_
     }
 
     if (index == shadow->property_number) {
-        printf("Property Not Found: %.*s", identifier_len, identifier);
+        printf("Property Not Found: %.*s\n", identifier_len, identifier);
         return FAIL_RETURN;
     }
 
@@ -1499,6 +1497,43 @@ int kk_tsl_assemble_property(_IN_ kk_tsl_t *shadow, _IN_ char *identifier, _IN_
 
     return SUCCESS_RETURN;
 }
+int kk_tsl_assemble_event_output(_IN_ kk_tsl_t *shadow, _IN_ char *identifier, _IN_ int identifier_len,
+                                 _IN_ lite_cjson_item_t *lite)
+{
+    int res = 0, index = 0;
+    kk_tsl_data_t *event_outputdata = NULL;
+    kk_tsl_event_t *event = NULL;
+
+    if (shadow == NULL || identifier == NULL || identifier_len <= 0 || lite == NULL || lite->type != cJSON_Object) {
+        return INVALID_PARAMETER;
+    }
+
+    for (index = 0; index < shadow->event_number; index++) {
+        event = shadow->events + index;
+        if ((strlen(event->identifier) == identifier_len) &&
+            (memcmp(event->identifier, identifier, identifier_len) == 0)) {
+            /* dm_log_debug("Event Found: %.*s",identifier_len,identifier); */
+            break;
+        }
+    }
+
+    if (index == shadow->event_number) {
+        printf("Event Not Found: %.*s\n", identifier_len, identifier);
+        return FAIL_RETURN;
+    }
+
+    for (index = 0; index < event->output_data_number; index++) {
+        event_outputdata = event->output_datas + index;
+
+        res = _kk_tsl_data_insert_json_item(event_outputdata, lite);
+        if (res != SUCCESS_RETURN) {
+            return FAIL_RETURN;
+        }
+    }
+
+    return SUCCESS_RETURN;
+}
+
 #if 0
 
 int main(int argc, char* argv[])