gengxin

diff --git a/2.sdk/project/Z5_HA_K18/product/craneg_modem/config/watch/lv_watch_conf_CUSTOM.h b/2.sdk/project/Z5_HA_K18/product/craneg_modem/config/watch/lv_watch_conf_CUSTOM.h
index 516cc24..f204c09 100644 (file)
--- a/2.sdk/project/Z5_HA_K18/product/craneg_modem/config/watch/lv_watch_conf_CUSTOM.h
+++ b/2.sdk/project/Z5_HA_K18/product/craneg_modem/config/watch/lv_watch_conf_CUSTOM.h
@@ -184,6 +184,7 @@
 #define __MMI_HEALTH_MEASURE_TEMPERATURE_SUPPORT__
 
 //#define __MMI_APP_QRCODE_MENU_SUPPORT__
+//#define __MMI_APP_QRCODE_FROM_SERVER_SUPPORT__
 #define __MMI_APP_QRCODE_AND_DEVICE_QRCODE_IN_ONE_SUPPORT__
 
 #define __MMI_ZHSX_SUPPORT_NO_SIM_POWER_OFF__
@@ -207,6 +208,7 @@
 //#define __MMI_CUSTOM_HENGAI_SLEEP__
 
 #define __MMI_CUSTOM_HENGAI_HEALTH__
+#define __MMI_CUSTOM_HENGAI_HEALTH_UPLOAD_USE_TCP__
 
 #define __MMI_CUSTOM_HENGAI_TCMS__
 

diff --git a/2.sdk/sdk/gui/lv_drivers/indev/FR8012HAQ/fr8012haq.c b/2.sdk/sdk/gui/lv_drivers/indev/FR8012HAQ/fr8012haq.c
index e8ac751..0906cdc 100644 (file)
--- a/2.sdk/sdk/gui/lv_drivers/indev/FR8012HAQ/fr8012haq.c
+++ b/2.sdk/sdk/gui/lv_drivers/indev/FR8012HAQ/fr8012haq.c
@@ -1159,10 +1159,12 @@ void fr8012haq_measure_temp_start(void)
 }
 void fr8012haq_measure_wear_start(void)
 {
+#if 0
     sys_pm_wakeup_no_lcd();
     FR8012HAQ_run_mode = WEAR_MODE     ;
     FR8012HAQ_LOG("fr8012haq_measure_wear_start :FR8012HAQ_run_mode:%d!!!!!!!!\n",FR8012HAQ_run_mode);
     sensor_task_send_message(FR8012HAQ_ID,SENSOR_MSG_START);
+#endif
 }
 void FR8012HAQ_restart(void)
 {
@@ -1333,11 +1335,20 @@ void FR8012HAQ_result_set_wear_status(unsigned char wear_status)
     if(wear_status == 0 && s_FR8012HAQ_wear_status == 1)//佩戴变未佩戴
     {
         //fr8012haq_measure_wear_start();//开始佩戴模式
+
+               //mmi_hsensor_close();
+               //printf("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__);
     }else if(wear_status == 1 && s_FR8012HAQ_wear_status == 0)//未佩戴变佩戴
     {
         //s_FR8012HAQ_wear_status =1;
         //fr8012haq_timer_cfg(TRUE);//恢复定时器
+
+//     #ifdef __MMI_CUSTOM_HENGAI_TCMS__
+//             mmi_hengai_tcms_action();
+//     #endif
+//     printf("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__);
     }
+//     printf("[@CHENG_DEBUG][%s][%d]: %d\n", __FUNCTION__, __LINE__, wear_status);
 
        if(wear_status != 1)
     {
@@ -1350,6 +1361,7 @@ void FR8012HAQ_result_set_wear_status(unsigned char wear_status)
 }
 unsigned char FR8012HAQ_result_get_wear_status(void)
 {
+       return 1;
        
        return s_FR8012HAQ_wear_status ;
 }

diff --git a/2.sdk/sdk/gui/lv_watch/lv_apps/custom_function/heng_ai_blood_pressure.c b/2.sdk/sdk/gui/lv_watch/lv_apps/custom_function/heng_ai_blood_pressure.c
index c468906..7dbed3d 100644 (file)
--- a/2.sdk/sdk/gui/lv_watch/lv_apps/custom_function/heng_ai_blood_pressure.c
+++ b/2.sdk/sdk/gui/lv_watch/lv_apps/custom_function/heng_ai_blood_pressure.c
@@ -95,7 +95,11 @@ void mmi_hengai_bp_back_measure_finish(void)
        //mmi_hengai_bp_measuring_flag_set(false);
        if(true == mmi_protocol_check_state_before_send_action())
        {
+       #ifdef __MMI_CUSTOM_HENGAI_HEALTH_UPLOAD_USE_TCP__
+               mmi_hengai_tcp_bp_measure_raw_data_send();
+       #else
                mmi_hengai_bp_measure_raw_data_send();
+       #endif
        }
 }
 
