From: @CHENG <2393524978@qq.com> Date: Mon, 3 Jun 2024 01:44:50 +0000 (+0800) Subject: gengxin X-Git-Url: http://git.snicker.com.cn/?a=commitdiff_plain;h=2711560d29953c3249d24b24e6fae2a72530e25a;p=mirrors%2FASR3603_Z5.git gengxin --- diff --git a/2.sdk/sdk/gui/lv_watch/include/ui_activity_id.h b/2.sdk/sdk/gui/lv_watch/include/ui_activity_id.h index fe6eabf2..d286fded 100644 --- a/2.sdk/sdk/gui/lv_watch/include/ui_activity_id.h +++ b/2.sdk/sdk/gui/lv_watch/include/ui_activity_id.h @@ -220,6 +220,12 @@ enum //ACT_ID_HENG_AI_BP_ATTEMPT, ACT_ID_HENG_AI_BP_RECORD, #endif +#ifdef __MMI_CUSTOM_AIGC_SUPPORT__ + ACT_ID_AIGC_MAIN, + ACT_ID_AIGC_WAITTING, + ACT_ID_AIGC_RECORDING, + ACT_ID_AIGC_SENDING, +#endif #ifdef __MMI_CUSTOM_BEI_KE_RUI_SHENG__ ACT_ID_AI_TALK, ACT_ID_AI_TALK_RECORDING, diff --git a/2.sdk/sdk/gui/lv_watch/lv_apps/custom_function/custom_function.c b/2.sdk/sdk/gui/lv_watch/lv_apps/custom_function/custom_function.c index ec5b3357..ba559878 100644 --- a/2.sdk/sdk/gui/lv_watch/lv_apps/custom_function/custom_function.c +++ b/2.sdk/sdk/gui/lv_watch/lv_apps/custom_function/custom_function.c @@ -18,6 +18,10 @@ #include "heng_ai_tcms.c" #endif #endif +#ifdef __MMI_CUSTOM_AIGC_SUPPORT__ +#include "mmi_aigc_ui.c" +#include "mmi_aigc_data.c" +#endif #ifdef __MMI_CUSTOM_BEI_KE_RUI_SHENG__ #include "bei_ke_rui_sheng.c" diff --git a/2.sdk/sdk/gui/lv_watch/lv_apps/custom_function/custom_function.h b/2.sdk/sdk/gui/lv_watch/lv_apps/custom_function/custom_function.h index befcea40..c504d787 100644 --- a/2.sdk/sdk/gui/lv_watch/lv_apps/custom_function/custom_function.h +++ b/2.sdk/sdk/gui/lv_watch/lv_apps/custom_function/custom_function.h @@ -30,6 +30,10 @@ extern "C" { #include "heng_ai_http_protocol.h" #include "heng_ai_tcms.h" #endif +#ifdef __MMI_CUSTOM_AIGC_SUPPORT__ +#include "mmi_aigc_ui.h" +#include "mmi_aigc_data.h" +#endif #ifdef __MMI_CUSTOM_BEI_KE_RUI_SHENG__ #include "bei_ke_rui_sheng.h" diff --git a/2.sdk/sdk/gui/lv_watch/lv_apps/custom_function/mmi_aigc_data.c b/2.sdk/sdk/gui/lv_watch/lv_apps/custom_function/mmi_aigc_data.c new file mode 100644 index 00000000..5cece51e --- /dev/null +++ b/2.sdk/sdk/gui/lv_watch/lv_apps/custom_function/mmi_aigc_data.c @@ -0,0 +1,592 @@ + + + +#include "lv_watch.h" + +#ifdef __MMI_CUSTOM_AIGC_SUPPORT__ + +//#include "../../../../../product/craneg_modem/pcac/video_call/re/include/Re_hmac.h" +#include "hal/dm/cJSON.h" + + +#ifndef MMI_AIGC_DEBUG_TO_FILE +#define MMI_AIGC_DEBUG_TO_FILE +#endif + +#ifdef MMI_AIGC_DEBUG_TO_FILE +#define AIGC_RECEIVE_FILE "C:/aigc.txt" +#define AIGC_RECEIVE_TEXT_FILE "C:/aigc_text.txt" +#define AIGC_RECEIVE_TTS_FILE "C:/aigc_tts.txt" + +bool mmi_aigc_receive_info_write_to_file(char * path, char * info_buf, uint32_t info_size) +{ + lv_fs_file_t file_p; + lv_fs_res_t res; + uint32_t bytes_write = 0; + + res = lv_fs_open(&file_p, path, LV_FS_MODE_WR | LV_FS_MODE_APPEND); + if(LV_FS_RES_OK != res) + { + printf("[@CHENG_DEBUG][%s][%d]: errno=%d\n", __FUNCTION__, __LINE__, res); + lv_fs_close(&file_p); + return false; + } + + hal_rtc_t cur_time = {0}; + char str_time[24] = {0}; + + Hal_Rtc_Gettime(&cur_time); + sprintf(str_time, "\n[%04d%02d%02d_%02d%02d%02d]", + cur_time.tm_year, + cur_time.tm_mon, + cur_time.tm_mday, + cur_time.tm_hour, + cur_time.tm_min, + cur_time.tm_sec); + + //lv_fs_seek + res = lv_fs_write(&file_p, str_time, strlen(str_time), &bytes_write); + if(LV_FS_RES_OK != res) + { + printf("[@CHENG_DEBUG][%s][%d]: errno=%d\n", __FUNCTION__, __LINE__, res); + lv_fs_close(&file_p); + return false; + } + + res = lv_fs_write(&file_p, info_buf, info_size, &bytes_write); + lv_fs_close(&file_p); + if(LV_FS_RES_OK != res) + { + printf("[@CHENG_DEBUG][%s][%d]: errno=%d\n", __FUNCTION__, __LINE__, res); + return false; + } + printf("[@CHENG_DEBUG][%s][%d]: file_size=%d,write_size=%d\n", __FUNCTION__, __LINE__, info_size, bytes_write); + + return true; +} +#endif + + +static char * s_aigc_transcription_result_ptr = NULL; +static uint32_t s_aigc_transcription_result_size = 0; + + +int mmi_aigc_stop_transcription_send(void) +{ + int ret = 0; + char data_ptr[512] = {0}; + int data_len = 0; + + data_len = sprintf(data_ptr, "{\"header\":{\"event\":\"StopTranscription\",\"trace_id\":\"3fa6b9e6a30b407ea38ad7ae69e6c291\"}}"); + + ret = mmi_aigc_trans_websocket_send_text_data(data_ptr, data_len); + + return ret; +} + +int mmi_aigc_start_transcription_send(void) +{ + int ret = 0; + char data_ptr[512] = {0}; + int data_len = 0; + + data_len = sprintf(data_ptr, "{\"header\":{\"event\":\"StartTranscription\",\"trace_id\":\"3fa6b9e6a30b407ea38ad7ae69e6c291\"},\"payload\":{\"format\":\"amr\",\"sample_rate\":8000}}"); + + ret = mmi_aigc_trans_websocket_send_text_data(data_ptr, data_len); + + return ret; +} + +int mmi_aigc_audio_data_send(char * audio_data_ptr, uint32_t audio_data_len) +{ + int ret = 0; + + AIGC_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: size=%d,data=%s\n", __FUNCTION__, __LINE__, audio_data_len, audio_data_ptr); + + ret = mmi_aigc_trans_websocket_send_binary_data(audio_data_ptr, audio_data_len); + + return ret; +} + +int __mmi_aigc_audio_data_send(uint8_t index) +{ + int ret = 0; + lv_fs_file_t file_p; + lv_fs_res_t res; + uint32_t file_size = 0, bytes_read = 0; + char * file_buf = NULL; + + #define AIGC_TEST_AUDIO_0 "C:/aigc_test_0.amr" + #define AIGC_TEST_AUDIO_1 "C:/aigc_test_1.amr" + + if(0 == index) + res = lv_fs_open(&file_p, AIGC_TEST_AUDIO_0, LV_FS_MODE_RD); + else + res = lv_fs_open(&file_p, AIGC_TEST_AUDIO_1, LV_FS_MODE_RD); + + if(LV_FS_RES_OK != res) + { + printf("[@CHENG_DEBUG][%s][%d]: errno=%d\n", __FUNCTION__, __LINE__, res); + lv_fs_close(&file_p); + return; + } + + lv_fs_size(&file_p, &file_size); + file_buf = (char *)lv_mem_alloc(file_size + 1); + _lv_memset_00(file_buf, file_size + 1); + res = lv_fs_read(&file_p, file_buf, file_size, &bytes_read); + lv_fs_close(&file_p); + if(LV_FS_RES_OK != res) + { + printf("[@CHENG_DEBUG][%s][%d]: errno=%d\n", __FUNCTION__, __LINE__, res); + lv_mem_free(file_buf); + return; + } + AIGC_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: file_size=%d,bytes_read=%d\n", __FUNCTION__, __LINE__, file_size, bytes_read); + + ret = mmi_aigc_trans_websocket_send_binary_data(file_buf, file_size); + + lv_mem_free(file_buf); + + return ret; +} + + +#if 0 +bool mmi_ai_talk_type_tts_info_data_store(unsigned char * next_buff, unsigned int next_buff_len) +{ + if(NULL == s_ai_talk_type_tts_info_ptr) + { + printf("[@CHENG_DEBUG][%s][%d]: \n",__FUNCTION__,__LINE__); + + s_ai_talk_type_tts_info_ptr = lv_mem_alloc(next_buff_len + 1); + if(NULL == s_ai_talk_type_tts_info_ptr) + { + printf("[@CHENG_DEBUG][%s][%d]: memory alloc fail\n", __FUNCTION__, __LINE__); + return false; + } + _lv_memset_00(s_ai_talk_type_tts_info_ptr, next_buff_len + 1); + _lv_memcpy(s_ai_talk_type_tts_info_ptr, next_buff, next_buff_len); + s_ai_talk_type_tts_info_size = next_buff_len; + } + else + { + printf("[@CHENG_DEBUG][%s][%d]: \n",__FUNCTION__,__LINE__); + + s_ai_talk_type_tts_info_ptr = lv_mem_realloc(s_ai_talk_type_tts_info_ptr, s_ai_talk_type_tts_info_size + next_buff_len + 1); + if(NULL == s_ai_talk_type_tts_info_ptr) + { + printf("[@CHENG_DEBUG][%s][%d]: memory realloc fail\n", __FUNCTION__, __LINE__); + return false; + } + _lv_memset_00(s_ai_talk_type_tts_info_ptr + s_ai_talk_type_tts_info_size, next_buff_len + 1); + _lv_memcpy(s_ai_talk_type_tts_info_ptr + s_ai_talk_type_tts_info_size, next_buff, next_buff_len); + s_ai_talk_type_tts_info_size += next_buff_len; + } + + return true; +} + +bool mmi_ai_talk_type_tts_info_data_parse(cJSON * json_type_tts) +{ + char t_left_brace = '{'; + char t_right_brace = '}'; + char * t_start_ptr = NULL; + char * t_end_ptr = NULL; + uint32_t t_offset = 0; + char * t_head_ptr = NULL; + + printf("[@CHENG_DEBUG][%s][%d]: total_size=%d\n", __FUNCTION__, __LINE__, s_ai_talk_type_tts_info_size); + + t_head_ptr = s_ai_talk_type_tts_info_ptr; + while(1) + { + if(t_left_brace!=s_ai_talk_type_tts_info_ptr[0]) + { + printf("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__); + } + + if(s_ai_talk_type_tts_info_size <= (t_head_ptr - s_ai_talk_type_tts_info_ptr)) + { + printf("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__); + debug_type_ai_talk=1; + return false; + } + + t_start_ptr = strchr(t_head_ptr, t_left_brace); + t_end_ptr = strchr(t_head_ptr, t_right_brace); + t_offset = t_end_ptr - t_start_ptr + 1; + t_head_ptr += t_offset; + + printf("[@CHENG_DEBUG][%s][%d]: head=0x%x,start=0x%x,end=0x%x,offset=%d\n", + __FUNCTION__, __LINE__, t_head_ptr, t_start_ptr, t_end_ptr, t_offset); + + if(NULL != s_ai_talk_type_tts_info_json_ptr) + { + lv_mem_free(s_ai_talk_type_tts_info_json_ptr); + s_ai_talk_type_tts_info_json_ptr = NULL; + } + s_ai_talk_type_tts_info_json_ptr = lv_mem_alloc(t_offset + 1); + if(NULL == s_ai_talk_type_tts_info_json_ptr) + { + printf("[@CHENG_DEBUG][%s][%d]: memory alloc fail\n", __FUNCTION__, __LINE__); + debug_type_ai_talk=2; + return false; + } + _lv_memset_00(s_ai_talk_type_tts_info_json_ptr, t_offset + 1); + _lv_memcpy(s_ai_talk_type_tts_info_json_ptr, t_start_ptr, t_offset); + + if(NULL != json_type_tts) + { + cJSON_Delete(json_type_tts); + json_type_tts = NULL; + } + json_type_tts = cJSON_Parse(s_ai_talk_type_tts_info_json_ptr); + if(NULL == json_type_tts) + { + printf("[@CHENG_DEBUG][%s][%d]: json parse fail\n", __FUNCTION__, __LINE__); + debug_type_ai_talk=3; + s_ai_talk_type_tts_info_recv_end=false; + mmi_ai_talk_tts_info_result_display(s_ai_talk_type_tts_info_audio_ptr, s_ai_talk_type_tts_info_audio_size); + return false; + } + + char * value_type_str = cJSON_GetStringValue(cJSON_GetObjectItem(json_type_tts, KEY_TYPE)); + if(0 != strncmp(value_type_str, VALUE_TYPE_TTS, strlen(VALUE_TYPE_TTS))) + { + printf("[@CHENG_DEBUG][%s][%d]: not tts info json\n", __FUNCTION__, __LINE__); + debug_type_ai_talk=4; + return false; + } + + int value_type_tts_index = cJSON_GetIntValue(cJSON_GetObjectItem(json_type_tts, KEY_TYPE_TTS_INDEX)); + if(value_type_tts_index==-1) + { + printf("[@CHENG_DEBUG][%s][%d]: tts info end flag\n", __FUNCTION__, __LINE__); + + #ifdef MMI_AI_TALK_DEBUG_TO_FILE + // write to file for debug + mmi_ai_talk_receive_info_write_to_file(BEI_KE_RECEIVE_TTS_AUDIO_TOTAL_FILE, s_ai_talk_type_tts_info_audio_ptr, s_ai_talk_type_tts_info_audio_size); + #endif + mmi_ai_talk_tts_info_result_display(s_ai_talk_type_tts_info_audio_ptr, s_ai_talk_type_tts_info_audio_size); + break; + } + else + { + printf("[@CHENG_DEBUG][%s][%d]: %d\n", __FUNCTION__, __LINE__,value_type_tts_index); + + char * value_type_tts_result_str = cJSON_GetStringValue(cJSON_GetObjectItem(json_type_tts, KEY_TYPE_TTS_RESULT)); + uint32_t value_type_tts_result_len = strlen(value_type_tts_result_str); + debug_type_ai_talk=12; + if(NULL == s_ai_talk_type_tts_info_audio_ptr) + { + s_ai_talk_type_tts_info_audio_ptr = lv_mem_alloc(value_type_tts_result_len + 1); + if(NULL == s_ai_talk_type_tts_info_audio_ptr) + { + printf("[@CHENG_DEBUG][%s][%d]: memory alloc fail\n", __FUNCTION__, __LINE__); + debug_type_ai_talk=5; + return false; + } + _lv_memset_00(s_ai_talk_type_tts_info_audio_ptr, value_type_tts_result_len + 1); + _lv_memcpy(s_ai_talk_type_tts_info_audio_ptr, value_type_tts_result_str, value_type_tts_result_len); + s_ai_talk_type_tts_info_audio_size = value_type_tts_result_len; + } + else + { + s_ai_talk_type_tts_info_audio_ptr = lv_mem_realloc(s_ai_talk_type_tts_info_audio_ptr, s_ai_talk_type_tts_info_audio_size + value_type_tts_result_len + 1); + if(NULL == s_ai_talk_type_tts_info_audio_ptr) + { + printf("[@CHENG_DEBUG][%s][%d]: memory realloc fail\n", __FUNCTION__, __LINE__); + debug_type_ai_talk=6; + return false; + } + _lv_memset_00(s_ai_talk_type_tts_info_audio_ptr + s_ai_talk_type_tts_info_audio_size, value_type_tts_result_len + 1); + _lv_memcpy(s_ai_talk_type_tts_info_audio_ptr + s_ai_talk_type_tts_info_audio_size, value_type_tts_result_str, value_type_tts_result_len); + s_ai_talk_type_tts_info_audio_size += value_type_tts_result_len; + } + } + } + + return true; +} + +bool mmi_ai_talk_type_tts_info_data_processing(unsigned char * next_buff, unsigned int next_buff_len, cJSON * json_type_tts) +{ + // {"answer_id":"1699511956918t","audio":"8f////D/5f8DA9QChwHe + // 7/1YfAQA7/1fAQ/D/5f8DAYADR/9q/+j/AfAQgDR/9/fAQD/5f8DAq/+j/Ag + // 6afA5QfAQ5/4U/C5CQQ=","index":0,"type":"tts_info"} + + // {"answer_id":"1699511956918t","audio":"FgD7/1YADR/9q/+j/AgAlAA==","index":2,"type":"tts_info"} + // {"answer_id":"1699511956918t","audio":"","index":-1,"type":"tts_info"} + + printf("[@CHENG_DEBUG][%s][%d]: receive_size=%d\n", __FUNCTION__, __LINE__, next_buff_len); + + // search end flag + char * t_end_str = "\"index\":-1\,\"type\"\:\"tts_info\"\}"; + //char * t_end_str = "\"type\"\:\"tts_info"; + if(next_buff[0]!='{') + { + printf("[@CHENG_DEBUG][%s][%d]: \n",__FUNCTION__,__LINE__); + }else + { + printf("[@CHENG_DEBUG][%s][%d]: \n",__FUNCTION__,__LINE__); + } + + if(NULL != strstr(next_buff, t_end_str)) + { + printf("[@CHENG_DEBUG][%s][%d]: \n",__FUNCTION__,__LINE__); + + s_ai_talk_type_tts_info_recv_end = true; + } + + // store type tts data + if(false == mmi_ai_talk_type_tts_info_data_store(next_buff, next_buff_len)) + { + printf("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__); + return false; + } + + // parse type tts data + if(true == s_ai_talk_type_tts_info_recv_end) + { + if(false == mmi_ai_talk_type_tts_info_data_parse(json_type_tts)) + { + printf("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__); + //return false; + } + #if ai_test + if(s_ai_talk_type_tts_info_recv_end==false) + { + if(NULL != s_ai_talk_type_tts_info_ptr) + { + lv_mem_free(s_ai_talk_type_tts_info_ptr); + s_ai_talk_type_tts_info_ptr = NULL; + } + s_ai_talk_type_tts_info_size = 0; + + } + else + { + return false; + } + #endif + } + + return true; +} + +bool mmi_ai_talk_data_receive(unsigned char * next_buff, unsigned int next_buff_len) +{ + bool result = false; + cJSON * json_root = NULL; + cJSON * json_type_tts = NULL; + + if(NULL == next_buff || 0 == next_buff_len) + { + printf("[@CHENG_DEBUG][%s][%d]: no data\n", __FUNCTION__, __LINE__); + goto exit_free_res; + } + +#ifdef MMI_AI_TALK_DEBUG_TO_FILE + // write to file for debug + mmi_ai_talk_receive_info_write_to_file(BEI_KE_RECEIVE_FILE, next_buff, next_buff_len); +#endif + + lv_obj_t * activity_obj = mmi_aigc_activity_obj_get(); + if(NULL == activity_obj) + { + printf("[@CHENG_DEBUG][%s][%d]: not in ai talk\n", __FUNCTION__, __LINE__); + goto exit_free_res; + } + + if(false == s_ai_talk_type_tts_info_recv_begin) + { + result = mmi_ai_talk_not_type_tts_info_data_processing(next_buff, next_buff_len, json_root); + } + else + { + result = mmi_ai_talk_type_tts_info_data_processing(next_buff, next_buff_len, json_type_tts); + } + +exit_free_res: + if(NULL != s_ai_talk_type_tts_info_json_ptr) + { + lv_mem_free(s_ai_talk_type_tts_info_json_ptr); + s_ai_talk_type_tts_info_json_ptr = NULL; + } + + if(NULL != json_type_tts) + { + printf("[@CHENG_DEBUG][%s][%d]: free json type tts\n", __FUNCTION__, __LINE__); + cJSON_Delete(json_type_tts); + json_type_tts = NULL; + } + + if(NULL != json_root) + { + printf("[@CHENG_DEBUG][%s][%d]: free json root\n", __FUNCTION__, __LINE__); + cJSON_Delete(json_root); + json_root = NULL; + } +//exit_no_free_res: + return result; +} +#endif + +void mmi_aigc_trans_websocket_recv_data_handler(char * data_ptr, int data_len, int payload_len, int payload_offset) +{ + bool result = false; + cJSON * json_root = NULL; + cJSON * json_result = NULL; + + AIGC_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__); + cplog_printf("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__); + if(NULL == data_ptr || 0 == data_len) + { + AIGC_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__); + return; + } + +#ifdef MMI_AIGC_DEBUG_TO_FILE + mmi_aigc_receive_info_write_to_file(AIGC_RECEIVE_FILE, data_ptr, data_len); +#endif + + json_root = cJSON_Parse(data_ptr); + if(NULL != json_root) + { + // "msg" + char * value_msg_str = cJSON_GetStringValue(cJSON_GetObjectItem(json_root, "msg")); + if(0 != strncmp(value_msg_str, "success", strlen("success"))) + { + AIGC_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: not success\n", __FUNCTION__, __LINE__); + goto EXIT_AND_FREE; + } + + // "event" + char * value_event_str = cJSON_GetStringValue(cJSON_GetObjectItem(json_root, "event")); + if(0 == strncmp(value_event_str, "TranscriptionStarted", strlen("TranscriptionStarted"))) + { + // start + AIGC_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: transcription start\n", __FUNCTION__, __LINE__); + + } + else if(0 == strncmp(value_event_str, "Changed", strlen("Changed"))) + { + // middle + AIGC_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: transcription middle\n", __FUNCTION__, __LINE__); + json_result = cJSON_GetObjectItem(json_root, "result"); + if(NULL != json_result) + { + + + } + } + else if(0 == strncmp(value_event_str, "SentenceEnd", strlen("SentenceEnd"))) + { + // end + AIGC_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: transcription end\n", __FUNCTION__, __LINE__); + json_result = cJSON_GetObjectItem(json_root, "result"); + if(NULL != json_result) + { + char * value_result_str = cJSON_GetStringValue(cJSON_GetObjectItem(json_result, "result")); + uint32_t value_result_len = strlen(value_result_str); + + if(NULL == s_aigc_transcription_result_ptr) + { + s_aigc_transcription_result_ptr = lv_mem_alloc(value_result_len + 1); + if(NULL == s_aigc_transcription_result_ptr) + { + AIGC_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: memory alloc fail\n", __FUNCTION__, __LINE__); + goto EXIT_AND_FREE; + } + _lv_memset_00(s_aigc_transcription_result_ptr, (value_result_len + 1)); + _lv_memcpy(s_aigc_transcription_result_ptr, value_result_str, value_result_len); + s_aigc_transcription_result_size = value_result_len; + } + else + { + //char * temp_ptr = lv_mem_realloc(); + + + } + + // send msg to refresh ui + + } + } + else if(0 == strncmp(value_event_str, "TranscriptionCompleted", strlen("TranscriptionCompleted"))) + { + // stop + AIGC_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: transcription stop\n", __FUNCTION__, __LINE__); + + } + + + + } + +EXIT_AND_FREE: + if(NULL != json_result) + { + AIGC_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: free json result\n", __FUNCTION__, __LINE__); + cplog_printf("[@CHENG_DEBUG][%s][%d]: free json result\n", __FUNCTION__, __LINE__); + cJSON_Delete(json_result); + json_result = NULL; + } + if(NULL != json_root) + { + AIGC_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: free json root\n", __FUNCTION__, __LINE__); + cplog_printf("[@CHENG_DEBUG][%s][%d]: free json root\n", __FUNCTION__, __LINE__); + cJSON_Delete(json_root); + json_root = NULL; + } +} + + + +// chat +void mmi_aigc_chat_websocket_recv_data_handler(char * data_ptr, int data_len, int payload_len, int payload_offset) +{ + bool result = false; + cJSON * json_root = NULL; + cJSON * json_result = NULL; + + AIGC_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__); + cplog_printf("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__); + if(NULL == data_ptr || 0 == data_len) + { + AIGC_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__); + return; + } + +#ifdef MMI_AIGC_DEBUG_TO_FILE + mmi_aigc_receive_info_write_to_file(AIGC_RECEIVE_FILE, data_ptr, data_len); +#endif + + json_root = cJSON_Parse(data_ptr); + if(NULL != json_root) + { + + + } + +EXIT_AND_FREE: + if(NULL != json_result) + { + AIGC_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: free json result\n", __FUNCTION__, __LINE__); + cplog_printf("[@CHENG_DEBUG][%s][%d]: free json result\n", __FUNCTION__, __LINE__); + cJSON_Delete(json_result); + json_result = NULL; + } + if(NULL != json_root) + { + AIGC_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: free json root\n", __FUNCTION__, __LINE__); + cplog_printf("[@CHENG_DEBUG][%s][%d]: free json root\n", __FUNCTION__, __LINE__); + cJSON_Delete(json_root); + json_root = NULL; + } +} + + +#endif + diff --git a/2.sdk/sdk/gui/lv_watch/lv_apps/custom_function/mmi_aigc_data.h b/2.sdk/sdk/gui/lv_watch/lv_apps/custom_function/mmi_aigc_data.h new file mode 100644 index 00000000..1ac9c26a --- /dev/null +++ b/2.sdk/sdk/gui/lv_watch/lv_apps/custom_function/mmi_aigc_data.h @@ -0,0 +1,61 @@ + + + +#ifndef __MMI_AIGC_DATA_H__ +#define __MMI_AIGC_DATA_H__ + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef LV_CONF_INCLUDE_SIMPLE +#include "lvgl.h" +#include "lv_watch_conf.h" +#else +#include "../../../lvgl/lvgl.h" +#include "../../../lv_watch_conf.h" +#endif + +#if 0 // def __MMI_CUSTOM_AIGC_SUPPORT__ + + +typedef enum +{ + MMI_AI_TALK_ACTION_NONE, + + MMI_AI_TALK_ACTION_LOGIN = MMI_AI_TALK_ACTION_NONE, + MMI_AI_TALK_ACTION_AUDIO_DATA, + MMI_AI_TALK_ACTION_AUDIO_DATA_END, + + MMI_AI_TALK_ACTION_MAX +}MMI_AI_TALK_ACTION_CMD_E; + + +typedef enum +{ + MMI_AI_TALK_RECEIVE_TYPE_NONE, + + MMI_AI_TALK_RECEIVE_TYPE_START, + MMI_AI_TALK_RECEIVE_TYPE_TEXT, + MMI_AI_TALK_RECEIVE_TYPE_ANSWER, + MMI_AI_TALK_RECEIVE_TYPE_TTS, + + MMI_AI_TALK_RECEIVE_TYPE_MAX +}MMI_AI_TALK_RECEIVE_TYPE_E; + + + +void mm_ai_talk_send_space_free(MMI_AI_TALK_ACTION_CMD_E action_cmd); +void * mm_ai_talk_send_space_ptr_get(MMI_AI_TALK_ACTION_CMD_E action_cmd); +uint32_t mm_ai_talk_send_space_size_get(MMI_AI_TALK_ACTION_CMD_E action_cmd); +bool mm_ai_talk_login_action(void); +bool mmi_ai_talk_audio_data_send(char * data_buff, int data_buff_len); +bool mmi_ai_talk_data_receive(unsigned char * next_buff, unsigned int next_buff_len); + +#endif + +#ifdef __cplusplus +} /* extern "C" */ +#endif + +#endif diff --git a/2.sdk/sdk/gui/lv_watch/lv_apps/custom_function/mmi_aigc_ui.c b/2.sdk/sdk/gui/lv_watch/lv_apps/custom_function/mmi_aigc_ui.c new file mode 100644 index 00000000..ac8513c0 --- /dev/null +++ b/2.sdk/sdk/gui/lv_watch/lv_apps/custom_function/mmi_aigc_ui.c @@ -0,0 +1,1582 @@ + + + +#include "lv_watch.h" + +#ifdef __MMI_CUSTOM_AIGC_SUPPORT__ + +static lv_signal_cb_t ancient_scrl_signal; + +//static uint8_t s_aigc_init_flag = 0; +//static mmi_aigc_msg_info_t * s_aigc_info = NULL; +static mmi_aigc_msg_item_info_t s_aigc_item_info = {0}; +static uint8_t s_aigc_play_anim_count = 0; +//static char s_aigc_selected_item_index = -1; +static bool s_item_receive_playing = false; +static uint32_t s_aigc_recording_sent_size = 0; +static uint8_t s_aigc_sending_screen_counter = 0; + +static bool mmi_aigc_is_waiting_for_result(void); +static void mmi_aigc_sending_screen_task_stop(void); + + +#include "../../../../product/craneg_modem/pcac/wsclient/libwebsockets/inc/Mmi_aigc_chat_websocket.h" +#include "../../../../product/craneg_modem/pcac/wsclient/libwebsockets/inc/mmi_aigc_trans_websocket.h" + +static uint32_t s_debug_counter = 0; + +static void mmi_aigc_receive_item_info_clean(void) +{ + if(NULL != s_aigc_item_info.msg_data_ptr) + { + AIGC_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__); + lv_mem_free(s_aigc_item_info.msg_data_ptr); + s_aigc_item_info.msg_data_ptr = NULL; + s_aigc_item_info.msg_data_size = 0; + } + + if(NULL != s_aigc_item_info.msg_voice_data_ptr) + { + AIGC_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__); + lv_mem_free(s_aigc_item_info.msg_voice_data_ptr); + s_aigc_item_info.msg_voice_data_ptr = NULL; + s_aigc_item_info.msg_voice_data_size = 0; + } +} + +uint8_t mmi_aigc_info_count_get(void) +{ + uint8_t msg_count = 0; + +#if 1 + if(NULL != s_aigc_item_info.msg_data_ptr) + { + msg_count = 1; + } +#else + msg_count = s_aigc_info->msg_count; +#endif + + return msg_count; +} + +void * mmi_aigc_actId_ext_get(lv_watch_Activity_Id_t actId) +{ + lv_obj_t * activity_obj = lv_watch_get_activity_obj(actId); + if(NULL == activity_obj) + return NULL; + + lv_obj_t * watch_obj = NULL; + lv_watch_get_child_obj(activity_obj, lv_watch_obj_signal, &watch_obj); + if(NULL != watch_obj) + { + void * ext = lv_obj_get_ext_attr(watch_obj); + return ext; + } + + return NULL; +} + +lv_obj_t * mmi_aigc_activity_obj_get(void) +{ + lv_obj_t * activity_obj = NULL; + + activity_obj = lv_watch_get_activity_obj(ACT_ID_AIGC_MAIN); + + return activity_obj; +} + +void mmi_aigc_main_prepare_destory(lv_obj_t * activity_obj) +{ + AIGC_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__); + + // close + mmi_aigc_websocket_app_stop(); + watch_set_suspend_enable(true, ACT_ID_AIGC_MAIN, 0); + + // free resource + //mmi_aigc_data_receive_resource_clean(); + + lv_watch_png_cache_all_free(); + + lv_aigc_ext_t * ext = mmi_aigc_actId_ext_get(ACT_ID_AIGC_MAIN); + if(NULL == ext) + return ; + + AIGC_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__); + + mmi_aigc_list_msg_item_style_reset(ext); + + // free buffer + mmi_aigc_receive_item_info_clean(); + + // + //Hal_NFFS_File_Play_End(); + Hal_Audio_Manage_End_Ind(AUDIO_CTRL_PRIORITY_5); + //Hal_Vibrator_Play_End(); + s_item_receive_playing = false; + + AIGC_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__); +} + +static void mmi_aigc_list_set_slide_enable(lv_watch_obj_ext_t * ext, bool enable) +{ + if(enable) + { + ext->slide_enable = 1; /*enable to slide to the right*/ + } + else + { + ext->slide_enable = 0; /*disable to slide to the right*/ + } +} + +bool mmi_aigc_voice_is_playing(void) +{ + bool result = false; + +#if 0 + lv_aigc_ext_t * ext = mmi_aigc_actId_ext_get(ACT_ID_AIGC_MAIN); + if(NULL != ext && NULL != ext->list) + { + lv_aigc_list_ext_t * list_page_ext = lv_obj_get_ext_attr(ext->list); + if(NULL != list_page_ext->voice_playing_anim.var) + { + result = true; + } + } +#endif + + return result; +} + +bool mmi_aigc_voice_is_recording(void) +{ + bool result = false; + + if(lv_watch_get_activity_obj(ACT_ID_AIGC_RECORDING)) + { + result = true; + } + + return result; +} + +bool mmi_aigc_item_is_sending(void) +{ + bool result = false; + + if(lv_watch_get_activity_obj(ACT_ID_AIGC_SENDING)) + { + result = true; + } + + return result; +} + +void mmi_aigc_receive_audio_play_audio_ctrl_callback(AUDIO_CTRL_PRIORITY priority) +{ + printf("[@CHENG_DEBUG][%s][%d]: priority=%d\n", __FUNCTION__, __LINE__, priority); + + if(AUDIO_CTRL_PRIORITY_5 == priority) + { + + } + else if(AUDIO_CTRL_PRIORITY_5 > priority) + { + Hal_NFFS_File_Play_End(); + Hal_Audio_Manage_End_Ind(AUDIO_CTRL_PRIORITY_5); + Hal_Vibrator_Play_End(); + s_item_receive_playing = false; + } +} + +void mmi_aigc_receive_audio_play_over_cb(void *para) +{ + printf("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__); + + Hal_NFFS_File_Play_End(); + Hal_Audio_Manage_End_Ind(AUDIO_CTRL_PRIORITY_5); + Hal_Vibrator_Play_End(); + s_item_receive_playing = false; +} + +static bool mmi_aigc_item_info_write_to_file(char * file_path, char * file_buf, uint32_t file_size) +{ + lv_fs_file_t file_p; + lv_fs_res_t res; + uint32_t bytes_write = 0; + + res = lv_fs_open(&file_p, file_path, LV_FS_MODE_WR); + if(LV_FS_RES_OK != res) + { + printf("[@CHENG_DEBUG][%s][%d]: errno=%d\n", __FUNCTION__, __LINE__, res); + lv_fs_close(&file_p); + return false; + } + res = lv_fs_write(&file_p, file_buf, file_size, &bytes_write); + lv_fs_close(&file_p); + if(LV_FS_RES_OK != res) + { + printf("[@CHENG_DEBUG][%s][%d]: errno=%d\n", __FUNCTION__, __LINE__, res); + return false; + } + printf("[@CHENG_DEBUG][%s][%d]: file_size=%d,write_size=%d\n", __FUNCTION__, __LINE__, file_size, bytes_write); + + return true; +} + +void mmi_aigc_receive_update_ui(void) +{ + printf("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__); + + if(AUDIO_CTRL_PRIORITY_5 == Hal_Audio_Manage_Start_Req(AUDIO_CTRL_PRIORITY_5, mmi_aigc_receive_audio_play_audio_ctrl_callback)) + { + if(false == s_item_receive_playing) + { + s_item_receive_playing = true; + + //Hal_NFFS_File_Play_Onetime(AUDIO_WECHAT_RECEIVE, (HAL_SPEAKER_GAIN)query_current_volume(), mmi_aigc_receive_audio_play_over_cb, NULL); + //Hal_Vibrator_Play_Onetime(NULL, 1000); + } + + mmi_aigc_sending_screen_exit(); + + if(lv_watch_get_activity_obj(ACT_ID_AIGC_MAIN)) + { + mmi_aigc_main_screen_refresh(); + } + else + { + //mmi_aigc_create_event_cb(NULL, LV_EVENT_CLICKED); + } + } +} + +bool mmi_aigc_model_answer_result_display(char * data_buff, int data_buff_len) +{ + if(NULL == data_buff || 0 == data_buff_len) + { + printf("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__); + return false; + } + + // if(false == mmi_aigc_is_waiting_for_result()) + // { + // printf("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__); + // return false; + // } + + //mmi_aigc_sending_screen_task_stop(); + + if(NULL != s_aigc_item_info.msg_data_ptr) + { + lv_mem_free(s_aigc_item_info.msg_data_ptr); + s_aigc_item_info.msg_data_ptr = NULL; + } + s_aigc_item_info.msg_data_ptr = lv_mem_alloc(data_buff_len + 1); + if(NULL == s_aigc_item_info.msg_data_ptr) + { + printf("[@CHENG_DEBUG][%s][%d]: alloc memory fail\n", __FUNCTION__, __LINE__); + return false; + } + _lv_memset_00(s_aigc_item_info.msg_data_ptr, data_buff_len + 1); + _lv_memcpy(s_aigc_item_info.msg_data_ptr, data_buff, data_buff_len); + s_aigc_item_info.msg_data_size = data_buff_len; + + printf("[@CHENG_DEBUG][%s][%d]: msg_data_size=%d,msg_data_ptr=0x%x\n", __FUNCTION__, __LINE__, s_aigc_item_info.msg_data_size, s_aigc_item_info.msg_data_ptr); + + return true; +} + + +#define BEI_KE_DEBUG_FILE "C:/bei_ke_debug.txt" +bool mmi_aigc_debug_info_write_to_file(char * path, char * info_buf, uint32_t info_size) +{ + lv_fs_file_t file_p; + lv_fs_res_t res; + uint32_t bytes_write = 0; + + res = lv_fs_open(&file_p, path, LV_FS_MODE_WR | LV_FS_MODE_APPEND); + if(LV_FS_RES_OK != res) + { + printf("[@CHENG_DEBUG][%s][%d]: errno=%d\n", __FUNCTION__, __LINE__, res); + lv_fs_close(&file_p); + return false; + } + + hal_rtc_t cur_time = {0}; + char str_time[24] = {0}; + + Hal_Rtc_Gettime(&cur_time); + sprintf(str_time, "\n[%04d%02d%02d_%02d%02d%02d]", + cur_time.tm_year, + cur_time.tm_mon, + cur_time.tm_mday, + cur_time.tm_hour, + cur_time.tm_min, + cur_time.tm_sec); + + //lv_fs_seek + res = lv_fs_write(&file_p, str_time, strlen(str_time), &bytes_write); + if(LV_FS_RES_OK != res) + { + printf("[@CHENG_DEBUG][%s][%d]: errno=%d\n", __FUNCTION__, __LINE__, res); + lv_fs_close(&file_p); + return false; + } + + res = lv_fs_write(&file_p, info_buf, info_size, &bytes_write); + lv_fs_close(&file_p); + if(LV_FS_RES_OK != res) + { + printf("[@CHENG_DEBUG][%s][%d]: errno=%d\n", __FUNCTION__, __LINE__, res); + return false; + } + printf("[@CHENG_DEBUG][%s][%d]: file_size=%d,write_size=%d\n", __FUNCTION__, __LINE__, info_size, bytes_write); + + return true; +} + + +static void mmi_aigc_tts_info_result_play_over_cb(void * para) +{ + printf("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__); + + if(NULL != s_aigc_item_info.msg_voice_data_ptr) + { + lv_mem_free(s_aigc_item_info.msg_voice_data_ptr); + s_aigc_item_info.msg_voice_data_ptr = NULL; + } + s_aigc_item_info.msg_voice_data_size = 0; +} + +#define blockAlign_16 1 +int simplest_pcm16le_to_wave(void *pcm_str,int pcm_str_size) +{ + int i=0; + int x=0; + char buf_str[64]={0}; + while (1) + { + i++; + + char temp_str[16]={0}; + if(i==14) + { + break; + } + switch (i) + { + case 1: + sprintf(buf_str,"%s","RIFF"); //4 + x=4; + break; + case 2: + for(int i=0;i<4;i++) + { + char temp= (pcm_str_size+32)>>(8*i) & 0xff; + buf_str[x] = temp; + x++; + // sprintf(buf_str,"%s%c",buf_str,temp); //8 + } + + break; + case 3: + sprintf(temp_str,"%s","WAVE"); //12 + _lv_memcpy(buf_str+x,temp_str,4); + x+=4; + break; + case 4: + sprintf(temp_str,"%s","fmt "); //16 + _lv_memcpy(buf_str+x,temp_str,4); + x+=4; + break; + case 5: + sprintf(temp_str,"%c%c%c%c",0x10,0,0,0); // 20 + _lv_memcpy(buf_str+x,temp_str,4); + x+=4; + + break; + case 6: + sprintf(temp_str,"%c%c",1,0);//22 + _lv_memcpy(buf_str+x,temp_str,2); + x+=2; + break; + case 7: + sprintf(temp_str,"%c%c",1,0);//24 + _lv_memcpy(buf_str+x,temp_str,2); + x+=2; + break; + case 8: + sprintf(temp_str,"%c%c%c%c",0x40,0x1f,0x00,0x00);//28 + _lv_memcpy(buf_str+x,temp_str,4); + x+=4; + break; + case 9: + #if blockAlign_16 + sprintf(temp_str,"%c%c%c%c",0x80,0x3e,0x00,0x00);//每秒字节数32 3200 + #else + sprintf(temp_str,"%c%c%c%c",0x40,0x1f,0x00,0x00);//28 16000 + #endif + + _lv_memcpy(buf_str+x,temp_str,4); + x+=4; + break; + case 10: + #if blockAlign_16 + sprintf(temp_str,"%c%c",0x02,0x00);//每个采样比特数36 + #else + sprintf(temp_str,"%c%c",0x01,0x00);//每个采样字节数32 + #endif + _lv_memcpy(buf_str+x,temp_str,2); + x+=2; + break; + case 11: + #if blockAlign_16 + sprintf(temp_str,"%c%c",0x10,0x00);//每个采样比特数36 + #else + sprintf(temp_str,"%c%c",0x08,0x00);//每个采样比特数36 + #endif + _lv_memcpy(buf_str+x,temp_str,2); + x+=2; + break; + case 12: + sprintf(temp_str,"%s","data");//40 + _lv_memcpy(buf_str+x,temp_str,4); + x+=4; + break; + case 13: + for(int i=0;i<4;i++) + { + char temp= (pcm_str_size)>>(8*i) & 0xff; + buf_str[x] = temp; + x++; + } + break; + } + } + + void * new_str=lv_mem_alloc(pcm_str_size +44+ + 1); + _lv_memset_00(new_str, pcm_str_size +44+ 1); + _lv_memcpy(new_str, buf_str, 44); + _lv_memcpy(new_str+44, s_aigc_item_info.msg_voice_data_ptr, pcm_str_size); + + s_aigc_item_info.msg_voice_data_ptr = lv_mem_realloc(s_aigc_item_info.msg_voice_data_ptr, pcm_str_size+44+1); + _lv_memcpy(s_aigc_item_info.msg_voice_data_ptr,new_str,pcm_str_size + 44); + lv_mem_free(new_str); + + #if 0 + char * info_buf = ""; + sprintf(info_buf,"测试次数 "); + uint32_t info_size = strlen(info_buf); + { + lv_fs_file_t file_p; + lv_fs_res_t res; + uint32_t bytes_write = 0; + + res = lv_fs_open(&file_p, "C:/bei_ke_debug_17_06.txt", LV_FS_MODE_WR | LV_FS_MODE_APPEND); + if(LV_FS_RES_OK != res) + { + printf("[@CHENG_DEBUG][%s][%d]: errno=%d\n", __FUNCTION__, __LINE__, res); + lv_fs_close(&file_p); + return false; + } + printf("[@CHENG_DEBUG][%s][%d]:\n", __FUNCTION__, __LINE__); + res = lv_fs_write(&file_p, info_buf, info_size, &bytes_write); + lv_fs_close(&file_p); + if(LV_FS_RES_OK != res) + { + printf("[@CHENG_DEBUG][%s][%d]: errno=%d\n", __FUNCTION__, __LINE__, res); + return false; + } + printf("[@CHENG_DEBUG][%s][%d]: file_size=%d,write_size=%d\n", __FUNCTION__, __LINE__, info_size, bytes_write); + + //return true; + } + #endif + return 0; +} + + +bool mmi_aigc_tts_info_result_display(char * data_buff, int data_buff_len) +{ + uint32_t output_len = 0; + + uint32_t fs_total = 0; + uint32_t fs_free = 0; + lv_fs_free_space('C', &fs_total, &fs_free); + printf("[@CHENG_DEBUG][%s][%d]: space total = %dB, free = %dB\n", __FUNCTION__, __LINE__, fs_total, fs_free); + + if(NULL == data_buff || 0 == data_buff_len) + { + printf("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__); + return false; + } + + if(false == mmi_aigc_is_waiting_for_result()) + { + printf("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__); + return false; + } + + mmi_aigc_sending_screen_task_stop(); + + // ui + mmi_watch_wake_up(); + //mmi_ui_msg_action_aigc_incoming(); + + + if(NULL != s_aigc_item_info.msg_voice_data_ptr) + { + lv_mem_free(s_aigc_item_info.msg_voice_data_ptr); + s_aigc_item_info.msg_voice_data_ptr = NULL; + } + s_aigc_item_info.msg_voice_data_ptr = lv_mem_alloc(data_buff_len); + if(NULL == s_aigc_item_info.msg_voice_data_ptr) + { + printf("[@CHENG_DEBUG][%s][%d]: memory alloc fail\n", __FUNCTION__, __LINE__); + return false; + } + _lv_memset_00(s_aigc_item_info.msg_voice_data_ptr, data_buff_len); + //mbedtls_base64_encode mbedtls_base64_decode + if(0 != mbedtls_base64_decode(s_aigc_item_info.msg_voice_data_ptr, data_buff_len, &output_len, data_buff, data_buff_len)) + { + printf("[@CHENG_DEBUG][%s][%d]: base64 decode error\n", __FUNCTION__, __LINE__); + return false; + } + s_aigc_item_info.msg_voice_data_size = output_len; + simplest_pcm16le_to_wave(s_aigc_item_info.msg_voice_data_ptr,output_len); + s_aigc_item_info.msg_voice_data_size+=44; + printf("[@CHENG_DEBUG][%s][%d]: len1=%d,len2=%d\n", __FUNCTION__, __LINE__, data_buff_len, output_len); + //mmi_aigc_debug_info_write_to_file(BEI_KE_DEBUG_FILE, s_aigc_item_info.msg_voice_data_ptr, s_aigc_item_info.msg_voice_data_size); + + uint8_t volume = 0; +#ifdef __MMI_USER_PROFILE_SUPPORT__ + volume = mmi_user_profile_current_mode_remind_volume_get(); +#else + volume = query_current_volume(); +#endif + //Hal_NFFS_File_Play_Onetime("C:ai_take.wav",volume,mmi_aigc_tts_info_result_play_over_cb,NULL); + Hal_Tone_Play_Onetime((uint32_t *)s_aigc_item_info.msg_voice_data_ptr, + s_aigc_item_info.msg_voice_data_size, + volume, + mmi_aigc_tts_info_result_play_over_cb, + NULL); + + + return true; +} + +bool mmi_aigc_send_to_server(void) +{ + bool result = false; // true-success; false-fail + + lv_aigc_ext_t * ext = (lv_aigc_ext_t *)mmi_aigc_actId_ext_get(ACT_ID_AIGC_MAIN); + if(NULL == ext) + { + printf("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__); + return false; + } + + printf("[@CHENG_DEBUG][%s][%d]: size=%d, buf=0x%x\n", __FUNCTION__, __LINE__, ext->record_size, ext->record_buffer); + + uint32_t file_size = ext->record_size - s_aigc_recording_sent_size; + if(0 >= file_size) + { + printf("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__); + return false; + } + char * file_buf = lv_mem_alloc(file_size + 1); + if(NULL == file_buf) + { + printf("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__); + + lv_mem_free(ext->record_buffer); + ext->record_buffer = NULL; + ext->record_size = 0; + return false; + } + _lv_memset_00(file_buf, file_size + 1); + _lv_memcpy(file_buf, ext->record_buffer + s_aigc_recording_sent_size, file_size); + lv_mem_free(ext->record_buffer); + ext->record_buffer = NULL; + + //if(true == mmi_aigc_audio_data_send(file_buf, file_size)) + { + result = true; + } + lv_mem_free(file_buf); + s_aigc_recording_sent_size = 0; + + return result; +} + +void mmi_aigc_sending_screen_prepare_destory(lv_obj_t * activity_obj) +{ + printf("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__); + + lv_watch_png_cache_all_free(); + + mmi_aigc_sending_screen_task_stop(); + + watch_set_suspend_enable(true, ACT_ID_AIGC_SENDING, 0); + watch_wakeup_time_reset(); +} + +void mmi_aigc_sending_screen_exit(void) +{ + mmi_aigc_sending_screen_prepare_destory(NULL); + + //delete sending screen + //lv_watch_del_interface(ACT_ID_AIGC_SENDING); + lv_obj_t * obj = lv_watch_get_activity_obj(ACT_ID_AIGC_SENDING); + if(NULL != obj) + { + printf("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__); + lv_obj_del(obj); + } +} + +void mmi_aigc_sending_fail_screen_exit(void) +{ + mmi_aigc_sending_screen_exit(); + //return main list screen + mmi_aigc_main_screen_refresh(); +} + + +#define TIMEOUT_SEND_END_CHAR_COUNT (3) // 500ms *3 +#define TIMEOUT_WAIT_FOR_RESULT_COUNT (16) // 500ms *3 + 500ms * 16 +#define TIMEOUT_GET_RESULT_FAIL_COUNT (21) // 500ms *3 + 500ms * 16 + 500ms * 3 +//static hal_rtc_t send_time; +static bool mmi_aigc_is_waiting_for_result(void) +{ + bool result = false; + + printf("[@CHENG_DEBUG][%s][%d]: %d\n", __FUNCTION__, __LINE__, s_aigc_sending_screen_counter); + if(1 < s_aigc_sending_screen_counter + && TIMEOUT_WAIT_FOR_RESULT_COUNT > s_aigc_sending_screen_counter + ) + { + result = true; + } + // hal_rtc_t cur_time = {0}; + // Hal_Rtc_Gettime(&cur_time); + // if(send_time.) + + return result; +} + +static void mmi_aigc_sending_screen_task_stop(void) +{ + printf("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__); + + lv_aigc_sending_ext_t * sending_ext = (lv_aigc_sending_ext_t *)mmi_aigc_actId_ext_get(ACT_ID_AIGC_SENDING); + if(NULL != sending_ext) + { + if(NULL != sending_ext->sending_screen_task_id) + { + lv_task_del(sending_ext->sending_screen_task_id); + sending_ext->sending_screen_task_id = NULL; + } + } + + s_aigc_sending_screen_counter = -1; +} + +void mmi_aigc_sending_screen_task_cb(lv_task_t * task) +{ + s_aigc_sending_screen_counter++; + printf("[@CHENG_DEBUG][%s][%d]: %d\n", __FUNCTION__, __LINE__, s_aigc_sending_screen_counter); + + switch(s_aigc_sending_screen_counter) + { + case TIMEOUT_SEND_END_CHAR_COUNT: + //mmi_aigc_audio_data_send_end_char(); + break; + + case 5: + lv_aigc_sending_ext_t * sending_ext = (lv_aigc_sending_ext_t *)(task->user_data); + lv_obj_set_hidden(sending_ext->gif_obj, false); + // lv_obj_t * img = lv_img_create(sending_ext, NULL); + // LV_ASSERT_MEM(img); + // lv_img_set_src(img, ICON_UPAY_BINDING); + // lv_obj_set_size(img, LV_HOR_RES, LV_VER_RES); + // lv_obj_align(img, sending_ext, LV_ALIGN_CENTER, 0, 0); + + + + + break; + case TIMEOUT_WAIT_FOR_RESULT_COUNT: + //lv_aigc_sending_ext_t * sending_ext = (lv_aigc_sending_ext_t *)(task->user_data); + // lv_obj_set_hidden(sending_ext->label_sending, true); + // lv_obj_set_hidden(sending_ext->label_result, false); + break; + + case TIMEOUT_GET_RESULT_FAIL_COUNT: + + mmi_aigc_sending_fail_screen_exit(); + + break; + + default: + break; + } +} + +lv_obj_t * mmi_aigc_sending_screen_create(lv_obj_t * activity_obj) +{ + printf("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__); + + if(NULL == activity_obj) + { + lv_watch_activity_ext_t activity_ext = {0}; + + activity_ext.actId = ACT_ID_AIGC_SENDING; + activity_ext.create = (lv_watch_activity_create_f_t)mmi_aigc_sending_screen_create; + activity_ext.prepare_destory = mmi_aigc_sending_screen_prepare_destory; + activity_obj = lv_watch_creat_activity_obj(&activity_ext); + if(NULL == activity_obj) + return NULL; + } + + lv_obj_t * obj = lv_watch_obj_create(activity_obj); + if(NULL == obj) + return NULL; + lv_aigc_sending_ext_t * sending_ext = (lv_aigc_sending_ext_t *)lv_obj_allocate_ext_attr(obj, sizeof(lv_aigc_sending_ext_t)); + if(NULL == sending_ext) + return NULL; + + mmi_aigc_list_set_slide_enable(&sending_ext->old_ext, false); /*prevent to slide out while recording*/ + + mmi_aigc_send_to_server(); + s_aigc_sending_screen_counter = 0; + sending_ext->sending_screen_task_id = lv_task_create(mmi_aigc_sending_screen_task_cb, 500, LV_TASK_PRIO_HIGH, sending_ext); + + lv_obj_t * cont = lv_cont_create(obj, NULL); + lv_obj_set_size(cont, lv_obj_get_width(obj), lv_obj_get_height(obj)); + lv_obj_align(cont, obj, LV_ALIGN_CENTER, 0, 0); + lv_obj_set_style_local_bg_color(cont, LV_CONT_PART_MAIN, LV_STATE_DEFAULT, lv_color_make(0x00, 0x00, 0x00)); + + lv_obj_t * img1 = lv_cont_create(obj, NULL); + gif_info_t * upay_binding_gif=gif_open(img1, ANIM_SOS, 0); + lv_obj_set_size(img1, 80, 80); + lv_obj_align(img1, NULL , LV_ALIGN_CENTER, 0, -20); + sending_ext->gif_obj=img1; + //lv_obj_set_hidden(sending_ext->gif_obj, true); + + sending_ext->label_sending = lv_label_create(cont, NULL); + lv_obj_add_style(sending_ext->label_sending, LV_LABEL_PART_MAIN, &lv_watch_font26); + lv_label_set_text_id(sending_ext->label_sending, WATCH_TEXT_ID_GETTING_RESULT); + lv_obj_align(sending_ext->label_sending, NULL, LV_ALIGN_CENTER, 0, 45); + + sending_ext->label_result = lv_label_create(cont, sending_ext->label_sending); + lv_label_set_text_id(sending_ext->label_result, WATCH_TEXT_ID_GET_RESULT_FAIL); + lv_obj_align(sending_ext->label_result, NULL, LV_ALIGN_CENTER, 0, 30); + + lv_obj_set_hidden(sending_ext->label_sending, false); + lv_obj_set_hidden(sending_ext->label_result, true); + + watch_set_suspend_enable(false, ACT_ID_AIGC_SENDING, 0); + + return obj; +} + +void mmi_aigc_recording_release_event_cb(lv_obj_t * obj, lv_event_t e) +{ + printf("[@CHENG_DEBUG][%s][%d]: event=%d\n", __FUNCTION__, __LINE__, e); + +#if 0 + if(LV_EVENT_RELEASED == e) //(LV_EVENT_CLICKED == e) + { + printf("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__); + + lv_watch_del_interface(ACT_ID_AIGC_RECORDING); + mmi_aigc_sending_screen_create(NULL); + } +#endif +} + +void mmi_aigc_recording_anim(lv_anim_t * a) +{ + s_aigc_play_anim_count++; + if(0 == (s_aigc_play_anim_count % 4)) + { + int8_t count_down = MMI_AIGC_DATA_RECORD_DURATION_MAX - s_aigc_play_anim_count / 4; + printf("[@CHENG_DEBUG][%s][%d]: count down=%d\n", __FUNCTION__, __LINE__, count_down); + + if(0 < count_down) + { + lv_obj_t * label_time = a->var; + const char * content = lv_lang_get_text(WATCH_TEXT_ID_AUDIO_RECORDING); // WATCH_TEXT_ID_RELEASE_SENDING); + uint8_t len = strlen(content) + 8; + char * text = (char *)lv_mem_alloc(len); + snprintf(text, len, "%s %d", content, count_down); + lv_label_set_text(label_time, text); + lv_mem_free(text); + } + } +} + +bool mmi_aigc_recording_stop(bool is_cancel) +{ + uint32_t duration_ms = 0; + uint32_t size = 0; + + Hal_Record_Buffer_Stop_Req(&size, &duration_ms); + Hal_Audio_Manage_End_Ind(AUDIO_CTRL_PRIORITY_5); + + lv_aigc_ext_t * ext = (lv_aigc_ext_t *)mmi_aigc_actId_ext_get(ACT_ID_AIGC_MAIN); + if(NULL == ext) + return false; + + if(true == is_cancel) + { + printf("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__); + lv_mem_free(ext->record_buffer); + ext->record_buffer = NULL; + ext->record_size = 0; + return false; + } + + if(MMI_AIGC_DATA_WAV_HEAD_SIZE >= size) + { + printf("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__); + lv_mem_free(ext->record_buffer); + ext->record_buffer = NULL; + ext->record_size = 0; + return false; + } + ext->record_size = size; + + return true; +} + +void mmi_aigc_recording_audio_ctrl_callback(AUDIO_CTRL_PRIORITY priority) +{ + printf("[@CHENG_DEBUG][%s][%d]: priority=%d\n", __FUNCTION__, __LINE__, priority); + + if(AUDIO_CTRL_PRIORITY_5 == priority) + { + if(false == watch_is_ready()) + { + printf("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__); + return; + } + } + else if(AUDIO_CTRL_PRIORITY_5 > priority) + { + mmi_aigc_recording_stop(true); + + //lv_watch_del_interface(ACT_ID_AIGC_RECORDING); + lv_obj_t * activity_obj = lv_watch_get_activity_obj(ACT_ID_AIGC_RECORDING); + if(NULL != activity_obj) + { + lv_obj_del(activity_obj); + } + } +} + +void mmi_aigc_recording_task_cb(lv_task_t * task) +{ + lv_aigc_ext_t * ext = (lv_aigc_ext_t *)mmi_aigc_actId_ext_get(ACT_ID_AIGC_MAIN); + if(NULL == ext) + return ; + + if(0 == ext->old_ext.element_click_en) + { + /*sliding to the right, not click button*/ + return; + } + + lv_obj_t * activity_obj; + MCI_EVNET_T event = (MCI_EVNET_T) (task->user_data); + printf("[@CHENG_DEBUG][%s][%d]: event=%d\n", __FUNCTION__, __LINE__, event); + + switch(event) + { + case MCI_EVENT_EOS: + printf("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__); + + mmi_aigc_recording_stop(false); + activity_obj = lv_watch_get_activity_obj(ACT_ID_AIGC_RECORDING); + if(NULL != activity_obj) + { + lv_obj_del(activity_obj); + } + mmi_aigc_sending_screen_create(NULL); + break; + + case MCI_EVENT_ERROR: + printf("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__); + + mmi_aigc_recording_stop(true); + activity_obj = lv_watch_get_activity_obj(ACT_ID_AIGC_RECORDING); + if(NULL != activity_obj) + { + lv_obj_del(activity_obj); + } + break; + + //case MCI_EVENT_INFO: + // break; + + default: + break; + } +} + +void mmi_aigc_recording_cb(MCI_EVNET_T event, MCI_INFO_T info_type, int32_t value) +{ + printf("[@CHENG_DEBUG][%s][%d]: event=%d,type=%d,value=%d\n", __FUNCTION__, __LINE__, event, info_type, value); + + if(MCI_EVENT_INFO != event) + { + //recording_ext->event = event; + lv_task_t * record_task = lv_task_create(mmi_aigc_recording_task_cb, 10, LV_TASK_PRIO_HIGH, event); + lv_task_once(record_task); + } + else // MCI_EVENT_INFO == event + { + if(MCI_INFO_RECORDER_CUR_SIZE == info_type) + { + lv_aigc_ext_t * ext = (lv_aigc_ext_t *)mmi_aigc_actId_ext_get(ACT_ID_AIGC_MAIN); + if(NULL == ext) + { + printf("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__); + return; + } + + static uint8_t t_value = 0; + t_value++; + if(2 == t_value) + { + t_value = 0; + + uint32_t sending_size = value - s_aigc_recording_sent_size; + if(0 >= sending_size) + { + printf("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__); + return; + } + + char * sending_buf = lv_mem_alloc(sending_size + 1); + if(NULL == sending_buf) + { + printf("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__); + return; + } + _lv_memset_00(sending_buf, sending_size + 1); + _lv_memcpy(sending_buf, ext->record_buffer + s_aigc_recording_sent_size, sending_size); + + mmi_aigc_audio_data_send(sending_buf, sending_size); + + lv_mem_free(sending_buf); + s_aigc_recording_sent_size += sending_size; + } + } + } +} + + +void mmi_aigc_recording_screen_prepare_destory(lv_obj_t * activity_obj) +{ + printf("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__); + + lv_watch_png_cache_all_free(); + + //mmi_aigc_recording_stop(true); + uint32_t duration_ms = 0; + uint32_t size = 0; + + Hal_Record_Buffer_Stop_Req(&size, &duration_ms); + Hal_Audio_Manage_End_Ind(AUDIO_CTRL_PRIORITY_5); +} + +lv_obj_t * mmi_aigc_recording_screen_create(lv_obj_t * activity_obj) +{ + printf("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__); + + if(NULL == activity_obj) + { + lv_watch_activity_ext_t activity_ext = {0}; + + activity_ext.actId = ACT_ID_AIGC_RECORDING; + activity_ext.create = mmi_aigc_recording_screen_create; + activity_ext.prepare_destory = mmi_aigc_recording_screen_prepare_destory; + activity_obj = lv_watch_creat_activity_obj(&activity_ext); + if(NULL == activity_obj) + return NULL; + } + + lv_obj_t * obj = lv_watch_obj_create(activity_obj); + LV_ASSERT_MEM(obj); + + lv_aigc_recording_ext_t * recording_ext = lv_obj_allocate_ext_attr(obj, sizeof(lv_aigc_recording_ext_t)); + LV_ASSERT_MEM(recording_ext); + + lv_obj_t * cont = lv_cont_create(obj, NULL); + lv_obj_set_size(cont, lv_obj_get_width(obj), lv_obj_get_height(obj)); + lv_obj_align(cont, obj, LV_ALIGN_CENTER, 0, 0); + lv_obj_set_style_local_bg_color(cont, LV_CONT_PART_MAIN, LV_STATE_DEFAULT, lv_color_make(0x00, 0x00, 0x00)); + //lv_obj_set_click(cont, true); + //lv_obj_set_event_cb(cont, mmi_aigc_recording_release_event_cb); + //lv_obj_add_protect(cont, LV_PROTECT_PRESS_LOST); + + lv_obj_t * label_time = lv_label_create(cont, NULL); + lv_obj_add_style(label_time, LV_LABEL_PART_MAIN, &lv_watch_font26); + const char * rel_snd = lv_lang_get_text(WATCH_TEXT_ID_AUDIO_RECORDING); // WATCH_TEXT_ID_RELEASE_SENDING); + uint8_t len = strlen(rel_snd) + 4; + char * text = (char *)lv_mem_alloc(len); + snprintf(text, len, "%s %d", rel_snd, MMI_AIGC_DATA_RECORD_DURATION_MAX); + lv_label_set_text(label_time, text); + lv_mem_free(text); + //lv_obj_align(label_time, label_warning, LV_ALIGN_OUT_BOTTOM_MID, 0, 30); + lv_obj_align(label_time, cont, LV_ALIGN_IN_TOP_MID, 0, 75); + recording_ext->label = label_time; + + lv_obj_t * img_release_snd = lv_img_create(cont, NULL); + lv_img_set_src(img_release_snd, ICON_WECHAT_RECORD_BUTTON_PRESSED); + lv_obj_align(img_release_snd, cont, LV_ALIGN_IN_BOTTOM_MID, 0, -8); + + lv_anim_t a; + lv_anim_init(&a); + lv_anim_set_var(&a, label_time); + lv_anim_set_start_cb(&a, (lv_anim_ready_cb_t)mmi_aigc_recording_anim); + lv_anim_set_repeat_count(&a, LV_ANIM_REPEAT_INFINITE); + lv_anim_set_time(&a, 249); + lv_anim_start(&a); + s_aigc_play_anim_count = 0; + + lv_aigc_ext_t * ext = (lv_aigc_ext_t *)mmi_aigc_actId_ext_get(ACT_ID_AIGC_MAIN); + if(NULL == ext) + return NULL; + + if(NULL != ext->record_buffer) + { + lv_mem_free(ext->record_buffer); + ext->record_buffer = NULL; + } + ext->record_buffer = (uint8_t *)lv_mem_alloc(MMI_AIGC_DATA_RECORD_SIZE_MAX); + if(NULL != ext->record_buffer) + { + _lv_memset_00(ext->record_buffer, MMI_AIGC_DATA_RECORD_SIZE_MAX); + + if(AUDIO_CTRL_PRIORITY_5 == Hal_Audio_Manage_Start_Req(AUDIO_CTRL_PRIORITY_5, mmi_aigc_recording_audio_ctrl_callback)) + { + s_aigc_recording_sent_size = 0; + + Hal_Record_Buffer_With_Format_Req(ext->record_buffer, + MMI_AIGC_DATA_RECORD_SIZE_MAX, + MMI_AIGC_DATA_RECORD_DURATION_MAX * 1000, + mmi_aigc_recording_cb, + (mci_type_enum)MMI_AIGC_AUDIO_FORMAT); + } + } + + return obj; +} + +void mmi_aigc_record_button_event_cb(lv_obj_t * obj, lv_event_t e) +{ + if(LV_EVENT_LONG_PRESSED == e) + { + printf("[@CHENG_DEBUG][%s][%d]: event=%d\n", __FUNCTION__, __LINE__, e); + + lv_aigc_ext_t * ext = mmi_aigc_actId_ext_get(ACT_ID_AIGC_MAIN); + if(NULL == ext) + return ; + + mmi_aigc_list_set_slide_enable(&ext->old_ext, true); /*reset slide_enable at the end of recording*/ + + if(0 == ext->old_ext.element_click_en) + { + /*sliding to the right, not click button*/ + return; + } + + // free resource + //mmi_aigc_data_receive_resource_clean(); + + mmi_aigc_receive_item_info_clean(); + + mmi_aigc_list_set_slide_enable(&ext->old_ext, false); /*prevent to slide out while recording*/ + mmi_aigc_start_transcription_send(); + mmi_aigc_recording_screen_create(NULL); + } + else if(LV_EVENT_CLICKED == e || LV_EVENT_PRESS_LOST == e) + { + printf("[@CHENG_DEBUG][%s][%d]: event=%d\n", __FUNCTION__, __LINE__, e); + + #if 0 + s_debug_counter++; + if(2 == s_debug_counter) + { + mmi_aigc_start_transcription_send(); + } + else if(3 == s_debug_counter) + { + __mmi_aigc_audio_data_send(0); + } + else if(4 == s_debug_counter) + { + __mmi_aigc_audio_data_send(1); + } + #endif + + lv_obj_t * activity_obj = lv_watch_get_activity_obj(ACT_ID_AIGC_RECORDING); + if(NULL != activity_obj) + { + lv_aigc_ext_t * ext = mmi_aigc_actId_ext_get(ACT_ID_AIGC_MAIN); + if(NULL == ext) + return ; + + lv_aigc_recording_ext_t * recording_ext = (lv_aigc_recording_ext_t *)mmi_aigc_actId_ext_get(ACT_ID_AIGC_RECORDING); + if(NULL == recording_ext) + return NULL; + + printf("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__); + mmi_aigc_list_set_slide_enable(&ext->old_ext, true); /*reset slide_enable at the end of recording*/ + + #if 0 + lv_indev_t * indev = lv_indev_get_act(); + if(indev) + { + lv_coord_t point_y = indev->proc.types.pointer.last_point.y; + lv_coord_t img_record_top = obj->coords.y1; + if(30 < img_record_top - point_y) // (point_y < (img_record_top - 20)) + { + printf("[@CHENG_DEBUG][%s][%d]: indev_y=%d, img_y=%d\n", __FUNCTION__, __LINE__, point_y, img_record_top); + mmi_aigc_recording_stop(true); + lv_obj_del(activity_obj); + //return main list screen + mmi_aigc_main_screen_refresh(); + + return; + } + } + #endif + + printf("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__); + mmi_aigc_recording_stop(false); + lv_obj_del(activity_obj); + mmi_aigc_sending_screen_create(NULL); + } + } + else if(LV_EVENT_PRESSED == e) + { + printf("[@CHENG_DEBUG][%s][%d]: event=%d\n", __FUNCTION__, __LINE__, e); + + lv_aigc_ext_t * ext = mmi_aigc_actId_ext_get(ACT_ID_AIGC_MAIN); + if(NULL == ext) + return ; + + // + Hal_NFFS_File_Play_End(); + Hal_Audio_Manage_End_Ind(AUDIO_CTRL_PRIORITY_5); + Hal_Vibrator_Play_End(); + + mmi_aigc_voice_item_playing_stop(ext); + } +} + +void mmi_aigc_voice_item_reset_play_state(lv_aigc_list_ext_t * list_page_ext) +{ + printf("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__); + +#if 0 + if(NULL == list_page_ext || NULL == list_page_ext->voice_playing_anim.var) + { + printf("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__); + return; + } + + uint8_t msg_from = list_page_ext->voice_playing_msg_from; + + lv_anim_del(list_page_ext->voice_playing_anim.var, NULL); + lv_img_set_src(list_page_ext->voice_playing_anim.var, ((0 == msg_from) ? ICON_WECHAT_MY_VOICE_ITEM_PLAYING3 : ICON_WECHAT_OTHER_VOICE_ITEM_PLAYING3)); + list_page_ext->voice_playing_anim.var = NULL; +#endif +} + +void mmi_aigc_voice_item_playing_stop(lv_aigc_ext_t * ext) +{ + printf("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__); + +#if 0 + if(NULL == ext || NULL == ext->list) + { + printf("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__); + return; + } + + lv_aigc_list_ext_t * list_page_ext = (lv_aigc_list_ext_t *)lv_obj_get_ext_attr(ext->list); + if(NULL == list_page_ext || NULL == list_page_ext->voice_playing_anim.var) + { + printf("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__); + return; + } + + Hal_File_Play_End(); + Hal_Audio_Manage_End_Ind(AUDIO_CTRL_PRIORITY_5); + mmi_aigc_voice_item_reset_play_state(list_page_ext); +#endif +} + +void mmi_aigc_list_msg_item_style_reset(lv_aigc_ext_t * ext) +{ + if(NULL == ext || NULL == ext->list) + return; + + lv_aigc_list_ext_t * list_page_ext = lv_obj_get_ext_attr(ext->list); + if(NULL == list_page_ext) + return; + + lv_style_reset(&(list_page_ext->style_cont_self)); + lv_style_reset(&(list_page_ext->style_cont_other)); + //lv_style_reset(&(list_page_ext->style_label_time)); + lv_style_reset(&(list_page_ext->style_label_len_self)); + lv_style_reset(&(list_page_ext->style_label_len_other)); +} + +//display time & content +lv_obj_t * mmi_aigc_list_msg_item_add(lv_obj_t * list_page, mmi_aigc_msg_item_info_t * msg_item, char * time_str, uint8_t i) +{ + printf("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__); + + lv_obj_t * obj = NULL; + lv_aigc_list_ext_t * list_page_ext = lv_obj_get_ext_attr(list_page); + lv_obj_t * scrl = lv_page_get_scrl(list_page); + lv_coord_t obj_y = 0; + obj_y = lv_obj_get_style_pad_top(scrl, LV_STATE_DEFAULT); + printf("[@CHENG_DEBUG][%s][%d]: obj_y=%d,size=%d\n", __FUNCTION__, __LINE__, obj_y, msg_item->msg_data_size); + + obj = lv_cont_create(list_page, NULL); + lv_obj_set_size(obj, LV_HOR_RES - 30-20, 50); //lv_obj_set_size(obj, 153, 53); // same with voice item + lv_cont_set_fit4(obj, LV_FIT_NONE, LV_FIT_NONE, LV_FIT_NONE, LV_FIT_TIGHT); + //lv_cont_set_layout(obj, LV_LAYOUT_COLUMN_LEFT); + lv_obj_add_style(obj, LV_CONT_PART_MAIN, &(list_page_ext->style_cont_other)); + lv_obj_align(obj, scrl, LV_ALIGN_IN_TOP_MID, 0, obj_y+200); + + uint32_t file_size = msg_item->msg_data_size; + char * file_buf = msg_item->msg_data_ptr; + + lv_obj_t * label_text = lv_label_create(obj, NULL); + lv_obj_add_style(label_text, LV_LABEL_PART_MAIN, &(list_page_ext->style_label_len_other)); + lv_label_set_align(label_text, LV_LABEL_ALIGN_LEFT); + lv_label_set_long_mode(label_text, LV_LABEL_LONG_BREAK); + lv_obj_set_width(label_text, lv_obj_get_width(obj) - 20); + + lv_label_set_text(label_text, file_buf); + lv_obj_align(label_text, obj, LV_ALIGN_IN_LEFT_MID, 10, 10); + + + // free resource + //mmi_aigc_data_receive_resource_clean(); + + lv_obj_set_click(obj, false); + lv_obj_set_adv_hittest(obj, false); + lv_page_focus(list_page, obj, 0); + lv_page_glue_obj(obj, true); + lv_watch_obj_add_element(obj); + + return obj; +} + +lv_res_t mmi_aigc_list_scrl_signal(lv_obj_t * scrl, lv_signal_t sign, void * param) +{ + lv_res_t res; + + /* Include the ancient signal function */ + res = ancient_scrl_signal(scrl, sign, param); + if(res != LV_RES_OK) + return res; + + if(LV_SIGNAL_COORD_CHG == sign) + { + lv_obj_t * list_page = lv_obj_get_parent(scrl); + lv_aigc_list_ext_t * list_page_ext = (lv_aigc_list_ext_t *)lv_obj_get_ext_attr(list_page); + if(NULL == list_page_ext) + return; + + if(true == list_page_ext->pressing) + { + list_page_ext->pressing = false; + } + } + + return LV_RES_OK; +} + +void mmi_aigc_list_create(lv_obj_t * obj, lv_aigc_ext_t * ext) +{ + printf("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__); + + lv_obj_t * list_page = lv_page_create(obj, NULL); + lv_aigc_list_ext_t * list_page_ext = lv_obj_allocate_ext_attr(list_page, sizeof(lv_aigc_list_ext_t)); + if(NULL == ext) + return; + + lv_obj_set_size(list_page, lv_obj_get_width(obj)-20, lv_obj_get_height(obj) - 5 - lv_obj_get_height(ext->img_record) - 58); + lv_page_set_scrollbar_mode(list_page, LV_SCROLLBAR_MODE_OFF); + lv_obj_set_style_local_bg_opa(list_page, LV_PAGE_PART_BG, LV_STATE_DEFAULT, LV_OPA_0); + lv_obj_set_style_local_border_opa(list_page, LV_PAGE_PART_BG, LV_STATE_DEFAULT, LV_OPA_0); + lv_obj_set_style_local_outline_width(list_page, LV_PAGE_PART_BG, LV_STATE_DEFAULT, 0); + lv_obj_align(list_page, obj, LV_ALIGN_IN_TOP_MID, 0, 30); + + lv_page_set_scrl_layout(list_page, LV_LAYOUT_OFF); + lv_page_set_scrollable_fit2(list_page, LV_FIT_NONE, LV_FIT_TIGHT); + + lv_obj_t * scrl = lv_page_get_scrollable(list_page); + ancient_scrl_signal = lv_obj_get_signal_cb(scrl); + lv_obj_set_signal_cb(scrl, mmi_aigc_list_scrl_signal); + + lv_watch_obj_add_element(list_page); + lv_watch_obj_add_element(scrl); + + //lv_style_init(&(list_page_ext->style_label_time)); + //lv_style_copy(&(list_page_ext->style_label_time), &lv_watch_font20); + //lv_style_set_text_color(&(list_page_ext->style_label_time), LV_STATE_DEFAULT, lv_color_make(20, 187, 242)); + + lv_style_init(&(list_page_ext->style_label_len_other)); + lv_style_copy(&(list_page_ext->style_label_len_other), &lv_watch_font20); + lv_style_set_text_color(&(list_page_ext->style_label_len_other), LV_STATE_DEFAULT, lv_color_make(0xff, 0xff, 0xff)); + + lv_style_init(&(list_page_ext->style_label_len_self)); + lv_style_copy(&(list_page_ext->style_label_len_self), &lv_watch_font20); + lv_style_set_text_color(&(list_page_ext->style_label_len_self), LV_STATE_DEFAULT, lv_color_make(0xff, 0xff, 0xff)); + + lv_style_init(&(list_page_ext->style_cont_self)); + lv_style_set_bg_color(&(list_page_ext->style_cont_self), LV_STATE_DEFAULT, LV_COLOR_MAKE(175, 242, 89)); + lv_style_set_radius(&(list_page_ext->style_cont_self), LV_STATE_DEFAULT, 15); // 30 + lv_style_set_pad_top(&(list_page_ext->style_cont_self), LV_STATE_DEFAULT, 10); // 8 + lv_style_set_pad_bottom(&(list_page_ext->style_cont_self), LV_STATE_DEFAULT, 10); // 8 + lv_style_set_pad_left(&(list_page_ext->style_cont_self), LV_STATE_DEFAULT, 5); // 8 + lv_style_set_pad_right(&(list_page_ext->style_cont_self), LV_STATE_DEFAULT, 5); // 8 + + lv_style_init(&(list_page_ext->style_cont_other)); + lv_style_set_bg_color(&(list_page_ext->style_cont_other), LV_STATE_DEFAULT, LV_COLOR_MAKE(0x00, 0x00, 0x00)); + lv_style_set_radius(&(list_page_ext->style_cont_other), LV_STATE_DEFAULT, 15); + lv_style_set_pad_top(&(list_page_ext->style_cont_other), LV_STATE_DEFAULT, 30); + lv_style_set_pad_bottom(&(list_page_ext->style_cont_other), LV_STATE_DEFAULT, 10); + lv_style_set_pad_left(&(list_page_ext->style_cont_other), LV_STATE_DEFAULT, 5); + lv_style_set_pad_right(&(list_page_ext->style_cont_other), LV_STATE_DEFAULT, 5); + + //_lv_memset_00(&(list_page_ext->voice_playing_anim), sizeof(lv_anim_t)); + //list_page_ext->voice_playing_msg_from = 0; + list_page_ext->pressing = false; + ext->list = list_page; + + mmi_aigc_msg_item_info_t * msg_item = &s_aigc_item_info; + mmi_aigc_list_msg_item_add(list_page, msg_item, NULL, 0); + + if((lv_obj_get_height(list_page) - lv_obj_get_style_pad_top(list_page, LV_LIST_PART_BG) * 2) > lv_obj_get_height(scrl)) + { + lv_cont_set_layout(scrl, LV_LAYOUT_OFF); + } +} + +void mmi_aigc_main_screen_refresh(void) +{ + printf("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__); + + lv_aigc_ext_t * ext = mmi_aigc_actId_ext_get(ACT_ID_AIGC_MAIN); + if(NULL == ext) + return; + + printf("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__); + +#if 1 + mmi_aigc_list_set_slide_enable(&ext->old_ext, true); + mmi_aigc_list_msg_item_style_reset(ext); + if(NULL != ext->list) + { + lv_obj_del(ext->list); + ext->list = NULL; + } + + printf("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__); + + uint8_t msg_count = mmi_aigc_info_count_get(); + //mmi_aigc_list_create(ext->cont, ext); + if(0 == msg_count) + { + printf("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__); + if(NULL != s_aigc_item_info.msg_data_ptr) + { + lv_mem_free(s_aigc_item_info.msg_data_ptr); + s_aigc_item_info.msg_data_ptr = NULL; + } + s_aigc_item_info.msg_data_size = 0; + + mmi_aigc_list_create(ext->cont, ext); + } + else + { + printf("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__); + + lv_obj_set_hidden(ext->label_no_msg, true); + mmi_aigc_list_create(ext->cont, ext); + } + +#else + + mmi_aigc_list_set_slide_enable(&ext->old_ext, true); + + mmi_aigc_voice_item_playing_stop(ext); + + mmi_aigc_list_msg_item_style_reset(ext); + if(NULL != ext->list) + { + lv_obj_del(ext->list); + ext->list = NULL; + } + + printf("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__); + if(NULL != ext->delete_timer_id) + { + Hal_Timer_Stop(ext->delete_timer_id); + ext->delete_timer_id = NULL; + } + printf("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__); + if(NULL != ext->delete_bg) + { + lv_obj_del(ext->delete_bg); + ext->delete_bg = NULL; + } + + printf("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__); + + uint8_t msg_count = mmi_aigc_info_count_get(); + if(0 == msg_count) + { + + printf("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__); + + lv_obj_set_hidden(ext->label_no_msg, false); + } + else + { + + printf("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__); + + lv_obj_set_hidden(ext->label_no_msg, true); + + mmi_aigc_list_create(ext->cont, ext); + } +#endif +} + +lv_obj_t * mmi_aigc_main_create(lv_obj_t * activity_obj) +{ + AIGC_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__); + + if(activity_obj == NULL) + { + lv_watch_activity_ext_t activity_ext; + + _lv_memset_00(&activity_ext, sizeof(lv_watch_activity_ext_t)); + activity_ext.actId = ACT_ID_AIGC_MAIN; + activity_ext.create = (lv_watch_activity_create_f_t)mmi_aigc_main_create; //NULL; + activity_ext.prepare_destory = mmi_aigc_main_prepare_destory; + activity_obj = lv_watch_creat_activity_obj(&activity_ext); + LV_ASSERT_MEM(activity_obj); + } + + lv_obj_t * obj = lv_watch_obj_create(activity_obj); + if(NULL == obj) + return NULL; + /*Allocate the tab type specific extended data*/ + lv_aigc_ext_t * ext = lv_obj_allocate_ext_attr(obj, sizeof(lv_aigc_ext_t)); + if(NULL == ext) + return NULL; + + ext->cont = NULL; + ext->list = NULL; + ext->record_buffer = NULL; + ext->record_size = 0; + + lv_obj_t * cont = lv_cont_create(obj, NULL); + lv_obj_set_size(cont, lv_obj_get_width(obj), lv_obj_get_height(obj)); + lv_obj_align(cont, obj, LV_ALIGN_CENTER, 0, 0); + lv_obj_set_style_local_bg_color(cont, LV_CONT_PART_MAIN, LV_STATE_DEFAULT, lv_color_make(0x00, 0x00, 0x00)); + lv_watch_obj_add_element(cont); + ext->cont = cont; + + if(false == watch_modem_sim_present_check_req() + //|| (MMI_MODEM_SIGNAL_BAR_0 == watch_modem_get_signal_bar_req()) + ) + { + // no network + lv_obj_t * label = lv_label_create(cont, NULL); + lv_obj_add_style(label, LV_LABEL_PART_MAIN, &lv_watch_font26); + lv_label_set_text_id(label, WATCH_TEXT_ID_DEVICE_NO_NETWORK); + lv_label_set_align(label, LV_LABEL_ALIGN_CENTER); + lv_obj_align(label, cont, LV_ALIGN_CENTER, 0, -10); + + return obj; + } + else if(false == watch_modem_sim_present_check_req()) // Device not activated + { + // no permission + lv_obj_t * label = lv_label_create(cont, NULL); + lv_obj_add_style(label, LV_LABEL_PART_MAIN, &lv_watch_font26); + lv_label_set_text_id(label, WATCH_TEXT_ID_DEVICE_NOT_WEAR); + lv_label_set_align(label, LV_LABEL_ALIGN_CENTER); + lv_obj_align(label, cont, LV_ALIGN_CENTER, 0, -10); + + return obj; + } + + // + s_debug_counter = 0; + mmi_aigc_websocket_app_start(); + watch_set_suspend_enable(false, ACT_ID_AIGC_MAIN, 0); + + //create no msg label + ext->label_no_msg = lv_label_create(cont, NULL); + lv_obj_add_style(ext->label_no_msg, LV_LABEL_PART_MAIN, &lv_watch_font26); + lv_label_set_text_id(ext->label_no_msg, WATCH_TEXT_ID_PRESS_TO_TALK); + //lv_label_set_align(ext->label_no_msg, LV_LABEL_ALIGN_CENTER); + lv_obj_align(ext->label_no_msg, cont, LV_ALIGN_CENTER, 0, -10); + + ext->img_record = lv_img_create(cont, NULL); + lv_img_set_src(ext->img_record, ICON_WECHAT_RECORD_BUTTON); + lv_obj_set_click(ext->img_record, true); + lv_obj_set_event_cb(ext->img_record, mmi_aigc_record_button_event_cb); + lv_obj_set_adv_hittest(ext->img_record, false); + lv_obj_add_protect(ext->img_record, LV_PROTECT_PRESS_LOST); + lv_watch_obj_add_element(ext->img_record); + lv_obj_align(ext->img_record, cont, LV_ALIGN_IN_BOTTOM_MID, 0, -8); + + uint8_t msg_count = mmi_aigc_info_count_get(); + if(0 == msg_count) + { + lv_obj_set_hidden(ext->label_no_msg, false); + } + else + { + lv_obj_set_hidden(ext->label_no_msg, true); + + mmi_aigc_list_create(cont, ext); + } + + return obj; +} + +void mmi_aigc_create_event_cb(lv_obj_t * btn, lv_event_t e) +{ + if(LV_EVENT_CLICKED == e) + { + // + mmi_aigc_receive_item_info_clean(); + + lv_watch_png_cache_all_free(); + lv_obj_t * obj = mmi_aigc_main_create(NULL); + LV_ASSERT_MEM(obj); + } +} + +#endif diff --git a/2.sdk/sdk/gui/lv_watch/lv_apps/custom_function/mmi_aigc_ui.h b/2.sdk/sdk/gui/lv_watch/lv_apps/custom_function/mmi_aigc_ui.h new file mode 100644 index 00000000..fa627c01 --- /dev/null +++ b/2.sdk/sdk/gui/lv_watch/lv_apps/custom_function/mmi_aigc_ui.h @@ -0,0 +1,129 @@ + + + +#ifndef __MMI_AIGC_UI_H__ +#define __MMI_AIGC_UI_H__ + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef LV_CONF_INCLUDE_SIMPLE +#include "lvgl.h" +#include "lv_watch_conf.h" +#else +#include "../../../lvgl/lvgl.h" +#include "../../../lv_watch_conf.h" +#endif + +#ifdef __MMI_CUSTOM_AIGC_SUPPORT__ + + +#define __MMI_AIGC_DEBUG__ +#ifdef __MMI_AIGC_DEBUG__ +#define AIGC_DEBUG_PRINTF(fmt, ...) printf("[AIGC]"fmt, ##__VA_ARGS__) +//#define AIGC_DEBUG_PRINTF(fmt, ...) CPUartLogPrintf("[AIGC]"fmt, ##__VA_ARGS__) +//#define AIGC_DEBUG_PRINTF(fmt, ...) cplog_printf("[AIGC]"fmt, ##__VA_ARGS__) +#else +#define AIGC_DEBUG_PRINTF(fmt, ...) +#endif + + +#define MMI_AIGC_AUDIO_FORMAT (3) // 7-pcm8; 3-amr +//#define MMI_AIGC_AUDIO_FORMAT_STR (".wav") // ".amr" + +//#define MMI_AIGC_DATA_AMR_HEAD_SIZE (6) +//#define MMI_AIGC_DATA_RECORD_DURATION_MAX (15) // seconds +//#define MMI_AIGC_DATA_RECORD_SIZE_MAX (MMI_AIGC_DATA_RECORD_DURATION_MAX * HAL_AMR_BUFSIZE_PER_SECOND + MMI_AIGC_DATA_AMR_HEAD_SIZE) +#define MMI_AIGC_DATA_WAV_HEAD_SIZE (44) +#define MMI_AIGC_DATA_RECORD_DURATION_MAX (10) // seconds +#define MMI_AIGC_DATA_RECORD_SIZE_MAX (MMI_AIGC_DATA_RECORD_DURATION_MAX * 16000 + MMI_AIGC_DATA_WAV_HEAD_SIZE) + +#define MMI_AIGC_CHAT_TIME_INTERVAL (3 * 60) /*display the time of current chat msg if more than 3 mins from the previous chat msgs*/ + + +//#define MMI_AIGC_MSG_NUM_MAX (1) +//#define MMI_AIGC_DATA_FILE_NAME_MAX (64) // (LV_FS_MAX_PATH_LENGTH / 2) + +typedef struct +{ + //uint8_t msg_index; + //uint8_t msg_from; // 0-slef; 1-other + //uint8_t unread_flag; // 0-read; 1-unread + //hal_rtc_t msg_time; + //nv_wechat_msg_type_e msg_type; + uint32_t msg_data_size; + void * msg_data_ptr; + uint32_t msg_voice_data_size; + void * msg_voice_data_ptr; + //char msg_data_full_file_name[MMI_AIGC_DATA_FILE_NAME_MAX]; +} mmi_aigc_msg_item_info_t; + +//typedef struct +//{ +// uint8_t msg_count; +// mmi_aigc_msg_item_info_t msg_item[MMI_AIGC_MSG_NUM_MAX]; +//} mmi_aigc_msg_info_t; + + +typedef struct +{ + lv_watch_obj_ext_t old_ext; + lv_obj_t * label_sending; + lv_obj_t * label_result; + lv_task_t * sending_screen_task_id; + lv_obj_t * gif_obj; +} lv_aigc_sending_ext_t; + +typedef struct +{ + lv_watch_obj_ext_t old_ext; + lv_obj_t * label; +} lv_aigc_recording_ext_t; + +typedef struct +{ + lv_watch_obj_ext_t old_ext; + lv_obj_t * unread_img; + uint8_t item_index; +} lv_aigc_list_item_ext_t; + +typedef struct { + lv_page_ext_t old_ext; + //lv_anim_t voice_playing_anim; + //uint8_t voice_playing_msg_from; // 0-slef; 1-other + bool pressing; + lv_style_t style_cont_self; + lv_style_t style_cont_other; + //lv_style_t style_label_time; + lv_style_t style_label_len_other; + lv_style_t style_label_len_self; +} lv_aigc_list_ext_t; + +typedef struct +{ + lv_watch_obj_ext_t old_ext; + lv_obj_t * cont; + lv_obj_t * list; // chat list + lv_obj_t * label_no_msg; // mo msg prompt + //lv_obj_t * img_emo; + lv_obj_t * img_record; // record button + + //TIMER_ID delete_timer_id; + + MCI_EVNET_T event; + uint8_t * record_buffer; + uint32_t record_size; +}lv_aigc_ext_t; + + +void mmi_aigc_create_event_cb(lv_obj_t * btn, lv_event_t e); + +#endif + +#ifdef __cplusplus +} /* extern "C" */ +#endif + +#endif + diff --git a/2.sdk/sdk/product/craneg_modem/pcac/wsclient/build/wsclient.mak b/2.sdk/sdk/product/craneg_modem/pcac/wsclient/build/wsclient.mak index d590a279..46c14c12 100644 --- a/2.sdk/sdk/product/craneg_modem/pcac/wsclient/build/wsclient.mak +++ b/2.sdk/sdk/product/craneg_modem/pcac/wsclient/build/wsclient.mak @@ -66,7 +66,9 @@ PACKAGE_SRC_FILES = \ sim_websocket_example.c \ web_esp_tls_mbedtls.c \ sim_esp_tls.c \ - web_transport_ssl.c + web_transport_ssl.c \ + mmi_aigc_chat_websocket.c \ + mmi_aigc_trans_websocket.c # These are the tool flags specific to the ci_stub package only. # The environment, target, and group also set flags. diff --git a/2.sdk/sdk/product/craneg_modem/pcac/wsclient/libwebsockets/inc/mmi_aigc_chat_websocket.h b/2.sdk/sdk/product/craneg_modem/pcac/wsclient/libwebsockets/inc/mmi_aigc_chat_websocket.h new file mode 100644 index 00000000..46a9e23e --- /dev/null +++ b/2.sdk/sdk/product/craneg_modem/pcac/wsclient/libwebsockets/inc/mmi_aigc_chat_websocket.h @@ -0,0 +1,31 @@ + + + +#ifndef __MMI_AIGC_CHAT_WEBSOCKET_H__ +#define __MMI_AIGC_CHAT_WEBSOCKET_H__ + +#ifdef __cplusplus +extern "C" { +#endif + +#if 1 // def __MMI_CUSTOM_AIGC_SUPPORT__ + + +#define MMI_AIGC_CHAT_WEBSOCKET_URI "ws://121.40.67.151:9099/chat/ws" + + +int mmi_aigc_chat_websocket_send_text_data(char * data_ptr, int data_len); +int mmi_aigc_chat_websocket_send_binary_data(char * data_ptr, int data_len); +void mmi_aigc_chat_websocket_app_start(void); +void mmi_aigc_chat_websocket_app_stop(void); + + + +#endif + +#ifdef __cplusplus +} /* extern "C" */ +#endif + +#endif + diff --git a/2.sdk/sdk/product/craneg_modem/pcac/wsclient/libwebsockets/inc/mmi_aigc_trans_websocket.h b/2.sdk/sdk/product/craneg_modem/pcac/wsclient/libwebsockets/inc/mmi_aigc_trans_websocket.h new file mode 100644 index 00000000..29227444 --- /dev/null +++ b/2.sdk/sdk/product/craneg_modem/pcac/wsclient/libwebsockets/inc/mmi_aigc_trans_websocket.h @@ -0,0 +1,41 @@ + + + +#ifndef __MMI_AIGC_TRANS_WEBSOCKET_H__ +#define __MMI_AIGC_TRANS_WEBSOCKET_H__ + +#ifdef __cplusplus +extern "C" { +#endif + +#if 1 // def __MMI_CUSTOM_AIGC_SUPPORT__ + + +#define __MMI_AIGC_WB_DEBUG__ +#ifdef __MMI_AIGC_WB_DEBUG__ +//#define AIGC_WB_DEBUG_PRINTF(fmt, ...) printf("[AIGC_WB]"fmt, ##__VA_ARGS__) +//#define AIGC_WB_DEBUG_PRINTF(fmt, ...) CPUartLogPrintf("[AIGC_WB]"fmt, ##__VA_ARGS__) +#define AIGC_WB_DEBUG_PRINTF(fmt, ...) cplog_printf("[AIGC_WB]"fmt, ##__VA_ARGS__) +#else +#define AIGC_WB_DEBUG_PRINTF(fmt, ...) +#endif + + +#define MMI_AIGC_TRANS_WEBSOCKET_URI "ws://121.40.67.151:9099/asr/ws" + + +int mmi_aigc_trans_websocket_send_text_data(char * data_ptr, int data_len); +int mmi_aigc_trans_websocket_send_binary_data(char * data_ptr, int data_len); +void mmi_aigc_trans_websocket_app_start(void); +void mmi_aigc_trans_websocket_app_stop(void); + + + +#endif + +#ifdef __cplusplus +} /* extern "C" */ +#endif + +#endif + diff --git a/2.sdk/sdk/product/craneg_modem/pcac/wsclient/libwebsockets/src/mmi_aigc_chat_websocket.c b/2.sdk/sdk/product/craneg_modem/pcac/wsclient/libwebsockets/src/mmi_aigc_chat_websocket.c new file mode 100644 index 00000000..34d02e8f --- /dev/null +++ b/2.sdk/sdk/product/craneg_modem/pcac/wsclient/libwebsockets/src/mmi_aigc_chat_websocket.c @@ -0,0 +1,141 @@ + + + +#if 1 // def __MMI_CUSTOM_AIGC_SUPPORT__ + +#include "uart.h" +#include "sim_esp_websocket_client.h" +#include "Mmi_aigc_chat_websocket.h" + +static sim_esp_websocket_client_handle_t s_aigc_chat_ws_client_p = NULL; + +extern void mmi_aigc_chat_websocket_recv_data_handler(char * data_ptr, int data_len, int payload_len, int payload_offset); + + + +int mmi_aigc_chat_websocket_send_text_data(char * data_ptr, int data_len) +{ + int ret = 0; + + AIGC_WB_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__); + ret = sim_esp_websocket_client_send_text(s_aigc_chat_ws_client_p, data_ptr, data_len, portMAX_DELAY); + if (0 > ret) + { + AIGC_WB_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__); + } + + return ret; +} + +int mmi_aigc_chat_websocket_send_binary_data(char * data_ptr, int data_len) +{ + int ret = 0; + + AIGC_WB_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__); + ret = sim_esp_websocket_client_send_bin(s_aigc_chat_ws_client_p, data_ptr, data_len, portMAX_DELAY); + if (0 > ret) + { + AIGC_WB_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__); + } + + return ret; +} + +static void mmi_aigc_chat_websocket_event_handler(int32_t event_id, void *event_data) +{ + sim_esp_websocket_event_data_t *data = (sim_esp_websocket_event_data_t *)event_data; + + AIGC_WB_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: event_id=%d\n", __FUNCTION__, __LINE__, event_id); + switch (event_id) + { + case WEBSOCKET_EVENT_CONNECTED: + AIGC_WB_DEBUG_PRINTF("[@CHENG_DEBUG][%d]: WEBSOCKET_EVENT_CONNECTED\n", __LINE__); + break; + + case WEBSOCKET_EVENT_DISCONNECTED: + AIGC_WB_DEBUG_PRINTF("[@CHENG_DEBUG][%d]: WEBSOCKET_EVENT_DISCONNECTED\n", __LINE__); + break; + + case WEBSOCKET_EVENT_DATA: + AIGC_WB_DEBUG_PRINTF("[@CHENG_DEBUG][%d]: WEBSOCKET_EVENT_DATA\n", __LINE__); + AIGC_WB_DEBUG_PRINTF("[@CHENG_DEBUG]: data opcode=%d,data len=%d", data->op_code, data->data_len); + AIGC_WB_DEBUG_PRINTF("[@CHENG_DEBUG]: Total payload len=%d,current payload offset=%d\r\n", data->payload_len, data->payload_offset); + if (data->op_code == 0x08 && data->data_len == 2) { + AIGC_WB_DEBUG_PRINTF("[@CHENG_DEBUG]: Received closed message with code=%d", 256*data->data_ptr[0] + data->data_ptr[1]); + } + else + { + AIGC_WB_DEBUG_PRINTF("[@CHENG_DEBUG]: Received=%.*s", data->data_len, (char *)data->data_ptr); + mmi_aigc_chat_websocket_recv_data_handler(data->data_ptr, data->data_len, data->payload_len, data->payload_offset); + } + //OSATimerStart(shutdown_signal_timer, portMAX_DELAY, 0, shutdown_signaler, 0); + break; + + case WEBSOCKET_EVENT_ERROR: + AIGC_WB_DEBUG_PRINTF("[@CHENG_DEBUG][%d]: WEBSOCKET_EVENT_ERROR\n", __LINE__); + break; + + case WEBSOCKET_EVENT_CLOSED: + AIGC_WB_DEBUG_PRINTF("[@CHENG_DEBUG][%d]: WEBSOCKET_EVENT_CLOSED\n", __LINE__); + break; + + default: + AIGC_WB_DEBUG_PRINTF("[@CHENG_DEBUG][%d]: default\n", __LINE__); + break; + } + + if (NULL != data) + { + if (NULL != data->data_ptr) + { + free(data->data_ptr); + data->data_ptr = NULL; + AIGC_WB_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: free data ptr\n", __FUNCTION__, __LINE__); + } + + free(data); + data = NULL; + AIGC_WB_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: free data\n", __FUNCTION__, __LINE__); + } +} + +void mmi_aigc_chat_websocket_app_start(void) +{ + OS_STATUS status = 0; + int ret = 0; + sim_esp_websocket_client_config_t websocket_cfg = {0}; + + websocket_cfg.uri = MMI_AIGC_CHAT_WEBSOCKET_URI; + + AIGC_WB_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: url=%s\n", __FUNCTION__, __LINE__, websocket_cfg.uri); + + s_aigc_chat_ws_client_p = sim_esp_websocket_client_init(&websocket_cfg); + if(NULL == s_aigc_chat_ws_client_p) + { + AIGC_WB_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: websocket client init fail\n", __FUNCTION__, __LINE__); + return; + } + + sim_esp_websocket_register_events(s_aigc_chat_ws_client_p, mmi_aigc_chat_websocket_event_handler); + + esp_err_t err_no = sim_esp_websocket_client_start(s_aigc_chat_ws_client_p); + if(ESP_OK != err_no) + { + AIGC_WB_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: websocket client start fail,%d\n", __FUNCTION__, __LINE__, err_no); + return; + } + else + { + + } +} + +void mmi_aigc_chat_websocket_app_stop(void) +{ + AIGC_WB_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__); + + sim_esp_websocket_client_destroy(s_aigc_chat_ws_client_p); +} + +#endif + diff --git a/2.sdk/sdk/product/craneg_modem/pcac/wsclient/libwebsockets/src/mmi_aigc_trans_websocket.c b/2.sdk/sdk/product/craneg_modem/pcac/wsclient/libwebsockets/src/mmi_aigc_trans_websocket.c new file mode 100644 index 00000000..18902425 --- /dev/null +++ b/2.sdk/sdk/product/craneg_modem/pcac/wsclient/libwebsockets/src/mmi_aigc_trans_websocket.c @@ -0,0 +1,141 @@ + + + +#if 1 // def __MMI_CUSTOM_AIGC_SUPPORT__ + +#include "uart.h" +#include "sim_esp_websocket_client.h" +#include "Mmi_aigc_trans_websocket.h" + +static sim_esp_websocket_client_handle_t s_aigc_trans_ws_client_p = NULL; + +extern void mmi_aigc_trans_websocket_recv_data_handler(char * data_ptr, int data_len, int payload_len, int payload_offset); + + + +int mmi_aigc_trans_websocket_send_text_data(char * data_ptr, int data_len) +{ + int ret = 0; + + AIGC_WB_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__); + ret = sim_esp_websocket_client_send_text(s_aigc_trans_ws_client_p, data_ptr, data_len, portMAX_DELAY); + if (0 > ret) + { + AIGC_WB_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__); + } + + return ret; +} + +int mmi_aigc_trans_websocket_send_binary_data(char * data_ptr, int data_len) +{ + int ret = 0; + + AIGC_WB_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__); + ret = sim_esp_websocket_client_send_bin(s_aigc_trans_ws_client_p, data_ptr, data_len, portMAX_DELAY); + if (0 > ret) + { + AIGC_WB_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__); + } + + return ret; +} + +static void mmi_aigc_trans_websocket_event_handler(int32_t event_id, void *event_data) +{ + sim_esp_websocket_event_data_t *data = (sim_esp_websocket_event_data_t *)event_data; + + AIGC_WB_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: event_id=%d\n", __FUNCTION__, __LINE__, event_id); + switch (event_id) + { + case WEBSOCKET_EVENT_CONNECTED: + AIGC_WB_DEBUG_PRINTF("[@CHENG_DEBUG][%d]: WEBSOCKET_EVENT_CONNECTED\n", __LINE__); + break; + + case WEBSOCKET_EVENT_DISCONNECTED: + AIGC_WB_DEBUG_PRINTF("[@CHENG_DEBUG][%d]: WEBSOCKET_EVENT_DISCONNECTED\n", __LINE__); + break; + + case WEBSOCKET_EVENT_DATA: + AIGC_WB_DEBUG_PRINTF("[@CHENG_DEBUG][%d]: WEBSOCKET_EVENT_DATA\n", __LINE__); + AIGC_WB_DEBUG_PRINTF("[@CHENG_DEBUG]: data opcode=%d,data len=%d", data->op_code, data->data_len); + AIGC_WB_DEBUG_PRINTF("[@CHENG_DEBUG]: Total payload len=%d,current payload offset=%d\r\n", data->payload_len, data->payload_offset); + if (data->op_code == 0x08 && data->data_len == 2) { + AIGC_WB_DEBUG_PRINTF("[@CHENG_DEBUG]: Received closed message with code=%d", 256*data->data_ptr[0] + data->data_ptr[1]); + } + else + { + AIGC_WB_DEBUG_PRINTF("[@CHENG_DEBUG]: Received=%.*s", data->data_len, (char *)data->data_ptr); + mmi_aigc_trans_websocket_recv_data_handler(data->data_ptr, data->data_len, data->payload_len, data->payload_offset); + } + //OSATimerStart(shutdown_signal_timer, portMAX_DELAY, 0, shutdown_signaler, 0); + break; + + case WEBSOCKET_EVENT_ERROR: + AIGC_WB_DEBUG_PRINTF("[@CHENG_DEBUG][%d]: WEBSOCKET_EVENT_ERROR\n", __LINE__); + break; + + case WEBSOCKET_EVENT_CLOSED: + AIGC_WB_DEBUG_PRINTF("[@CHENG_DEBUG][%d]: WEBSOCKET_EVENT_CLOSED\n", __LINE__); + break; + + default: + AIGC_WB_DEBUG_PRINTF("[@CHENG_DEBUG][%d]: default\n", __LINE__); + break; + } + + if (NULL != data) + { + if (NULL != data->data_ptr) + { + free(data->data_ptr); + data->data_ptr = NULL; + AIGC_WB_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: free data ptr\n", __FUNCTION__, __LINE__); + } + + free(data); + data = NULL; + AIGC_WB_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: free data\n", __FUNCTION__, __LINE__); + } +} + +void mmi_aigc_trans_websocket_app_start(void) +{ + OS_STATUS status = 0; + int ret = 0; + sim_esp_websocket_client_config_t websocket_cfg = {0}; + + websocket_cfg.uri = MMI_AIGC_TRANS_WEBSOCKET_URI; + + AIGC_WB_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: url=%s\n", __FUNCTION__, __LINE__, websocket_cfg.uri); + + s_aigc_trans_ws_client_p = sim_esp_websocket_client_init(&websocket_cfg); + if(NULL == s_aigc_trans_ws_client_p) + { + AIGC_WB_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: websocket client init fail\n", __FUNCTION__, __LINE__); + return; + } + + sim_esp_websocket_register_events(s_aigc_trans_ws_client_p, mmi_aigc_trans_websocket_event_handler); + + esp_err_t err_no = sim_esp_websocket_client_start(s_aigc_trans_ws_client_p); + if(ESP_OK != err_no) + { + AIGC_WB_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: websocket client start fail,%d\n", __FUNCTION__, __LINE__, err_no); + return; + } + else + { + + } +} + +void mmi_aigc_trans_websocket_app_stop(void) +{ + AIGC_WB_DEBUG_PRINTF("[@CHENG_DEBUG][%s][%d]: \n", __FUNCTION__, __LINE__); + + sim_esp_websocket_client_destroy(s_aigc_trans_ws_client_p); +} + +#endif +