From: @CHENG <2393524978@qq.com>
Date: Thu, 28 Mar 2024 03:36:57 +0000 (+0800)
Subject: gengxin
X-Git-Url: http://git.snicker.com.cn/?a=commitdiff_plain;h=5eed2fc116e1d7f39c10a0104076a30990778a6a;p=mirrors%2FASR3603_Z5.git

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 516cc24f..f204c091 100644
--- 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 e8ac7514..0906cdc2 100644
--- 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 c4689062..7dbed3d6 100644
--- 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 c686bd5e..38300bc2 100644
--- 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 a7fd21e2..be48c0bf 100644
--- 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 032606d0..a5b4f9a2 100644
--- 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 d795416b..6d833cb9 100644
--- 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 cb59a33b..000036cb 100644
--- 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
 
 #ifdef USE_LV_WATCH_UI_466_466
-	lv_obj_set_size(list, LV_HOR_RES, LV_VER_RES - 60);
+	lv_obj_set_size(list, LV_HOR_RES, LV_VER_RES - 110);
 #else
 	lv_obj_set_size(list,LV_HOR_RES,LV_VER_RES);//set list size
 #endif
@@ -848,7 +848,7 @@ static void mbox_sms_label(lv_sms_item_ext_t * ext)
 		LV_ASSERT_MEM(msg_ta);
 	#ifdef USE_LV_WATCH_UI_CIRCLE
 	#ifdef USE_LV_WATCH_UI_466_466
-		lv_obj_set_size(msg_ta, LV_HOR_RES - 80, LV_VER_RES - 50 - 100);
+		lv_obj_set_size(msg_ta, LV_HOR_RES - 54 * 2, LV_VER_RES - 166);
 	#else
 		lv_obj_set_size(msg_ta, LV_HOR_RES - 20 * 2, LV_VER_RES - 20 - 15 * 2 - 40);
 	#endif
@@ -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);
 		lv_textarea_set_edge_flash(msg_ta, true);
 	#ifdef USE_LV_WATCH_UI_466_466
-		lv_obj_align(msg_ta, mbox_count, LV_ALIGN_IN_TOP_MID, 0, 50);
+		lv_obj_align(msg_ta, mbox_count, LV_ALIGN_IN_TOP_MID, 0, 62);
 	#else
 		lv_obj_align(msg_ta, mbox_count, LV_ALIGN_IN_TOP_MID, 0, 20);
 	#endif
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 2c55e9db..cf45ee65 100644
--- 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 e3279feb..c1273230 100644
--- 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 6e8eaa0e..09a4bc09 100644
--- 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 9ecad0eb..7e3c9b54 100644
--- 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;