@@ -435,7 +439,11 @@ void mmi_hengai_bp_measure_data_send_task_cb(lv_task_t * task)
 {
        if(true == mmi_protocol_check_state_before_send_action())
        {
+       #ifdef __MMI_CUSTOM_HENGAI_HEALTH_UPLOAD_USE_TCP__
+               mmi_hengai_tcp_bp_measure_raw_data_send();
+       #else
                mmi_hengai_bp_measure_raw_data_send();
+       #endif
        }
        else
        {
@@ -952,7 +960,11 @@ void mmi_hengai_bp_calibrate_second_data_send_task_cb(lv_task_t * task)
 {
        if(true == mmi_protocol_check_state_before_send_action())
        {
+       #ifdef __MMI_CUSTOM_HENGAI_HEALTH_UPLOAD_USE_TCP__
+               mmi_hengai_tcp_bp_calibrate_raw_data_send(2, s_bp_value_high, s_bp_value_low);
+       #else
                mmi_hengai_bp_calibrate_raw_data_send(2, s_bp_value_high, s_bp_value_low);
+       #endif
        }
        else
        {
@@ -1010,7 +1022,11 @@ void mmi_hengai_bp_calibrate_end_input_event_cb(lv_obj_t * obj, lv_event_t e)
        {
                if(true == mmi_protocol_check_state_before_send_action())
                {
+               #ifdef __MMI_CUSTOM_HENGAI_HEALTH_UPLOAD_USE_TCP__
+                       mmi_hengai_tcp_bp_calibrate_raw_data_send(1, s_bp_value_high, s_bp_value_low);
+               #else
                        mmi_hengai_bp_calibrate_raw_data_send(1, s_bp_value_high, s_bp_value_low);
+               #endif
                        // once again
                        mmi_heng_ai_bp_calibrate_start_screen();
                }

diff --git a/2.sdk/sdk/gui/lv_watch/lv_apps/custom_function/heng_ai_http_protocol.c b/2.sdk/sdk/gui/lv_watch/lv_apps/custom_function/heng_ai_http_protocol.c
index c686bd5..38300bc 100644 (file)
--- a/2.sdk/sdk/gui/lv_watch/lv_apps/custom_function/heng_ai_http_protocol.c
+++ b/2.sdk/sdk/gui/lv_watch/lv_apps/custom_function/heng_ai_http_protocol.c
@@ -10,6 +10,999 @@
 #include "hal/dm/libhttpclient.h"
 
 
+#ifdef __MMI_CUSTOM_HENGAI_HEALTH_UPLOAD_USE_TCP__
+
+static HENGAI_HEALTH_SEND_TYPE_ENUM s_hengai_bp_send_code = HENGAI_HEALTH_SEND_NONE; //
+
+// measure data
+void mmi_hengai_tcp_bp_measure_raw_data_send(void)
+{
+       HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__);
+
+#if 0
+       char * data_ptr = NULL;
+       uint32_t data_len = 0;
+       char * encode_str = NULL;
+       uint32_t encode_len = 0;
+       char * encode_header_str = NULL;
+       uint32_t encode_header_len = 0;
+       uint32_t output_len = 0;
+       uint32_t output_header_len = 0;
+       int temp_len = 0;
+       int json_data_len = 512; // MMI_HENGAI_BP_RAW_DATA_LEN * 11 + 256;
+       char * json_data = NULL;
+
+       // json body
+       json_data = lv_mem_alloc(json_data_len);
+       if(NULL == json_data)
+       {
+               HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: memory alloc failed\n", __FUNCTION__, __LINE__);
+               goto FREE_AND_EXIT;
+       }
+       _lv_memset_00(json_data, json_data_len);
+
+       temp_len = 0;
+       temp_len += sprintf(json_data + temp_len, "{\"app_key\":\"%s\",", HENGAI_HTTP_POST_APP_KEY);
+
+       char imei[16 + 1] = {0};
+       app_adp_get_imei_req(imei);
+       temp_len += sprintf(json_data + temp_len, "\"mac\":\"%s\",", imei);
+       
+       temp_len += sprintf(json_data + temp_len, "\"begin_time\":\"%s\",", "2024-03-27 10:57:16");
+
+       temp_len += sprintf(json_data + temp_len, "\"end_time\":\"%s\",", "2024-03-27 10:58:16");
+       
+       temp_len += sprintf(json_data + temp_len, "\"pulse_wave\":[10,11,12],");
+       
+       temp_len += sprintf(json_data + temp_len, "\"sample_rate\":%d}", MMI_HENGAI_BP_RAW_DATA_SAMPLE_RATE);
+
+       HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: %d\n", __FUNCTION__, __LINE__, temp_len);
+       HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%d]: %s\n", __LINE__, json_data);
+       HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%d]: %s\n", __LINE__, json_data + 90);
+       HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%d]: %s\n", __LINE__, json_data + 180);
+       HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%d]: %s\n", __LINE__, json_data + 270);
+       HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%d]: %s\n", __LINE__, json_data + 360);
+       
+
+       // base64 body
+       encode_len = temp_len * 3 / 2;
+       encode_str = lv_mem_alloc(encode_len);
+       if(NULL == encode_str)
+       {
+               HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: memory alloc failed\n", __FUNCTION__, __LINE__);
+               goto FREE_AND_EXIT;
+       }
+       _lv_memset_00(encode_str, encode_len);
+       if(0 != mbedtls_base64_encode(encode_str, encode_len, &output_len, json_data, temp_len))
+       {
+               HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: base64 encode failed\n", __FUNCTION__, __LINE__);
+               goto FREE_AND_EXIT;
+       }
+       HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: %d\n", __FUNCTION__, __LINE__, output_len);
+       HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%d]: %s\n", __LINE__, encode_str);
+       HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%d]: %s\n", __LINE__, encode_str + 90);
+       HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%d]: %s\n", __LINE__, encode_str + 180);
+       HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%d]: %s\n", __LINE__, encode_str + 270);
+       HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%d]: %s\n", __LINE__, encode_str + 360);
+       
+
+       // json header
+       _lv_memset_00(json_data, json_data_len);
+
+       temp_len = 0;
+       temp_len += sprintf(json_data + temp_len, "{\"headers\":[");
+
+       temp_len += sprintf(json_data + temp_len, "{\"key\":\"token\",");
+
+       char * token = mmi_hengai_health_token_get();
+       temp_len += sprintf(json_data + temp_len, "\"value\":\"%s\"}", token);
+
+       temp_len += sprintf(json_data + temp_len, "]}");
+       
+       HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: %d\n", __FUNCTION__, __LINE__, temp_len);
+       HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%d]: %s\n", __LINE__, json_data);
+       HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%d]: %s\n", __LINE__, json_data + 90);
+       HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%d]: %s\n", __LINE__, json_data + 180);
+       HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%d]: %s\n", __LINE__, json_data + 270);
+       HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%d]: %s\n", __LINE__, json_data + 360);
+       
+
+       // base64 header
+       encode_header_len = temp_len * 3 / 2;
+       encode_header_str = lv_mem_alloc(encode_header_len);
+       if(NULL == encode_header_str)
+       {
+               HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: memory alloc failed\n", __FUNCTION__, __LINE__);
+               goto FREE_AND_EXIT;
+       }
+       _lv_memset_00(encode_header_str, encode_header_len);
+       if(0 != mbedtls_base64_encode(encode_header_str, encode_header_len, &output_header_len, json_data, temp_len))
+       {
+               HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: base64 encode failed\n", __FUNCTION__, __LINE__);
+               goto FREE_AND_EXIT;
+       }       
+       HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: %d\n", __FUNCTION__, __LINE__, output_header_len);
+       HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%d]: %s\n", __LINE__, encode_header_str);
+       HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%d]: %s\n", __LINE__, encode_header_str + 90);
+       HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%d]: %s\n", __LINE__, encode_header_str + 180);
+       HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%d]: %s\n", __LINE__, encode_header_str + 270);
+       HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%d]: %s\n", __LINE__, encode_header_str + 360);
+       
+       
+       // content
+       data_len = output_len + output_header_len + 128;
+       data_ptr = lv_mem_alloc(data_len);
+       if(NULL == data_ptr)
+       {
+               HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: memory alloc failed\n", __FUNCTION__, __LINE__);
+               goto FREE_AND_EXIT;
+       }
+       _lv_memset_00(data_ptr, data_len);
+       
+#if 1
+       sprintf(data_ptr, ",POST,%s%s,%s,%s", HENGAI_HTTP_POST_URL_COMMON_PREFIX, "/health/bp/measurement", encode_header_str, encode_str);
+#else
+       sprintf(data_ptr, "POST,%s%s,%s,%s", HENGAI_HTTP_POST_URL_COMMON_PREFIX, "/health/bp/measurement", encode_header_str, encode_str);
+#endif
+       data_len = strlen(data_ptr);
+       HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: %d\n", __FUNCTION__, __LINE__, data_len);
+       HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%d]: %s\n", __LINE__, data_ptr);
+       HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%d]: %s\n", __LINE__, data_ptr + 90);
+       HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%d]: %s\n", __LINE__, data_ptr + 180);
+       HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%d]: %s\n", __LINE__, data_ptr + 270);
+       HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%d]: %s\n", __LINE__, data_ptr + 360);
+       
+
+       s_hengai_bp_send_code = HENGAI_HEALTH_SEND_MEASURE_DATA;
+       mmi_protocol_fzd_action_tcp_http(data_ptr, data_len);
+
+#else
+
+       char * data_ptr = NULL;
+       uint32_t data_len = 0;
+       char * encode_str = NULL;
+       uint32_t encode_len = 0;
+       char * encode_header_str = NULL;
+       uint32_t encode_header_len = 0;
+       uint32_t output_len = 0;
+       uint32_t output_header_len = 0;
+       int temp_len = 0;
+       int json_data_len = MMI_HENGAI_BP_RAW_DATA_LEN * 11 + 256;
+       char * json_data = NULL;
+
+       // json body
+       json_data = lv_mem_alloc(json_data_len);
+       if(NULL == json_data)
+       {
+               HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: memory alloc failed\n", __FUNCTION__, __LINE__);
+               goto FREE_AND_EXIT;
+       }
+       _lv_memset_00(json_data, json_data_len);
+
+       temp_len = 0;
+       temp_len += sprintf(json_data + temp_len, "{\"app_key\":\"%s\",", HENGAI_HTTP_POST_APP_KEY);
+
+       char imei[16 + 1] = {0};
+       app_adp_get_imei_req(imei);
+       temp_len += sprintf(json_data + temp_len, "\"mac\":\"%s\",", imei);
+       
+       char * begin_time_str = mmi_hengai_bp_measure_action_time_string_get(1);
+       temp_len += sprintf(json_data + temp_len, "\"begin_time\":\"%s\",", begin_time_str);
+
+       char * end_time_str = mmi_hengai_bp_measure_action_time_string_get(0);
+       temp_len += sprintf(json_data + temp_len, "\"end_time\":\"%s\",", end_time_str);
+       
+       uint16_t i = 0;
+       int * temp_int_ptr = mmi_hengai_bp_raw_data_ptr_get();
+       int temp_int_len = mmi_hengai_bp_raw_data_len_get();
+       temp_len += sprintf(json_data + temp_len, "\"pulse_wave\":[");
+       for(i = 0; i < temp_int_len; i++)
+       {
+               if(i == (temp_int_len - 1))
+               {
+                       temp_len += sprintf(json_data + temp_len, "%d],", temp_int_ptr[i]);
+               }
+               else
+               {
+                       temp_len += sprintf(json_data + temp_len, "%d,", temp_int_ptr[i]);
+               }
+       }
+       
+       temp_len += sprintf(json_data + temp_len, "\"sample_rate\":%d}", MMI_HENGAI_BP_RAW_DATA_SAMPLE_RATE);
+
+       HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: %d\n", __FUNCTION__, __LINE__, temp_len);
+
+       // base64 body
+       encode_len = temp_len * 3 / 2;
+       encode_str = lv_mem_alloc(encode_len);
+       if(NULL == encode_str)
+       {
+               HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: memory alloc failed\n", __FUNCTION__, __LINE__);
+               goto FREE_AND_EXIT;
+       }
+       _lv_memset_00(encode_str, encode_len);
+       if(0 != mbedtls_base64_encode(encode_str, encode_len, &output_len, json_data, temp_len))
+       {
+               HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: base64 encode failed\n", __FUNCTION__, __LINE__);
+               goto FREE_AND_EXIT;
+       }
+
+       // json header
+       _lv_memset_00(json_data, json_data_len);
+
+       temp_len = 0;
+       temp_len += sprintf(json_data + temp_len, "{\"headers\":[");
+
+       temp_len += sprintf(json_data + temp_len, "{\"key\":\"token\",");
+
+       char * token = mmi_hengai_health_token_get();
+       temp_len += sprintf(json_data + temp_len, "\"value\":\"%s\"}", token);
+
+       temp_len += sprintf(json_data + temp_len, "]}");
+       
+       HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: %d\n", __FUNCTION__, __LINE__, temp_len);
+
+       // base64 header
+       encode_header_len = temp_len * 3 / 2;
+       encode_header_str = lv_mem_alloc(encode_header_len);
+       if(NULL == encode_header_str)
+       {
+               HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: memory alloc failed\n", __FUNCTION__, __LINE__);
+               goto FREE_AND_EXIT;
+       }
+       _lv_memset_00(encode_header_str, encode_header_len);
+       if(0 != mbedtls_base64_encode(encode_header_str, encode_header_len, &output_header_len, json_data, temp_len))
+       {
+               HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: base64 encode failed\n", __FUNCTION__, __LINE__);
+               goto FREE_AND_EXIT;
+       }       
+       
+       // content
+       data_len = output_len + output_header_len + 128;
+       data_ptr = lv_mem_alloc(data_len);
+       if(NULL == data_ptr)
+       {
+               HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: memory alloc failed\n", __FUNCTION__, __LINE__);
+               goto FREE_AND_EXIT;
+       }
+       _lv_memset_00(data_ptr, data_len);
+       
+       #if 1
+       sprintf(data_ptr, ",POST,%s%s,%s,%s", HENGAI_HTTP_POST_URL_COMMON_PREFIX, "/health/bp/measurement", encode_header_str, encode_str);
+       #else
+       sprintf(data_ptr, "POST,%s%s,%s,%s", HENGAI_HTTP_POST_URL_COMMON_PREFIX, "/health/bp/measurement", encode_header_str, encode_str);
+       #endif
+       data_len = strlen(data_ptr);
+       HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: %d\n", __FUNCTION__, __LINE__, data_len);
+
+       s_hengai_bp_send_code = HENGAI_HEALTH_SEND_MEASURE_DATA;
+       mmi_protocol_fzd_action_tcp_http(data_ptr, data_len);
+#endif
+       
+FREE_AND_EXIT:
+       if(NULL != json_data)
+       {
+               lv_mem_free(json_data);
+               json_data = NULL;
+       }
+       if(NULL != encode_str)
+       {
+               lv_mem_free(encode_str);
+               encode_str = NULL;
+       }
+       if(NULL != encode_header_str)
+       {
+               lv_mem_free(encode_header_str);
+               encode_header_str = NULL;
+       }
+       if(NULL != data_ptr)
+       {
+               lv_mem_free(data_ptr);
+               data_ptr = NULL;
+       }
+}
+
+// calibrate mode
+void mmi_hengai_tcp_bp_calibrate_model_send(void)
+{
+       char * data_ptr = NULL;
+       uint32_t data_len = 0;
+       char * encode_str = NULL;
+       uint32_t encode_len = 0;
+       char * encode_header_str = NULL;
+       uint32_t encode_header_len = 0;
+       uint32_t output_len = 0;
+       uint32_t output_header_len = 0;
+       int temp_len = 0;
+       int json_data_len = 256;
+       char * json_data = NULL;
+
+       // json body
+       json_data = lv_mem_alloc(json_data_len);
+       if(NULL == json_data)
+       {
+               HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: memory alloc failed\n", __FUNCTION__, __LINE__);
+               goto FREE_AND_EXIT;
+       }
+       _lv_memset_00(json_data, json_data_len);
+
+       temp_len = 0;
+       temp_len += sprintf(json_data + temp_len, "{\"app_key\":\"%s\",", HENGAI_HTTP_POST_APP_KEY);
+       
+       char imei[16 + 1] = {0};
+       app_adp_get_imei_req(imei);
+       temp_len += sprintf(json_data + temp_len, "\"mac\":\"%s\"}", imei);
+
+       HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: %d\n", __FUNCTION__, __LINE__, temp_len);
+
+       // base64 body
+       encode_len = temp_len * 3 / 2;
+       encode_str = lv_mem_alloc(encode_len);
+       if(NULL == encode_str)
+       {
+               HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: memory alloc failed\n", __FUNCTION__, __LINE__);
+               goto FREE_AND_EXIT;
+       }
+       _lv_memset_00(encode_str, encode_len);
+       if(0 != mbedtls_base64_encode(encode_str, encode_len, &output_len, json_data, temp_len))
+       {
+               HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: base64 encode failed\n", __FUNCTION__, __LINE__);
+               goto FREE_AND_EXIT;
+       }
+
+       // json header
+       _lv_memset_00(json_data, json_data_len);
+
+       temp_len = 0;
+       temp_len += sprintf(json_data + temp_len, "{\"headers\":[");
+
+       temp_len += sprintf(json_data + temp_len, "{\"key\":\"token\",");
+
+       char * token = mmi_hengai_health_token_get();
+       temp_len += sprintf(json_data + temp_len, "\"value\":\"%s\"}", token);
+
+       temp_len += sprintf(json_data + temp_len, "]}");
+       
+       HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: %d\n", __FUNCTION__, __LINE__, temp_len);
+
+       // base64 header
+       encode_header_len = temp_len * 3 / 2;
+       encode_header_str = lv_mem_alloc(encode_header_len);
+       if(NULL == encode_header_str)
+       {
+               HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: memory alloc failed\n", __FUNCTION__, __LINE__);
+               goto FREE_AND_EXIT;
+       }
+       _lv_memset_00(encode_header_str, encode_header_len);
+       if(0 != mbedtls_base64_encode(encode_header_str, encode_header_len, &output_header_len, json_data, temp_len))
+       {
+               HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: base64 encode failed\n", __FUNCTION__, __LINE__);
+               goto FREE_AND_EXIT;
+       }       
+       
+       // content
+       data_len = output_len + output_header_len + 128;
+       data_ptr = lv_mem_alloc(data_len);
+       if(NULL == data_ptr)
+       {
+               HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: memory alloc failed\n", __FUNCTION__, __LINE__);
+               goto FREE_AND_EXIT;
+       }
+       _lv_memset_00(data_ptr, data_len);
+       
+#if 1
+       sprintf(data_ptr, ",POST,%s%s,%s,%s", HENGAI_HTTP_POST_URL_COMMON_PREFIX, "/health/bp/model", encode_header_str, encode_str);
+#else
+       sprintf(data_ptr, "POST,%s%s,%s,%s", HENGAI_HTTP_POST_URL_COMMON_PREFIX, "/health/bp/model", encode_header_str, encode_str);
+#endif
+       data_len = strlen(data_ptr);
+
+       s_hengai_bp_send_code = HENGAI_HEALTH_SEND_CALIBRATE_MODEL;
+       mmi_protocol_fzd_action_tcp_http(data_ptr, data_len);
+       
+FREE_AND_EXIT:
+       if(NULL != json_data)
+       {
+               lv_mem_free(json_data);
+               json_data = NULL;
+       }
+       if(NULL != encode_str)
+       {
+               lv_mem_free(encode_str);
+               encode_str = NULL;
+       }
+       if(NULL != encode_header_str)
+       {
+               lv_mem_free(encode_header_str);
+               encode_header_str = NULL;
+       }
+       if(NULL != data_ptr)
+       {
+               lv_mem_free(data_ptr);
+               data_ptr = NULL;
+       }
+}
+
+void mmi_hengai_tcp_bp_calibrate_raw_data_send(uint8_t calibrate_times, uint16_t bp_value_high, uint16_t bp_value_low)
+{
+       char * data_ptr = NULL;
+       uint32_t data_len = 0;
+       char * encode_str = NULL;
+       uint32_t encode_len = 0;
+       char * encode_header_str = NULL;
+       uint32_t encode_header_len = 0;
+       uint32_t output_len = 0;
+       uint32_t output_header_len = 0;
+       int temp_len = 0;
+       int json_data_len = MMI_HENGAI_BP_RAW_DATA_LEN * 11 + 256;
+       char * json_data = NULL;
+
+       // json body
+       json_data = lv_mem_alloc(json_data_len);
+       if(NULL == json_data)
+       {
+               HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: memory alloc failed\n", __FUNCTION__, __LINE__);
+               goto FREE_AND_EXIT;
+       }
+       _lv_memset_00(json_data, json_data_len);
+
+       temp_len += sprintf(json_data + temp_len, "{\"app_key\":\"%s\",", HENGAI_HTTP_POST_APP_KEY);
+
+       char imei[16 + 1] = {0};
+       app_adp_get_imei_req(imei);
+       temp_len += sprintf(json_data + temp_len, "\"mac\":\"%s\",", imei);
+
+       char * begin_time_str = mmi_hengai_bp_measure_action_time_string_get(1);
+       temp_len += sprintf(json_data + temp_len, "\"begin_time\":\"%s\",", begin_time_str);
+
+       char * end_time_str = mmi_hengai_bp_measure_action_time_string_get(0);
+       temp_len += sprintf(json_data + temp_len, "\"end_time\":\"%s\",", end_time_str);
+
+       uint16_t i = 0;
+       int * temp_int_ptr = mmi_hengai_bp_raw_data_ptr_get();
+       int temp_int_len = mmi_hengai_bp_raw_data_len_get();
+       temp_len += sprintf(json_data + temp_len, "\"pulse_wave\":[");
+       for(i = 0; i < temp_int_len; i++)
+       {
+               if(i == (temp_int_len - 1))
+               {
+                       temp_len += sprintf(json_data + temp_len, "%d],", temp_int_ptr[i]);
+               }
+               else
+               {
+                       temp_len += sprintf(json_data + temp_len, "%d,", temp_int_ptr[i]);
+               }
+       }
+
+       temp_len += sprintf(json_data + temp_len, "\"sample_rate\":%d,", MMI_HENGAI_BP_RAW_DATA_SAMPLE_RATE);
+
+       temp_len += sprintf(json_data + temp_len, "\"sbp\":%d,", bp_value_high);
+
+       temp_len += sprintf(json_data + temp_len, "\"dbp\":%d,", bp_value_low);
+
+       temp_len += sprintf(json_data + temp_len, "\"category\":%d}", calibrate_times);
+       
+       HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: %d\n", __FUNCTION__, __LINE__, temp_len);
+
+       // base64 body
+       encode_len = temp_len * 3 / 2;
+       encode_str = lv_mem_alloc(encode_len);
+       if(NULL == encode_str)
+       {
+               HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: memory alloc failed\n", __FUNCTION__, __LINE__);
+               goto FREE_AND_EXIT;
+       }
+       _lv_memset_00(encode_str, encode_len);
+       if(0 != mbedtls_base64_encode(encode_str, encode_len, &output_len, json_data, temp_len))
+       {
+               HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: base64 encode failed\n", __FUNCTION__, __LINE__);
+               goto FREE_AND_EXIT;
+       }
+
+       // json header
+       _lv_memset_00(json_data, json_data_len);
+
+       temp_len = 0;
+       temp_len += sprintf(json_data + temp_len, "{\"headers\":[");
+
+       temp_len += sprintf(json_data + temp_len, "{\"key\":\"token\",");
+
+       char * token = mmi_hengai_health_token_get();
+       temp_len += sprintf(json_data + temp_len, "\"value\":\"%s\"}", token);
+
+       temp_len += sprintf(json_data + temp_len, "]}");
+       
+       HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: %d\n", __FUNCTION__, __LINE__, temp_len);
+
+       // base64 header
+       encode_header_len = temp_len * 3 / 2;
+       encode_header_str = lv_mem_alloc(encode_header_len);
+       if(NULL == encode_header_str)
+       {
+               HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: memory alloc failed\n", __FUNCTION__, __LINE__);
+               goto FREE_AND_EXIT;
+       }
+       _lv_memset_00(encode_header_str, encode_header_len);
+       if(0 != mbedtls_base64_encode(encode_header_str, encode_header_len, &output_header_len, json_data, temp_len))
+       {
+               HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: base64 encode failed\n", __FUNCTION__, __LINE__);
+               goto FREE_AND_EXIT;
+       }       
+       
+       // content
+       data_len = output_len + output_header_len + 128;
+       data_ptr = lv_mem_alloc(data_len);
+       if(NULL == data_ptr)
+       {
+               HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: memory alloc failed\n", __FUNCTION__, __LINE__);
+               goto FREE_AND_EXIT;
+       }
+       _lv_memset_00(data_ptr, data_len);
+       
+#if 1
+       sprintf(data_ptr, ",POST,%s%s,%s,%s", HENGAI_HTTP_POST_URL_COMMON_PREFIX, "/health/bp/calibration", encode_header_str, encode_str);
+#else
+       sprintf(data_ptr, "POST,%s%s,%s,%s", HENGAI_HTTP_POST_URL_COMMON_PREFIX, "/health/bp/calibration", encode_header_str, encode_str);
+#endif
+       data_len = strlen(data_ptr);
+
+       s_hengai_bp_send_code = HENGAI_HEALTH_SEND_CALIBRATE_DATA;
+       mmi_protocol_fzd_action_tcp_http(data_ptr, data_len);
+       
+FREE_AND_EXIT:
+       if(NULL != json_data)
+       {
+               lv_mem_free(json_data);
+               json_data = NULL;
+       }
+       if(NULL != encode_str)
+       {
+               lv_mem_free(encode_str);
+               encode_str = NULL;
+       }
+       if(NULL != encode_header_str)
+       {
+               lv_mem_free(encode_header_str);
+               encode_header_str = NULL;
+       }
+       if(NULL != data_ptr)
+       {
+               lv_mem_free(data_ptr);
+               data_ptr = NULL;
+       }
+}
+
+void mmi_hengai_tcp_health_lib_activation_feedback(void)
+{
+       char * data_ptr = NULL;
+       uint32_t data_len = 0;
+       char * encode_str = NULL;
+       uint32_t encode_len = 0;
+       uint32_t output_len = 0;
+       int temp_len = 0;
+       int json_data_len = 256;
+       char * json_data = NULL;
+
+       // json body
+       json_data = lv_mem_alloc(json_data_len);
+       if(NULL == json_data)
+       {
+               HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: memory alloc failed\n", __FUNCTION__, __LINE__);
+               goto FREE_AND_EXIT;
+       }
+       _lv_memset_00(json_data, json_data_len);
+
+       temp_len += sprintf(json_data + temp_len, "{\"app_key\":\"%s\",", HENGAI_HTTP_POST_APP_KEY);
+
+       temp_len += sprintf(json_data + temp_len, "\"firm\":\"%s\",", "HENGAI");
+       
+       char imei[16 + 1] = {0};
+       app_adp_get_imei_req(imei);
+       temp_len += sprintf(json_data + temp_len, "\"mac\":\"%s\"}", imei);
+       
+       HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: %d\n", __FUNCTION__, __LINE__, temp_len);
+
+       // base64 body
+       encode_len = temp_len * 3 / 2;
+       encode_str = lv_mem_alloc(encode_len);
+       if(NULL == encode_str)
+       {
+               HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: memory alloc failed\n", __FUNCTION__, __LINE__);
+               goto FREE_AND_EXIT;
+       }
+       _lv_memset_00(encode_str, encode_len);
+       if(0 != mbedtls_base64_encode(encode_str, encode_len, &output_len, json_data, temp_len))
+       {
+               HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: base64 encode failed\n", __FUNCTION__, __LINE__);
+               goto FREE_AND_EXIT;
+       }
+       
+       // content
+       data_len = output_len + 128;
+       data_ptr = lv_mem_alloc(data_len);
+       if(NULL == data_ptr)
+       {
+               HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: memory alloc failed\n", __FUNCTION__, __LINE__);
+               goto FREE_AND_EXIT;
+       }
+       _lv_memset_00(data_ptr, data_len);
+       
+#if 1
+       sprintf(data_ptr, ",POST,%s%s,,%s", HENGAI_HTTP_POST_URL_COMMON_PREFIX, "/sinklib/activation/feedback", encode_str);
+#else
+       sprintf(data_ptr, "POST,%s%s,,%s", HENGAI_HTTP_POST_URL_COMMON_PREFIX, "/sinklib/activation/feedback", encode_str);
+#endif
+       data_len = strlen(data_ptr);
+
+       s_hengai_bp_send_code = HENGAI_HEALTH_SEND_ACTIVE_FEEDBACK;
+       mmi_protocol_fzd_action_tcp_http(data_ptr, data_len);
+       
+FREE_AND_EXIT:
+       if(NULL != json_data)
+       {
+               lv_mem_free(json_data);
+               json_data = NULL;
+       }
+       if(NULL != encode_str)
+       {
+               lv_mem_free(encode_str);
+               encode_str = NULL;
+       }
+       if(NULL != data_ptr)
+       {
+               lv_mem_free(data_ptr);
+               data_ptr = NULL;
+       }
+}
+
+void mmi_hengai_tcp_health_lib_activation_check_action(void)
+{
+       HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__);
+       
+       if(0 == mmi_hengai_health_lib_activated_flag_get())
+       {
+               char * data_ptr = NULL;
+               uint32_t data_len = 0;
+               char * encode_str = NULL;
+               uint32_t encode_len = 0;
+               uint32_t output_len = 0;
+               int temp_len = 0;
+               int json_data_len = 512;
+               char * json_data = NULL;
+
+               // json body
+               json_data = lv_mem_alloc(json_data_len);
+               if(NULL == json_data)
+               {
+                       HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: memory alloc failed\n", __FUNCTION__, __LINE__);
+                       goto FREE_AND_EXIT;
+               }
+               _lv_memset_00(json_data, json_data_len);
+       
+               temp_len += sprintf(json_data + temp_len, "{\"app_key\":\"%s\",", HENGAI_HTTP_POST_APP_KEY);
+       
+               temp_len += sprintf(json_data + temp_len, "\"name\":\"%s\",", "Z5");
+       
+               temp_len += sprintf(json_data + temp_len, "\"firm\":\"%s\",", "HENGAI");
+       
+               char imei[16 + 1] = {0};
+               app_adp_get_imei_req(imei);
+               temp_len += sprintf(json_data + temp_len, "\"mac\":\"%s\",", imei);
+       
+               temp_len += sprintf(json_data + temp_len, "\"model\":\"%s\",", "Z5_HA_K18");
+
+               temp_len += sprintf(json_data + temp_len, "\"sensor\":{\"fs\":%d,\"model\":\"%s\"},", MMI_HENGAI_BP_RAW_DATA_SAMPLE_RATE, "VC9202");
+       
+               temp_len += sprintf(json_data + temp_len, "\"sinklib_version\":\"%s\",", "v0.1.0.020623");
+       
+               char * req_code = mmi_hengai_health_lib_req_code_get();
+               temp_len += sprintf(json_data + temp_len, "\"request_code\":\"%s\"}", req_code);
+       
+               HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: %d\n", __FUNCTION__, __LINE__, temp_len);
+
+               // base64 body
+               encode_len = temp_len * 3 / 2;
+               encode_str = lv_mem_alloc(encode_len);
+               if(NULL == encode_str)
+               {
+                       HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: memory alloc failed\n", __FUNCTION__, __LINE__);
+                       goto FREE_AND_EXIT;
+               }
+               _lv_memset_00(encode_str, encode_len);
+               if(0 != mbedtls_base64_encode(encode_str, encode_len, &output_len, json_data, temp_len))
+               {
+                       HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: base64 encode failed\n", __FUNCTION__, __LINE__);
+                       goto FREE_AND_EXIT;
+               }
+               
+               // content
+               data_len = output_len + 128;
+               data_ptr = lv_mem_alloc(data_len);
+               if(NULL == data_ptr)
+               {
+                       HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: memory alloc failed\n", __FUNCTION__, __LINE__);
+                       goto FREE_AND_EXIT;
+               }
+               _lv_memset_00(data_ptr, data_len);
+               
+       #if 1
+               sprintf(data_ptr, ",POST,%s%s,,%s", HENGAI_HTTP_POST_URL_COMMON_PREFIX, "/sinklib/activation", encode_str);
+       #else
+               sprintf(data_ptr, "POST,%s%s,,%s", HENGAI_HTTP_POST_URL_COMMON_PREFIX, "/sinklib/activation", encode_str);
+       #endif
+               data_len = strlen(data_ptr);
+       
+               s_hengai_bp_send_code = HENGAI_HEALTH_SEND_ACTIVE;
+               mmi_protocol_fzd_action_tcp_http(data_ptr, data_len);
+               
+       FREE_AND_EXIT:
+               if(NULL != json_data)
+               {
+                       lv_mem_free(json_data);
+                       json_data = NULL;
+               }
+               if(NULL != encode_str)
+               {
+                       lv_mem_free(encode_str);
+                       encode_str = NULL;
+               }
+               if(NULL != data_ptr)
+               {
+                       lv_mem_free(data_ptr);
+                       data_ptr = NULL;
+               }
+       }
+}
+
+void mmi_hengai_tcp_algorithm_interface_login_action(void)
+{
+       HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__);
+       
+       char * token = mmi_hengai_health_token_get();
+       if(0 == strlen(token))
+       {
+               char * data_ptr = NULL;
+               uint32_t data_len = 0;
+               char * encode_str = NULL;
+               uint32_t encode_len = 0;
+               uint32_t output_len = 0;
+               int temp_len = 0;
+               int json_data_len = 512;
+               char * json_data = NULL;
+
+               // json body
+               json_data = lv_mem_alloc(json_data_len);
+               if(NULL == json_data)
+               {
+                       HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: memory alloc failed\n", __FUNCTION__, __LINE__);
+                       goto FREE_AND_EXIT;
+               }
+               _lv_memset_00(json_data, json_data_len);
+       
+               temp_len += sprintf(json_data + temp_len, "{\"app_key\":\"%s\",", HENGAI_HTTP_POST_APP_KEY);
+       
+               temp_len += sprintf(json_data + temp_len, "\"account_type\":\"%d\",", 3);
+               
+               char imei[16 + 1] = {0};
+               app_adp_get_imei_req(imei);
+               temp_len += sprintf(json_data + temp_len, "\"account\":\"%s\",", imei);
+               
+               temp_len += sprintf(json_data + temp_len, "\"name\":\"%s\",", imei);
+       
+               temp_len += sprintf(json_data + temp_len, "\"password\":\"%s\",", imei);
+       
+               temp_len += sprintf(json_data + temp_len, "\"gender\":\"%d\",", 3);
+       
+               temp_len += sprintf(json_data + temp_len, "\"birthday\":\"%s\",", "2000-10-01");
+               
+               temp_len += sprintf(json_data + temp_len, "\"height\":\"%d\",", 180);
+
+               temp_len += sprintf(json_data + temp_len, "\"weight\":\"%d\"}", 80);
+       
+               HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: %d\n", __FUNCTION__, __LINE__, temp_len);
+
+               // base64 body
+               encode_len = temp_len * 3 / 2;
+               encode_str = lv_mem_alloc(encode_len);
+               if(NULL == encode_str)
+               {
+                       HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: memory alloc failed\n", __FUNCTION__, __LINE__);
+                       goto FREE_AND_EXIT;
+               }
+               _lv_memset_00(encode_str, encode_len);
+               if(0 != mbedtls_base64_encode(encode_str, encode_len, &output_len, json_data, temp_len))
+               {
+                       HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: base64 encode failed\n", __FUNCTION__, __LINE__);
+                       goto FREE_AND_EXIT;
+               }
+               
+               // content
+               data_len = output_len + 128;
+               data_ptr = lv_mem_alloc(data_len);
+               if(NULL == data_ptr)
+               {
+                       HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: memory alloc failed\n", __FUNCTION__, __LINE__);
+                       goto FREE_AND_EXIT;
+               }
+               _lv_memset_00(data_ptr, data_len);
+               
+       #if 1
+               sprintf(data_ptr, ",POST,%s%s,,%s", HENGAI_HTTP_POST_URL_COMMON_PREFIX, "/entrance/user/login", encode_str);
+       #else
+               sprintf(data_ptr, "POST,%s%s,,%s", HENGAI_HTTP_POST_URL_COMMON_PREFIX, "/entrance/user/login", encode_str);
+       #endif
+               data_len = strlen(data_ptr);
+
+               s_hengai_bp_send_code = HENGAI_HEALTH_SEND_LOGIN;
+               mmi_protocol_fzd_action_tcp_http(data_ptr, data_len);
+               
+       FREE_AND_EXIT:
+               if(NULL != json_data)
+               {
+                       lv_mem_free(json_data);
+                       json_data = NULL;
+               }
+               if(NULL != encode_str)
+               {
+                       lv_mem_free(encode_str);
+                       encode_str = NULL;
+               }
+               if(NULL != data_ptr)
+               {
+                       lv_mem_free(data_ptr);
+                       data_ptr = NULL;
+               }
+       }
+       else
+       {
+               mmi_hengai_tcp_health_lib_activation_check_action();
+       }
+}
+
+bool mmi_hengai_health_data_parse(unsigned char * next_buff, unsigned int next_buff_len)
+{
+       if(NULL == next_buff || 0 == next_buff_len)
+       {
+               HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__);
+               return false;
+       }
+
+       HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: %d\n", __FUNCTION__, __LINE__, next_buff_len);
+       HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG]: %s\n", next_buff);
+       HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG]: %s\n", next_buff + 90);
+       HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG]: %s\n", next_buff + 180);
+       HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG]: %s\n", next_buff + 270);
+
+       uint32_t output_len = 0;
+       char * t_decode_str = lv_mem_alloc(next_buff_len);
+       if(NULL == t_decode_str)
+       {
+               HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: memory alloc fail\n", __FUNCTION__, __LINE__);
+               return false;
+       }
+       _lv_memset_00(t_decode_str, next_buff_len);     
+
+       int ret_value = mbedtls_base64_decode(t_decode_str, next_buff_len, &output_len, next_buff, next_buff_len);
+       HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: %d\n", __FUNCTION__, __LINE__, ret_value);
+       if(0 != ret_value)
+       {
+               HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__);
+               lv_mem_free(t_decode_str);
+               return false;
+       }
+
+       HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: %d\n", __FUNCTION__, __LINE__, strlen(t_decode_str));
+       HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG]: %s\n", t_decode_str);
+       HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG]: %s\n", t_decode_str + 90);
+       HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG]: %s\n", t_decode_str + 180);
+       HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG]: %s\n", t_decode_str + 270);
+       
+       cJSON * json_recv = cJSON_Parse(t_decode_str);
+       if(NULL != json_recv)
+       {
+               switch(s_hengai_bp_send_code)
+               {
+                       case HENGAI_HEALTH_SEND_LOGIN:
+                               if(cJSON_IsTrue(cJSON_GetObjectItem(json_recv, "status")))
+                               {
+                                       HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: true\n", __FUNCTION__, __LINE__);
+                                       //if(cJSON_HasObjectItem(json_recv, "data"))
+                                       cJSON * json_data = cJSON_GetObjectItem(json_recv, "data");
+                                       //if(cJSON_HasObjectItem(json_data, "token")) // login
+                                       char * token = cJSON_GetStringValue(cJSON_GetObjectItem(json_data, "token"));
+                                       
+                                       mmi_hengai_health_token_set(token);
+
+                                       mmi_hengai_tcp_health_lib_activation_check_action();
+                               }
+                               break;
+                               
+                       case HENGAI_HEALTH_SEND_ACTIVE:
+                               if(cJSON_IsTrue(cJSON_GetObjectItem(json_recv, "status")))
+                               {
+                                       HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: true\n", __FUNCTION__, __LINE__);
+                                       cJSON * json_data = cJSON_GetObjectItem(json_recv, "data");
+                                       char * act_code = cJSON_GetStringValue(cJSON_GetObjectItem(json_data, "activation_code"));
+
+                                       mmi_hengai_health_lib_act_code_set(act_code);
+                               }
+                               break;
+                               
+                       case HENGAI_HEALTH_SEND_ACTIVE_FEEDBACK:
+                               break;
+                               
+                       case HENGAI_HEALTH_SEND_CALIBRATE_DATA:
+                               if(cJSON_IsTrue(cJSON_GetObjectItem(json_recv, "status")))
+                               {
+                                       HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: true\n", __FUNCTION__, __LINE__);
+                                       cJSON * json_data = cJSON_GetObjectItem(json_recv, "data");
+                                       if(2 == cJSON_GetIntValue(cJSON_GetObjectItem(json_data, "category")))
+                                       {
+                                               mmi_hengai_tcp_bp_calibrate_model_send();
+                                       }
+                               }
+                               else
+                               {
+                                       HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: false\n", __FUNCTION__, __LINE__);
+                                       //if(2 == calibrate_times)
+                                               //mmi_ui_msg_action_hengai_bp_calibrate_result(false);
+                               }
+                               break;
+                               
+                       case HENGAI_HEALTH_SEND_CALIBRATE_MODEL:
+                               bool status_value = cJSON_IsTrue(cJSON_GetObjectItem(json_recv, "status"));
+                               
+                               HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: %d\n", __FUNCTION__, __LINE__, status_value);                                       
+                               mmi_ui_msg_action_hengai_bp_calibrate_result(status_value);
+                               break;
+                               
+                       case HENGAI_HEALTH_SEND_MEASURE_DATA:
+                               if(cJSON_IsTrue(cJSON_GetObjectItem(json_recv, "status")))
+                               {
+                                       HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: true\n", __FUNCTION__, __LINE__);
+                                       
+                                       cJSON * json_data = cJSON_GetObjectItem(json_recv, "data");
+                                       uint16_t bp_value_high = cJSON_GetIntValue(cJSON_GetObjectItem(json_data, "sbp"));
+                                       uint16_t bp_value_low = cJSON_GetIntValue(cJSON_GetObjectItem(json_data, "dbp"));
+                                       //char * description = cJSON_GetStringValue(cJSON_GetObjectItem(json_data, "description"));
+       
+                                       // update
+                                       mmi_ui_msg_action_hengai_bp_measure_result(true, bp_value_high, bp_value_low);
+                               }
+                               else
+                               {
+                                       HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: false\n", __FUNCTION__, __LINE__);
+                                       // update
+                                       mmi_ui_msg_action_hengai_bp_measure_result(false, 0, 0);
+                               }
+                               break;
+
+                       default:
+                               break;
+               }       
+       }
+       else
+       {
+               HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: not json file\n", __FUNCTION__, __LINE__);
+       }
+       
+       if(NULL != json_recv)
+       {
+               HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: free json root\n", __FUNCTION__, __LINE__);
+               cJSON_Delete(json_recv);
+               json_recv = NULL;
+       }       
+       if(NULL != t_decode_str)
+       {
+               lv_mem_free(t_decode_str);
+               t_decode_str = NULL;
+       }
+
+       return true;
+}
+
+#else
+
 static struct http_client * s_hengai_http_client = NULL;
 static struct http_client_list * s_hengai_http_client_list_header = NULL;
 static uint8_t s_hengai_http_post_try_count = 0;
@@ -879,7 +1872,7 @@ void mmi_hengai_algorithm_interface_login_action(void)
                }
        }
 }
-
+#endif
 
 
 
@@ -972,7 +1965,11 @@ void mmi_hengai_health_lib_act_code_set(char * act_code)
        HENGAI_HEALTH_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: ret=%d\n", __FUNCTION__, __LINE__, ret);
        if(ret)
        {
+       #ifdef __MMI_CUSTOM_HENGAI_HEALTH_UPLOAD_USE_TCP__
+               mmi_hengai_tcp_health_lib_activation_feedback();
+       #else
                mmi_hengai_health_lib_activation_feedback();
+       #endif
        }
 }
 

diff --git a/2.sdk/sdk/gui/lv_watch/lv_apps/custom_function/heng_ai_http_protocol.h b/2.sdk/sdk/gui/lv_watch/lv_apps/custom_function/heng_ai_http_protocol.h
index a7fd21e..be48c0b 100644 (file)
--- a/2.sdk/sdk/gui/lv_watch/lv_apps/custom_function/heng_ai_http_protocol.h
+++ b/2.sdk/sdk/gui/lv_watch/lv_apps/custom_function/heng_ai_http_protocol.h
@@ -46,6 +46,28 @@ extern "C" {
 #endif
 
 
+#ifdef __MMI_CUSTOM_HENGAI_HEALTH_UPLOAD_USE_TCP__
+typedef enum
+{
+       HENGAI_HEALTH_SEND_NONE,
+       HENGAI_HEALTH_SEND_LOGIN,
+       HENGAI_HEALTH_SEND_ACTIVE,
+       HENGAI_HEALTH_SEND_ACTIVE_FEEDBACK,
+       HENGAI_HEALTH_SEND_CALIBRATE_DATA,
+       HENGAI_HEALTH_SEND_CALIBRATE_MODEL,
+       HENGAI_HEALTH_SEND_MEASURE_DATA,
+       
+       HENGAI_HEALTH_SEND_MAX,
+}HENGAI_HEALTH_SEND_TYPE_ENUM;
+
+
+void mmi_hengai_tcp_bp_measure_raw_data_send(void);
+void mmi_hengai_tcp_bp_calibrate_raw_data_send(uint8_t calibrate_times, uint16_t bp_value_high, uint16_t bp_value_low);
+void mmi_hengai_tcp_algorithm_interface_login_action(void);
+bool mmi_hengai_health_data_parse(unsigned char * next_buff, unsigned int next_buff_len);
+
+#else
+
 #define HENGAI_HTTP_POST_TRY_COUNT_MAX  (3)
 
 
@@ -58,7 +80,7 @@ void mmi_hengai_bp_calibrate_raw_data_send(uint8_t calibrate_times, uint16_t bp_
 void mmi_hengai_health_lib_activation_check_action(void);
 
 void mmi_hengai_algorithm_interface_login_action(void);
-
+#endif
 
 void mmi_hengai_health_data_nv_read(void);
 

diff --git a/2.sdk/sdk/gui/lv_watch/lv_apps/custom_function/heng_ai_tcms.c b/2.sdk/sdk/gui/lv_watch/lv_apps/custom_function/heng_ai_tcms.c
index 032606d..a5b4f9a 100644 (file)
--- a/2.sdk/sdk/gui/lv_watch/lv_apps/custom_function/heng_ai_tcms.c
+++ b/2.sdk/sdk/gui/lv_watch/lv_apps/custom_function/heng_ai_tcms.c
@@ -41,6 +41,9 @@ void mmi_hengai_tcms_action(void)
        if(false == watch_modem_sim_present_check_req())
                return;
        
+       if(false == mmi_health_measure_wear_state_get())
+               return;
+       
        if(true == mmi_watch_is_in_factory_mode())
                return ;
 

diff --git a/2.sdk/sdk/gui/lv_watch/lv_apps/health_measure/health_measure.c b/2.sdk/sdk/gui/lv_watch/lv_apps/health_measure/health_measure.c
index d795416..6d833cb 100644 (file)
--- a/2.sdk/sdk/gui/lv_watch/lv_apps/health_measure/health_measure.c
+++ b/2.sdk/sdk/gui/lv_watch/lv_apps/health_measure/health_measure.c
@@ -176,7 +176,7 @@ bool mmi_health_measure_temperature_data_process(float * body_value, float * wri
        t_body_value = 36.0 + rand() % 4 * 0.1;
        t_wrist_value = t_body_value - 10.0;
 
-#elif USE_ACNT117
+#elif USE_ACNT117 || USE_FR8012HAQ
        float t_float_value = 0.0;
 
        mmi_tsensor_body_value_get(&t_float_value);

diff --git a/2.sdk/sdk/gui/lv_watch/lv_apps/sms_msg/sms_msg.c b/2.sdk/sdk/gui/lv_watch/lv_apps/sms_msg/sms_msg.c
index cb59a33..000036c 100644 (file)
--- a/2.sdk/sdk/gui/lv_watch/lv_apps/sms_msg/sms_msg.c
+++ b/2.sdk/sdk/gui/lv_watch/lv_apps/sms_msg/sms_msg.c
@@ -239,7 +239,7 @@ static void sms_msg_list_create(lv_obj_t * obj, lv_ll_t * sms_list)
 #else\r
 \r
 #ifdef USE_LV_WATCH_UI_466_466\r
-       lv_obj_set_size(list, LV_HOR_RES, LV_VER_RES - 60);\r
+       lv_obj_set_size(list, LV_HOR_RES, LV_VER_RES - 110);\r
 #else\r
        lv_obj_set_size(list,LV_HOR_RES,LV_VER_RES);//set list size\r
 #endif\r
@@ -848,7 +848,7 @@ static void mbox_sms_label(lv_sms_item_ext_t * ext)
                LV_ASSERT_MEM(msg_ta);\r
        #ifdef USE_LV_WATCH_UI_CIRCLE\r
        #ifdef USE_LV_WATCH_UI_466_466\r
-               lv_obj_set_size(msg_ta, LV_HOR_RES - 80, LV_VER_RES - 50 - 100);\r
+               lv_obj_set_size(msg_ta, LV_HOR_RES - 54 * 2, LV_VER_RES - 166);\r
        #else\r
                lv_obj_set_size(msg_ta, LV_HOR_RES - 20 * 2, LV_VER_RES - 20 - 15 * 2 - 40);\r
        #endif\r
@@ -867,7 +867,7 @@ static void mbox_sms_label(lv_sms_item_ext_t * ext)
                lv_textarea_set_scrollbar_mode(msg_ta,LV_SCROLLBAR_MODE_OFF);\r
                lv_textarea_set_edge_flash(msg_ta, true);\r
        #ifdef USE_LV_WATCH_UI_466_466\r
-               lv_obj_align(msg_ta, mbox_count, LV_ALIGN_IN_TOP_MID, 0, 50);\r
+               lv_obj_align(msg_ta, mbox_count, LV_ALIGN_IN_TOP_MID, 0, 62);\r
        #else\r
                lv_obj_align(msg_ta, mbox_count, LV_ALIGN_IN_TOP_MID, 0, 20);\r
        #endif\r

diff --git a/2.sdk/sdk/gui/lv_watch/mmi_protocol/mmi_protocol_api.c b/2.sdk/sdk/gui/lv_watch/mmi_protocol/mmi_protocol_api.c
index 2c55e9d..cf45ee6 100644 (file)
--- a/2.sdk/sdk/gui/lv_watch/mmi_protocol/mmi_protocol_api.c
+++ b/2.sdk/sdk/gui/lv_watch/mmi_protocol/mmi_protocol_api.c
@@ -474,9 +474,13 @@ extern void dm_send_msg_active(void);
 bool mmi_protocol_watch_link_action(void)
 {
 #ifdef __MMI_CUSTOM_HENGAI_HEALTH__
+#ifdef __MMI_CUSTOM_HENGAI_HEALTH_UPLOAD_USE_TCP__
+       mmi_hengai_tcp_algorithm_interface_login_action();
+#else
        mmi_hengai_algorithm_interface_login_action();
        mmi_hengai_health_lib_activation_check_action();
 #endif
+#endif
 #if USE_DS_DM
        dm_send_msg_active();
 #endif

diff --git a/2.sdk/sdk/gui/lv_watch/mmi_protocol/mmi_protocol_fzd.c b/2.sdk/sdk/gui/lv_watch/mmi_protocol/mmi_protocol_fzd.c
index e3279fe..c127323 100644 (file)
--- a/2.sdk/sdk/gui/lv_watch/mmi_protocol/mmi_protocol_fzd.c
+++ b/2.sdk/sdk/gui/lv_watch/mmi_protocol/mmi_protocol_fzd.c
@@ -566,6 +566,8 @@ bool mmi_protocol_fzd_parse_LINK(unsigned char * next_buff, unsigned int next_bu
                mmi_protocol_fzd_action_bind();
        }
 
+       mmi_protocol_fzd_action_get_app_qrcode();
+
        return true;
 }
 
@@ -2155,6 +2157,62 @@ bool mmi_protocol_fzd_action_unbind(void)
        return mmi_protocol_fzd_send_without_data(MMI_FZD_ACTION_UNBIND);
 }
 
+#ifdef __MMI_APP_QRCODE_FROM_SERVER_SUPPORT__
+static uint8_t s_app_qrcode_get_flag = 0;
+
+uint8_t mmi_app_qrcode_get_flag_get(void)
+{
+       return s_app_qrcode_get_flag;
+}
+
+void mmi_app_qrcode_get_flag_set(uint8_t flag)
+{
+       if(0 != flag && 1 != flag)
+               return;
+       
+       s_app_qrcode_get_flag = flag;
+}
+#endif
+
+bool mmi_protocol_fzd_action_get_app_qrcode(void)
+{
+#ifdef __MMI_APP_QRCODE_FROM_SERVER_SUPPORT__
+       if(0 == mmi_app_qrcode_get_flag_get())
+               return mmi_protocol_fzd_send_without_data(MMI_FZD_ACTION_GET_APP_QRCODE);
+       else
+               return false;
+#else
+       return false;
+#endif
+}
+
+bool mmi_protocol_fzd_parse_ACTION_GET_APP_QRCODE(unsigned char * next_buff, unsigned int next_buff_len)
+{
+       bool result = false;
+       MMI_PROTOCOL_FZD_ACTION_ENUM action = MMI_FZD_ACTION_GET_APP_QRCODE;
+
+#ifdef __MMI_APP_QRCODE_FROM_SERVER_SUPPORT__
+       if(NULL == next_buff || 0 == next_buff_len)
+       {
+               PROTOCOL_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__);
+               return false;
+       }
+
+       result = true;
+
+       unsigned int next_buff_len_new = 0;
+       
+       next_buff_len_new = mmi_protocol_fzd_voice_data_decrypt(next_buff, next_buff_len);
+       PROTOCOL_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: %d, %d\n", __FUNCTION__, __LINE__, next_buff_len, next_buff_len_new);
+       mmi_app_qrcode_content_buffer_set(next_buff, next_buff_len_new);
+
+       mmi_app_qrcode_get_flag_set(1);
+#endif
+
+       return result;
+}
+
+
 
 #ifdef __MMI_ZHSX_SUPPORT_VIDEO_CALL__
 #ifdef __MMI_ZHSX_SUPPORT_VIDEO_CALL_WULIAN__
@@ -3884,6 +3942,89 @@ bool mmi_protocol_fzd_action_hengai_tcms_data(char * data_ptr, uint32_t data_len
 }
 #endif
 
+bool mmi_protocol_fzd_action_tcp_http(char * data_ptr, uint32_t data_len)
+{
+       bool result = false;
+       MMI_PROTOCOL_FZD_ACTION_ENUM action = MMI_FZD_ACTION_TCP_HTTP;
+       unsigned char * content_buff = NULL;
+       unsigned int content_lenth = 0;
+       unsigned char * temp_ptr = NULL;
+       unsigned int temp_lenth = 0;
+
+#if 1
+       PROTOCOL_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: %d\n", __FUNCTION__, __LINE__, data_len);
+       PROTOCOL_DEBUG_PRINTF("[@CHENG_DEBUG][%d]: %s\n", __LINE__, data_ptr);
+
+       result = mmi_protocol_fzd_send_with_data(action, data_ptr, data_len);
+#else
+
+       content_lenth = data_len + 8;
+       content_buff = (unsigned char *)lv_mem_alloc(content_lenth);
+       if(NULL == content_buff)
+       {
+               PROTOCOL_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__);
+               return false;
+       }
+       _lv_memset_00(content_buff, content_lenth);
+
+       temp_lenth = 0;
+       temp_ptr = content_buff + temp_lenth;
+       sprintf(temp_ptr, ",");
+
+       temp_lenth = strlen(temp_ptr);
+       temp_ptr += temp_lenth;
+       _lv_memcpy(temp_ptr, data_ptr, data_len);
+
+       content_lenth = strlen(content_buff);
+       
+       PROTOCOL_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: %d\n", __FUNCTION__, __LINE__, content_lenth);
+       PROTOCOL_DEBUG_PRINTF("[@CHENG_DEBUG][%d]: %s\n", __LINE__, content_buff);
+
+       result = mmi_protocol_fzd_send_with_data(action, content_buff, content_lenth);
+
+       if(NULL != content_buff)
+       {
+               lv_mem_free(content_buff);
+               content_buff = NULL;
+       }
+#endif
+       
+       return true;
+}
+
+bool mmi_protocol_fzd_parse_ACTION_TCP_HTTP(unsigned char * next_buff, unsigned int next_buff_len)
+{
+       bool result = false;
+       MMI_PROTOCOL_FZD_ACTION_ENUM action = MMI_FZD_ACTION_TCP_HTTP;
+
+       if(NULL == next_buff || 0 == next_buff_len)
+       {
+               PROTOCOL_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__);
+               return false;
+       }
+       
+       result = true;
+       //mmi_protocol_fzd_send_without_data(action);
+
+       char * temp_ptr = NULL;
+       int state_code = 0;
+
+       temp_ptr = km_strtok_r(NULL, ",", &next_buff);
+       state_code = atoi(temp_ptr);
+       PROTOCOL_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: %d\n", __FUNCTION__, __LINE__, state_code);
+       
+       if(5000 != state_code && 4005 != state_code)
+       {
+       #ifdef __MMI_CUSTOM_HENGAI_HEALTH_UPLOAD_USE_TCP__
+               mmi_hengai_health_data_parse(next_buff, strlen(next_buff));
+       #else
+
+       #endif
+       }
+       
+       return result;
+}
+
 
 
 #endif

diff --git a/2.sdk/sdk/gui/lv_watch/mmi_protocol/mmi_protocol_fzd.h b/2.sdk/sdk/gui/lv_watch/mmi_protocol/mmi_protocol_fzd.h
index 6e8eaa0..09a4bc0 100644 (file)
--- a/2.sdk/sdk/gui/lv_watch/mmi_protocol/mmi_protocol_fzd.h
+++ b/2.sdk/sdk/gui/lv_watch/mmi_protocol/mmi_protocol_fzd.h
@@ -142,6 +142,7 @@ typedef enum
        MMI_FZD_SERVER_SET_MONITOR,     
        MMI_FZD_ACTION_UNBIND,
        MMI_FZD_SERVER_SET_REBOOT,
+       MMI_FZD_ACTION_GET_APP_QRCODE,
 
 #ifdef __MMI_ZHSX_SUPPORT_VIDEO_CALL__
 #if defined(__MMI_ZHSX_SUPPORT_VIDEO_CALL_WULIAN__) || defined(__MMI_ZHSX_SUPPORT_VIDEO_CALL_FZD__) || defined(__MMI_ZHSX_SUPPORT_VIDEO_CALL_TONGXIN__)
@@ -206,6 +207,8 @@ MMI_FZD_ACTION_HENGAI_SLEEP_DATA_TEST,
 #ifdef __MMI_CUSTOM_HENGAI_TCMS__
        MMI_FZD_ACTION_HENGAI_TCMS_DATA,
 #endif
+       MMI_FZD_ACTION_TCP_HTTP,
+
        MMI_FZD_SERVER_SET_BOOTOFF,
        MMI_FZD_SEND_UP_REMIND,
 
@@ -315,6 +318,9 @@ bool mmi_protocol_fzd_action_send_warning_info(MMI_WATCH_LOCATION_DATA_T * locat
 
 bool mmi_protocol_fzd_action_unbind(void);
 
+bool mmi_protocol_fzd_action_get_app_qrcode(void);
+bool mmi_protocol_fzd_parse_ACTION_GET_APP_QRCODE(unsigned char * next_buff, unsigned int next_buff_len);
+
 #ifdef __MMI_ZHSX_SUPPORT_VIDEO_CALL__
 bool mmi_protocol_fzd_action_get_vc_config(void);
 bool mmi_protocol_fzd_action_VC_CALL_REQUEST(char * number, uint8_t call_type);
@@ -366,6 +372,11 @@ bool mmi_protocol_fzd_action_hengai_sleep_data(char * file_buf, uint32_t file_si
 bool mmi_protocol_fzd_action_hengai_tcms_data(char * data_ptr, uint32_t data_len);
 #endif
 
+bool mmi_protocol_fzd_action_tcp_http(char * data_ptr, uint32_t data_len);
+bool mmi_protocol_fzd_parse_ACTION_TCP_HTTP(unsigned char * next_buff, unsigned int next_buff_len);
+
+
+
 #endif
 
 #ifdef __cplusplus

diff --git a/2.sdk/sdk/gui/lv_watch/mmi_protocol/mmi_protocol_fzd_content.c b/2.sdk/sdk/gui/lv_watch/mmi_protocol/mmi_protocol_fzd_content.c
index 9ecad0e..7e3c9b5 100644 (file)
--- a/2.sdk/sdk/gui/lv_watch/mmi_protocol/mmi_protocol_fzd_content.c
+++ b/2.sdk/sdk/gui/lv_watch/mmi_protocol/mmi_protocol_fzd_content.c
@@ -65,6 +65,7 @@ static unsigned char * mmi_protocol_fzd_action_string_get(MMI_PROTOCOL_FZD_ACTIO
                        {MMI_FZD_SERVER_SET_MONITOR, "MONITOR"},
                        {MMI_FZD_ACTION_UNBIND, "DLT"},
                        {MMI_FZD_SERVER_SET_REBOOT, "REBOOT"},
+                       {MMI_FZD_ACTION_GET_APP_QRCODE, "CID"},
 
                #ifdef __MMI_ZHSX_SUPPORT_VIDEO_CALL__
                #ifdef __MMI_ZHSX_SUPPORT_VIDEO_CALL_WULIAN__
@@ -139,6 +140,7 @@ static unsigned char * mmi_protocol_fzd_action_string_get(MMI_PROTOCOL_FZD_ACTIO
                #ifdef __MMI_CUSTOM_HENGAI_TCMS__
                        {MMI_FZD_ACTION_HENGAI_TCMS_DATA, "CNDOCD"},                    
                #endif
+                       {MMI_FZD_ACTION_TCP_HTTP, "TCP_HTTP"},
                        {MMI_FZD_SERVER_SET_BOOTOFF, "BOOTOFF"},
                        {MMI_FZD_SEND_UP_REMIND, "UP_REMIND"},
                
@@ -330,6 +332,10 @@ static bool mmi_protocol_fzd_content_parse(unsigned char * content_ptr, unsigned
                        mmi_protocol_fzd_parse_SERVER_SET_REBOOT(next_buff, next_buff_len);
                        break;
 
+               case MMI_FZD_ACTION_GET_APP_QRCODE:
+                       mmi_protocol_fzd_parse_ACTION_GET_APP_QRCODE(next_buff, next_buff_len);
+                       break;
+
        #ifdef __MMI_ZHSX_SUPPORT_VIDEO_CALL__
        #if defined(__MMI_ZHSX_SUPPORT_VIDEO_CALL_WULIAN__) || defined(__MMI_ZHSX_SUPPORT_VIDEO_CALL_FZD__) || defined(__MMI_ZHSX_SUPPORT_VIDEO_CALL_TONGXIN__)
                case MMI_FZD_WATCH_GET_VC_CONFIG:
@@ -473,6 +479,10 @@ static bool mmi_protocol_fzd_content_parse(unsigned char * content_ptr, unsigned
                        break;
        #endif
 
+               case MMI_FZD_ACTION_TCP_HTTP:
+                       mmi_protocol_fzd_parse_ACTION_TCP_HTTP(next_buff, next_buff_len);
+                       break;
+
                case MMI_FZD_SERVER_SET_BOOTOFF:
                        mmi_protocol_fzd_parse_SERVER_SET_BOOTOFF(next_buff, next_buff_len);
                        break;