From 8487a9313e7d0a92b61af4cfa65bc1e008a4a9d4 Mon Sep 17 00:00:00 2001 From: =?utf8?q?=E8=83=A1=E4=BC=A0=E5=86=9B?= <1224667075@qq.com> Date: Tue, 20 May 2025 09:03:20 +0000 Subject: [PATCH] Merge #1768 into sdk650pathc0423 from refs/changes/1768/head MIME-Version: 1.0 Content-Type: text/plain; charset=utf8 Content-Transfer-Encoding: 8bit Code review from 胡传军 * refs/changes/1768/head: (7 commits squashed) - 修改安装app回复错误指令bug - Merge branch 'sdk650pathc0423' of https://codeup.aliyun.com/64191456b9581d62e8f81ac0/FD230 into 0423 - Merge branch 'sdk650pathc0423' of https://codeup.aliyun.com/64191456b9581d62e8f81ac0/FD230 into 0423 - Merge branch 'sdk650pathc0423' of https://codeup.aliyun.com/64191456b9581d62e8f81ac0/FD230 into 0423 - 提交hfp部分代码 - 修改appble处理函数 - Merge branch 'sdk650pathc0423' of https://codeup.aliyun.com/64191456b9581d62e8f81ac0/FD230 into 0423 Signed-off-by: aliyun8003852482 <1224667075@qq.com> Merged-by: Caisking <3449750381@qq.com> CR-link: https://codeup.aliyun.com/64191456b9581d62e8f81ac0/FD230/change/1768 --- .../nativeui/bluetooth/src/BluetoothModel.cpp | 2 +- .../src/BluetoothServiceOptionsPresenter.cpp | 2 +- .../phoneservice/include/PhoneAGService.h | 47 + .../phoneservice/include/PhoneAudio.h | 16 + .../phoneservice/include/PhoneService.h | 45 +- .../phoneservice/include/PhoneServiceC.h | 45 + .../phoneservice/src/PhoneAGService.cpp | 1058 +++++++++++++++++ .../nativeui/phoneservice/src/PhoneAudio.cpp | 140 ++- .../phoneservice/src/PhoneService.cpp | 772 ++++++++++-- .../nativeui/player/src/PlayersModel.cpp | 10 +- .../blemoder/ble_congfig_adapt.cpp | 26 +- .../blemoder/ble_instruct_init.cpp | 2 +- .../ble_service/bleservice/bleEvent.c | 10 +- .../ble_service/bleservice/bleService.c | 2 +- code/sdk/zhihui/utils/custom_cmd_service.c | 16 +- 15 files changed, 2066 insertions(+), 127 deletions(-) create mode 100644 code/sdk/application/wearable/fd230/nativeapp/nativeui/phoneservice/include/PhoneAGService.h create mode 100644 code/sdk/application/wearable/fd230/nativeapp/nativeui/phoneservice/include/PhoneServiceC.h create mode 100644 code/sdk/application/wearable/fd230/nativeapp/nativeui/phoneservice/src/PhoneAGService.cpp diff --git a/code/sdk/application/wearable/fd230/nativeapp/nativeui/bluetooth/src/BluetoothModel.cpp b/code/sdk/application/wearable/fd230/nativeapp/nativeui/bluetooth/src/BluetoothModel.cpp index e1a74b3d7..2bf729647 100644 --- a/code/sdk/application/wearable/fd230/nativeapp/nativeui/bluetooth/src/BluetoothModel.cpp +++ b/code/sdk/application/wearable/fd230/nativeapp/nativeui/bluetooth/src/BluetoothModel.cpp @@ -1610,7 +1610,7 @@ static void BtA2dpSnkConnectStateChangedCb(bd_addr_t *bd_addr, int conn_state) if(cm_get_HFP_switch() && uapi_hfp_connect_state()==0) { - // uapi_hfp_connect(); + uapi_hfp_connect(); } #endif diff --git a/code/sdk/application/wearable/fd230/nativeapp/nativeui/classicbluetooth/src/BluetoothServiceOptionsPresenter.cpp b/code/sdk/application/wearable/fd230/nativeapp/nativeui/classicbluetooth/src/BluetoothServiceOptionsPresenter.cpp index 8578af9ab..c10398b62 100644 --- a/code/sdk/application/wearable/fd230/nativeapp/nativeui/classicbluetooth/src/BluetoothServiceOptionsPresenter.cpp +++ b/code/sdk/application/wearable/fd230/nativeapp/nativeui/classicbluetooth/src/BluetoothServiceOptionsPresenter.cpp @@ -87,7 +87,7 @@ namespace OHOS { ConfigModel::GetInstance()->SetHFPState(true); #ifdef FD230_650 - // uapi_hfp_connect(); + uapi_hfp_connect(); #endif classicBlueToothView->init_connect_timer(BluetoothServiceOptionsView::CONNECT_HFP); } diff --git a/code/sdk/application/wearable/fd230/nativeapp/nativeui/phoneservice/include/PhoneAGService.h b/code/sdk/application/wearable/fd230/nativeapp/nativeui/phoneservice/include/PhoneAGService.h new file mode 100644 index 000000000..5b6c4c512 --- /dev/null +++ b/code/sdk/application/wearable/fd230/nativeapp/nativeui/phoneservice/include/PhoneAGService.h @@ -0,0 +1,47 @@ +/* + * Copyright (c) @CompanyNameMagicTag 2021. All rights reserved. + * Description: This module include test functions of HFP AG service. + */ +#ifndef HFP_AG_SERVICE_H +#define HFP_AG_SERVICE_H + +#include + +#include "bts_br_gap.h" +#include "bts_hfp_hf.h" +#include "ohos_types.h" + + +#define SAMPLE_HFP_PROF_VOL_LEVEL 15 +#define SAMPLE_HFP_MEDIA_VOL_LEVEL 100 + +#define SUPPORT_CAT1_HFP_AG_SERV + +#ifdef SUPPORT_CAT1_HFP_AG_SERV + +void hfp_ag_reg_callback(void); + +errcode_t hfp_ag_cmd_conn_hfp(const bd_addr_t *bd_addr); + +errcode_t hfp_ag_cmd_disconn_hfp(const bd_addr_t *bd_addr); + + +void hfp_ag_cmd_conn_sco(const bd_addr_t *bd_addr ); + +void hfp_ag_cmd_disconn_sco(const bd_addr_t *bd_addr ); + +bool headset_Is_connect(void); + +bool headset_SCO_Is_connect(void); + +void cat1_set_headset_volume( unsigned char volume); + +int cat1_ag_send_call_event( uint32_t event_topic,const char* info); + +bool headset_SCO_Is_connect_extend(bd_addr_t *bd_addr); + +#endif + +// void bt_hfp_ag_service_sample_cmd(uint32_t cmd_id, const char **params, int32_t params_cnt); + +#endif /* SAMPLE_HFP_AG_SERVICE_H */ diff --git a/code/sdk/application/wearable/fd230/nativeapp/nativeui/phoneservice/include/PhoneAudio.h b/code/sdk/application/wearable/fd230/nativeapp/nativeui/phoneservice/include/PhoneAudio.h index fd0b6c957..7ae2e74b6 100644 --- a/code/sdk/application/wearable/fd230/nativeapp/nativeui/phoneservice/include/PhoneAudio.h +++ b/code/sdk/application/wearable/fd230/nativeapp/nativeui/phoneservice/include/PhoneAudio.h @@ -58,6 +58,22 @@ int32 PhoneAudioStreamOutDeinit(int32 instanceNum); int32 PhoneAudioManagerDeactInterrupt(void); +//////////////////cat1//////////////// +int32 PhoneAudioGetCAT1MinVolume(void); + + +int32 PhoneAudioGetCAT1MAXVolume(void); + + +int32 PhoneCAT1AudioGetVolume(void); + + +bool PhoneCATAudioSetVolume(int32 volume); + +void Sample_audio_init(void); + + + #ifdef __cplusplus } #endif diff --git a/code/sdk/application/wearable/fd230/nativeapp/nativeui/phoneservice/include/PhoneService.h b/code/sdk/application/wearable/fd230/nativeapp/nativeui/phoneservice/include/PhoneService.h index 7e7dd371a..1e3e4df7c 100644 --- a/code/sdk/application/wearable/fd230/nativeapp/nativeui/phoneservice/include/PhoneService.h +++ b/code/sdk/application/wearable/fd230/nativeapp/nativeui/phoneservice/include/PhoneService.h @@ -75,16 +75,25 @@ typedef enum { CALL_MISSED, // 未接来电 } CallFinishStatus; +typedef enum { + CALL_HFP=0, // + CALL_CAT1, // + +} CalllogtypeStatus; + + +#pragma pack(1) typedef struct { char name[NAME_SIZE]; unsigned char nameLen; unsigned char tel[MAX_PHONE_NUM]; unsigned char telLen; CallFinishStatus status; - uint64 creationTime; // 通话创建时间（不是接通时间） + uint32 creationTime; // 通话创建时间（不是接通时间） uint64 callDurTime; // 通话持续时间 + uint8_t calllogtype; } CallLogInfo; - +#pragma pack() // 通话状态改变回调函数 typedef void (*PhoneServiceCallChangedCb)(const PhoneCallInfo *phoneCall); // 电话服务失败回调函数 @@ -266,6 +275,38 @@ void AudioRelease(void); uint32 GetCallCodec(void); +// 添加通话进通话记录文件 +void AddToCallLog(CallLogInfo *info); + +void AddToCallLog_CAT1(CallLogInfo *callInfo); + +int uapi_hfp_disconnect(void); + +int uapi_hfp_connect(void); + +int uapi_hfp_connect_state(void); + +void uapi_hfp_send_DTMF_CODE(char code); + +void Cat1_CallStateChanged(const hfp_hf_calls_info_t *call); + +void PhoneServiceScreenCtr(bool turnOnFlag); + +void set_speaker_volume(unsigned char hfpVolume,int type); + +int SaveCallLog(CallLogInfo **info,int num); + + +int32_t SetMicMutecat1(bool isMute); + +void AudioActInterrupt(AudioStreamType type); + +void uapi_SetSpeaker_Mute(bool isMute); + + +void set_TransCallToMobilePhone_falg(uint8_t date); + + #ifdef __cplusplus } #endif diff --git a/code/sdk/application/wearable/fd230/nativeapp/nativeui/phoneservice/include/PhoneServiceC.h b/code/sdk/application/wearable/fd230/nativeapp/nativeui/phoneservice/include/PhoneServiceC.h new file mode 100644 index 000000000..01ffbd79c --- /dev/null +++ b/code/sdk/application/wearable/fd230/nativeapp/nativeui/phoneservice/include/PhoneServiceC.h @@ -0,0 +1,45 @@ +/* + * Copyright (c) CompanyNameMagicTag 2021-2021. All rights reserved. + * Description: PhoneService + * Create: 2021-09-22 + */ + +#ifndef PHONE_SERVICE_C_H +#define PHONE_SERVICE_C_H + + +#ifdef __cplusplus +extern "C" { +#endif + +int uapi_hfp_disconnect_(void); + +int uapi_hfp_connect_(void); + +int uapi_hfp_fail_cbk(int32_t errcode); + +int uapi_open_voice_recognition(void ); + +int uapi_close_voice_recognition(void ); + +void cat1_audio_AudioSetup(void); + +void cat1_audio_AudioRelease(void); + +int32_t PhoneAudioSetMicMuteCat1(bool isMute); + +void cat1_audio_stop(void); + +void cat1_connect_sco_(uint8_t); + +void cat1_disconn_sco_(void); + +void cat1_start_SCO_audio_(void); + +void hfp_ag_cmd_conn_last_hfp(void); + +#ifdef __cplusplus +} +#endif + +#endif // PHONE_SERVICE_H diff --git a/code/sdk/application/wearable/fd230/nativeapp/nativeui/phoneservice/src/PhoneAGService.cpp b/code/sdk/application/wearable/fd230/nativeapp/nativeui/phoneservice/src/PhoneAGService.cpp new file mode 100644 index 000000000..85cbddc4b --- /dev/null +++ b/code/sdk/application/wearable/fd230/nativeapp/nativeui/phoneservice/src/PhoneAGService.cpp @@ -0,0 +1,1058 @@ +// /* +// * Copyright (c) @CompanyNameMagicTag 2021. All rights reserved. +// * Description: This module include test function of BT HFP Service module. +// */ + +// #include "PhoneAGService.h" +// #include +// #include +// #include +// #include "securec.h" +// #include "errcode.h" +// #include "bts_br_gap.h" +// #include "bts_hfp_ag.h" +// // #include "sample_common.h" +// #ifdef MEMORY_MINI +// #include "audio_manager.h" +// #else +// // #include "sdk_private.h" +// // /home/hcj/FD230/code/sdk/protocol/bt/host/bt/bts/brandy_service/bt_audio_wrapper/bt_audio_manager_wrapper.h +// // #include "bt_audio_manager_wrapper.h" +// #endif + +// #include "wearable_log.h" +// #include "common_def.h" +// #include "PhoneAudio.h" +// #include "cat1_ctl.h" +// #include "BluetoothHeadsetEvent.h" + +// #include "PhoneServiceC.h" +// #include "notification_manager.h" + +// #include "PhoneService.h" +// #include "CallerLogModel.h" +// #include "custom_utils.h" +// #include "voice_call_volte_sample_wrapper.h" +// #include "BluetoothModel.h" +// #include "BluetoothDeviceListView.h" +// #include "ui_list.h" + + +// #define SAMPLE_HFP_TASK_STACK_SIZE 0x1600 +// #define SAMPLE_HFP_TASK_PRI 20 +// #define HFP_MEDIA_STATUS_DEINIT 0 +// #define HFP_MEDIA_STATUS_INIT 1 +// #define HFP_MEDIA_STATUS_START 2 +// #define HFP_MEDIA_FLAG_IDLE 0 +// #define HFP_MEDIA_FLAG_BUSY 1 + +// #define HFP_AG_IND_SIGNAL_DEFAULT 3 +// #define HFP_AG_IND_BATTERY_DEFAULT 5 + +// typedef enum { +// SAMPLE_HFP_AG_CMD_INIT = 0, /* AG初始化 */ +// SAMPLE_HFP_AG_CMD_DEINIT, /* AG去初始化 */ +// SAMPLE_HFP_AG_CMD_REG_CALLBACK, /* 注册回调 */ +// SAMPLE_HFP_AG_CMD_CONN_HFP, /* HFP连接 */ +// SAMPLE_HFP_AG_CMD_DISCONN_HFP, /* HFP断开连接 */ +// SAMPLE_HFP_AG_CMD_CONN_SCO = 5, /* 建立SCO连接 */ +// SAMPLE_HFP_AG_CMD_DISCONN_SCO, /* 断开SCO连接 */ +// SAMPLE_HFP_AG_CMD_GET_DEV_CONN_STATE, /* 获取设备Profile连接状态 */ +// SAMPLE_HFP_AG_CMD_GET_SCO_CONN_STATE, /* 获取SCO连接状态 */ +// SAMPLE_HFP_AG_CMD_ANSWER_CALL, /* 接听电话 */ +// SAMPLE_HFP_AG_CMD_FINISH_CALL = 10, /* 挂断电话 */ +// SAMPLE_HFP_AG_CMD_SET_VOLUME, /* 设置扬声器/麦克风音量 */ +// SAMPLE_HFP_AG_CMD_SEND_INCOMING_EVENT, /* 发送来电事件 */ +// SAMPLE_HFP_AG_CMD_SEND_NETWORK_EVENT, /* 发送网络事件 */ +// SAMPLE_HFP_AG_CMD_SEND_CALL_LIST, /* 发送通话列表 */ +// SAMPLE_HFP_AG_CMD_SEND_SUBSCRIBER_NUMBER = 15, /* 发送订阅号码信息 */ +// SAMPLE_HFP_AG_CMD_SEND_BATTERY_CHARGE, /* 发送电量信息 */ +// SAMPLE_HFP_AG_CMD_SEND_CMEE_ERROR, /* 发送扩展错误码信息 */ +// SAMPLE_HFP_AG_CMD_SEND_NETWORK_OPERATOR, /* 发送运营商信息 */ +// SAMPLE_HFP_AG_CMD_SEND_INDICATOR_VAL, /* 发送指示器值 */ +// SAMPLE_HFP_AG_CMD_ORIGINATE_CALL, /* 呼出电话 */ +// } sample_hfp_ag_cmd_id; + +// typedef void (*hfp_ag_sample_cmd_handle_func)(const char **params, int32_t params_cnt); + +// typedef struct { +// sample_hfp_ag_cmd_id id; +// hfp_ag_sample_cmd_handle_func func; +// } sample_hfp_ag_hdl_info; + +// static hfp_cind_info_t g_sample_hfp_cind_info = {0}; + + +// static bd_addr_t AG_bd_addr={0}; + + +// static void sample_hfp_ag_print_addr(const bd_addr_t *bd_addr) +// { +// if (bd_addr != NULL) { +// WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"addr: %02x:%02x:**:**:**:%02x ", +// bd_addr->addr[5], bd_addr->addr[4], bd_addr->addr[0]); /* addr 只打印0,4,5位 */ +// } +// } + +// static int32_t g_hfp_media_status = 0; +// static int32_t g_hfp_media_flag = 0; + + +// static AudioCodecFormat g_hfp_codec = mSBC; +// static int32_t g_hdl_up_mic = -1; +// static int32_t g_hdl_up_sco = -1; +// static int32_t g_hdl_dn_spk = -1; +// static int32_t g_hdl_dn_sco = -1; +// static int32_t g_hdl_up_modem = -1; +// static int32_t g_hdl_dn_modem = -1; + + +// static int8_t AG_connect_state=0; + + +// #ifndef MEMORY_MINI +// static int32_t audio_stream_init(void) +// { +// /* 请求音频焦点 */ +// /* deactive响铃时申请的焦点后，重新申请通话焦点 */ +// audio_manager_activate_interrupt(AUDIO_STREAM_VOICE_CALL_VOLTE); +// audio_manager_set_device_connection_state(IN_BLUETOOTH_SCO, AUDIO_DEVICE_CONNECTED); +// audio_manager_set_device_connection_state(OUT_BLUETOOTH_SCO, AUDIO_DEVICE_CONNECTED); +// audio_manager_set_device_connection_state(IN_MODEM_HEADSET, AUDIO_DEVICE_CONNECTED); +// audio_manager_set_device_connection_state(OUT_MODEM_HEADSET, AUDIO_DEVICE_CONNECTED); + +// g_hdl_up_sco = audio_stream_in_init(AUDIO_UP_LINK, g_hfp_codec); +// g_hdl_up_modem = audio_stream_out_init(AUDIO_UP_LINK, g_hfp_codec); +// g_hdl_dn_sco = audio_stream_out_init(AUDIO_DOWN_LINK, g_hfp_codec); +// g_hdl_dn_modem = audio_stream_in_init(AUDIO_DOWN_LINK, g_hfp_codec); +// WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"%d",g_hfp_codec); +// return 0; +// } + +// static int32_t establish_audio_stream_pipeline(void) +// { +// uint32_t modem_out_shm_id = 0; +// uint32_t modem_in_shm_id = 0; + +// audio_stream_in_start(g_hdl_dn_modem); +// audio_stream_out_start(g_hdl_dn_sco); +// audio_stream_in_get_channel_id(g_hdl_dn_modem, &modem_in_shm_id); +// audio_stream_out_attach_frontend(g_hdl_dn_sco, modem_in_shm_id); +// audio_stream_in_start(g_hdl_up_sco); +// audio_stream_out_start(g_hdl_up_modem); +// audio_stream_out_get_channel_id(g_hdl_up_modem, &modem_out_shm_id); +// audio_stream_in_attach_backend(g_hdl_up_sco, modem_out_shm_id); + +// return 0; +// } + +// static int32_t abrogation_audio_stream_pipeline(void) +// { +// /* 销毁上下行通路 */ +// audio_stream_in_stop(g_hdl_up_sco); +// audio_stream_in_deinit(g_hdl_up_sco); +// audio_stream_out_stop(g_hdl_up_modem); +// audio_stream_out_deinit(g_hdl_up_modem); +// audio_stream_out_stop(g_hdl_dn_sco); +// audio_stream_out_deinit(g_hdl_dn_sco); +// audio_stream_in_stop(g_hdl_dn_modem); +// audio_stream_in_deinit(g_hdl_dn_modem); +// audio_manager_set_device_connection_state(IN_BLUETOOTH_SCO, AUDIO_DEVICE_DISCONNECTED); +// audio_manager_set_device_connection_state(OUT_BLUETOOTH_SCO, AUDIO_DEVICE_DISCONNECTED); +// audio_manager_set_device_connection_state(IN_MODEM_HEADSET, AUDIO_DEVICE_DISCONNECTED); +// audio_manager_set_device_connection_state(OUT_MODEM_HEADSET, AUDIO_DEVICE_DISCONNECTED); +// /* 释放音频焦点 */ +// audio_manager_deactivate_interrupt(); +// audio_manager_deinit(); + +// return 0; +// } +// #endif + + + + +// static int32_t sample_audio_init_start_task_body(const void *data) +// { + +// unused(data); +// WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"sample_audio_init_start enter\n"); +// while ((g_hfp_media_flag != HFP_MEDIA_FLAG_IDLE) || (g_hfp_media_status != HFP_MEDIA_STATUS_DEINIT)) { +// osal_msleep(1); +// } +// /* 设置媒体状态繁忙 */ +// g_hfp_media_flag = HFP_MEDIA_FLAG_BUSY; +// int ret; +// audio_stream_init(); + +// /* Init success */ +// g_hfp_media_status = HFP_MEDIA_STATUS_INIT; + +// /* 建立电话上下行通路 */ +// establish_audio_stream_pipeline(); + +// WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"sample_audio_init_start end\n"); +// /* Start success */ +// g_hfp_media_status = HFP_MEDIA_STATUS_START; +// g_hfp_media_flag = HFP_MEDIA_FLAG_IDLE; +// return 0; +// } + +// static int32_t sample_audio_deinit_task_body(const void *data) +// { +// unused(data); +// WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"sample_audio_deinit enter\n"); +// while ((g_hfp_media_flag != HFP_MEDIA_FLAG_IDLE) || (g_hfp_media_status != HFP_MEDIA_STATUS_START)) { +// osal_msleep(1); +// } +// WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"sample_audio_deinit start\n"); +// /* 设置媒体状态繁忙 */ +// g_hfp_media_flag = HFP_MEDIA_FLAG_BUSY; +// abrogation_audio_stream_pipeline(); + +// WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"sample_audio_deinit end\n"); +// /* Deinit success */ +// g_hfp_media_status = HFP_MEDIA_STATUS_DEINIT; +// g_hfp_media_flag = HFP_MEDIA_FLAG_IDLE; +// return 0; +// } + +// static void sample_hfp_ag_set_spk_volume(uint8_t volume) +// { + +// /* vol range [0, 100] */ +// int32_t vol = volume * SAMPLE_HFP_MEDIA_VOL_LEVEL / SAMPLE_HFP_PROF_VOL_LEVEL; +// audio_manager_set_volume(AUDIO_STREAM_VOICE_CALL_VOLTE, vol); + +// } + + + +// static void sample_hfp_ag_conn_state_changed_callback(const bd_addr_t *bd_addr, profile_connect_state_t state) +// { +// sample_hfp_ag_print_addr(bd_addr); +// WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"state: %d\n", state); +// //如果触发连接为电话状态，自动切到电话 +// if(state==PROFILE_STATE_CONNECTED) +// { +// if(OHOS::CallerLogModel::GetInstance()->GetCallSource() == OHOS::CallerLogModel::CallSourceCat1 +// && OHOS::NotificationManager::GetInstance()->GetWatchCallStatus()) +// { +// // cat1_connect_sco_(); +// WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"电话状态\n"); +// uint8_t sleep_time=500; +// do_custom_cmd_service_check_msg(CUSTOM_CMD_MSG_CAT_HFP_SCO_CONNECT, &sleep_time, sizeof(sleep_time)); +// } +// else +// { +// WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"未电话状态\n"); +// } +// } + +// if(state==PROFILE_STATE_DISCONNECTED) +// { +// } +// AG_connect_state=state; +// memcpy_s((void*)&AG_bd_addr,sizeof(bd_addr_t),bd_addr,sizeof(bd_addr_t)); + +// } + + +// void cat1_start_SCO_audio_(void) +// { +// uapi_cat1_start_SCO_volte_voice(); +// } + + +// #ifdef __cplusplus +// extern "C" { +// #endif + +// static void PostGraphicEvent(void (*fun)(void)) +// { +// WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[PostGraphicEvent] start"); +// GraphicService::GetInstance()->PostGraphicEvent(*fun); +// } + +// #ifdef __cplusplus +// } +// #endif + +// static void connectedHandle() +// { +// OHOS::BluetoothModel::GetInstance()->SetTagDisconnectView(false); +// OHOS::BluetoothDeviceListView *bluetoothDeviceListView =OHOS:: BluetoothDeviceListView::GetInstance(); +// if (bluetoothDeviceListView == nullptr) { +// WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "AclStateChangedCallback bluetoothDeviceListView == nullptr"); +// return; +// } +// OHOS::UIList *deviceList = bluetoothDeviceListView->GetDeviceUIList(); +// if (deviceList == nullptr) { +// WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "DisconnectedHandle deviceList nullptr"); +// return; +// } +// deviceList->RefreshList(); +// // BluetoothOptionsView *bluetoothOptionsView = BluetoothOptionsView::GetInstance(); +// // if (bluetoothOptionsView == nullptr) { +// // WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "AclStateChangedCallback bluetoothOptionsView == nullptr"); +// // return; +// // } +// // bluetoothOptionsView->RefreshText(); +// } + + + +// void HFP_SCO_STATE_CONNECTEDPro(void) +// { +// if(volte_voice_state()==0) +// { +// do_custom_cmd_service_check_msg(CUSTOM_CMD_MSG_CAT_HFP_SCO_AUDIO_START, nullptr, 0); +// } +// else +// { +// if(OHOS::CallerLogModel::GetInstance()->GetCallSource() == OHOS::CallerLogModel::CallSourceCat1 +// && OHOS::NotificationManager::GetInstance()->GetWatchCallStatus()) +// { +// do_custom_cmd_service_check_msg(CUSTOM_CMD_MSG_CAT1_AUDIO_STOP, nullptr, 0); + +// do_custom_cmd_service_check_msg(CUSTOM_CMD_MSG_CAT_HFP_SCO_AUDIO_START, nullptr, 0); +// } + +// } +// connectedHandle(); + +// } + +// void HFP_SCO_STATE_DISCONNECTEDPro(void) +// { +// if(OHOS::CallerLogModel::GetInstance()->GetCallSource() == OHOS::CallerLogModel::CallSourceCat1 +// && OHOS::NotificationManager::GetInstance()->GetWatchCallStatus()) +// { +// do_custom_cmd_service_check_msg(CUSTOM_CMD_MSG_CAT1_AUDIO_STOP, nullptr, 0); + +// do_custom_cmd_service_check_msg(CUSTOM_CMD_MSG_CAT1_AUDIO_START, nullptr, 0); +// } +// else +// { +// do_custom_cmd_service_check_msg(CUSTOM_CMD_MSG_CAT_AUDIO_END, nullptr, 0); + +// do_custom_cmd_service_check_msg(CUSTOM_CMD_MSG_CAT1_AUDIO_STOP, nullptr, 0); +// } +// connectedHandle(); + +// } + + + +// static void sample_hfp_ag_sco_conn_state_changed_callback(const bd_addr_t *bd_addr, hfp_sco_connect_state_t state) +// { +// sample_hfp_ag_print_addr(bd_addr); +// WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"state: %d\n", state); +// osal_kthread_handler task_body = NULL; +// switch (state) { +// case HFP_SCO_STATE_CONNECTING: +// break; + +// case HFP_SCO_STATE_CONNECTED: + +// PostGraphicEvent(HFP_SCO_STATE_CONNECTEDPro); +// Call_headset_state_updata(1); +// break; + +// case HFP_SCO_STATE_DISCONNECTING: +// break; +// case HFP_SCO_STATE_DISCONNECTED: + +// PostGraphicEvent(HFP_SCO_STATE_DISCONNECTEDPro); +// Call_headset_state_updata(0); +// break; + +// default: { +// WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"invalid state!\n"); +// break; +// } +// } +// } + +// static void sample_hfp_ag_codec_changed_callback(const bd_addr_t *bd_addr, hfp_ag_codec_id_t codec) +// { +// sample_hfp_ag_print_addr(bd_addr); +// WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"codec : %d\n", codec); +// if (codec == HFP_AG_CODEC_ID_CVSD) { + +// g_hfp_codec = PCM; +// updata_Audio_code_hfp(0); + +// } else if (codec == HFP_AG_CODEC_ID_MSBC) { + +// g_hfp_codec = mSBC; +// updata_Audio_code_hfp(1); +// } + + + +// } + +// void hfp_ag_cmd_conn_last_hfp(void) +// { +// bd_addr_t *lastAddr = OHOS::BluetoothModel::GetInstance()->GetLastConnedAddr(); +// hfp_ag_cmd_conn_hfp(lastAddr); +// } + +// static void sample_hfp_ag_volume_changed_callback(const bd_addr_t *bd_addr, hfp_volume_type_t type, uint8_t volume) +// { +// sample_hfp_ag_print_addr(bd_addr); +// WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"type: %d, volume: %u\n", type, volume); +// if (type == HFP_VOLUME_SPEAKER) { +// // sample_hfp_ag_set_spk_volume(volume); +// } +// } + +// static void sample_hfp_ag_dial_req_callback(const bd_addr_t *bd_addr, unsigned char *number, unsigned int len) +// { +// sample_hfp_ag_print_addr(bd_addr); +// for (unsigned int i = 0; i < len; i++) { +// WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"number: %d ", *((uint8_t *)number + i)); +// } +// WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"len: %d.\n", len); +// } + +// static void sample_hfp_ag_mem_dial_req_callback(const bd_addr_t *bd_addr, unsigned int index) +// { +// sample_hfp_ag_print_addr(bd_addr); +// WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"index: %d.\n", index); +// } + +// static void sample_hfp_ag_lastnum_dial_req_callback(const bd_addr_t *bd_addr) +// { +// sample_hfp_ag_print_addr(bd_addr); +// } + +// static void sample_hfp_ag_answer_call_req_callback(const bd_addr_t *bd_addr, hfp_ag_type_t type) +// { +// sample_hfp_ag_print_addr(bd_addr); + +// WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"type: %d.\n", type); +// } + +// static void sample_hfp_ag_cancel_call_req_callback(const bd_addr_t *bd_addr, hfp_ag_type_t type) +// { +// sample_hfp_ag_print_addr(bd_addr); +// WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"type: %d.\n", type); +// } + +// static void sample_hfp_ag_dtmf_req_callback(const bd_addr_t *bd_addr, unsigned int code) +// { +// sample_hfp_ag_print_addr(bd_addr); +// WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"code: 0x%x.\n", code); +// } + +// static void sample_hfp_ag_subscriber_number_req_callback(const bd_addr_t *bd_addr) +// { +// sample_hfp_ag_print_addr(bd_addr); +// /* TODO 造数据响应 */ +// } + +// static void sample_hfp_ag_current_calls_req_callback(const bd_addr_t *bd_addr) +// { +// sample_hfp_ag_print_addr(bd_addr); +// /* TODO 造数据响应 */ +// } + +// static void sample_hfp_ag_current_indicator_req_callback(const bd_addr_t *bd_addr) +// { +// g_sample_hfp_cind_info.service = 1; +// g_sample_hfp_cind_info.call = 0; +// g_sample_hfp_cind_info.callsetup = 0; +// g_sample_hfp_cind_info.callheld = 0; +// g_sample_hfp_cind_info.signal = HFP_AG_IND_SIGNAL_DEFAULT; +// g_sample_hfp_cind_info.roam = 0; +// g_sample_hfp_cind_info.battchg = HFP_AG_IND_BATTERY_DEFAULT; +// errcode_t ret = (errcode_t)hfp_ag_send_indicator_val(bd_addr, &g_sample_hfp_cind_info); +// WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"sample hfp ag send cur indicator cbk ret=0x%x\n", ret); +// } + +// static void sample_hfp_ag_network_operator_format_req_callback(const bd_addr_t *bd_addr) +// { +// sample_hfp_ag_print_addr(bd_addr); +// WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"sample hfp ag AT+COPS= req cbk.\n"); +// } + +// static void sample_hfp_ag_network_operator_req_callback(const bd_addr_t *bd_addr) +// { +// sample_hfp_ag_print_addr(bd_addr); +// WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"sample hfp ag AT+COPS? req cbk.\n"); +// } + +// static void sample_hfp_ag_init(const char **params, int32_t params_cnt) +// { +// unused(params); +// unused(params_cnt); +// // hfp_ag_service_init(); +// WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"sample hfp ag init done.\n"); +// } + +// static void sample_hfp_ag_deinit(const char **params, int32_t params_cnt) +// { +// unused(params); +// unused(params_cnt); +// // hfp_ag_service_deinit(); +// WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"sample hfp ag deinit done.\n"); +// } + +// void hfp_ag_reg_callback(void) +// { + +// errcode_t ret = ERRCODE_BT_SUCCESS; +// hfp_ag_callbacks_t callbacks = { +// sample_hfp_ag_conn_state_changed_callback, +// sample_hfp_ag_sco_conn_state_changed_callback, +// sample_hfp_ag_codec_changed_callback, +// sample_hfp_ag_volume_changed_callback, +// sample_hfp_ag_dial_req_callback, +// sample_hfp_ag_mem_dial_req_callback, +// sample_hfp_ag_lastnum_dial_req_callback, +// sample_hfp_ag_answer_call_req_callback, +// sample_hfp_ag_cancel_call_req_callback, +// sample_hfp_ag_dtmf_req_callback, +// sample_hfp_ag_subscriber_number_req_callback, +// sample_hfp_ag_current_calls_req_callback, +// sample_hfp_ag_current_indicator_req_callback, +// sample_hfp_ag_network_operator_format_req_callback, +// sample_hfp_ag_network_operator_req_callback, +// }; +// ret = (errcode_t)hfp_ag_register_callbacks(&callbacks); +// WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"sample hfp ag reg cbk ret=0x%x\n", ret); +// } + +// /* */ +// errcode_t hfp_ag_cmd_conn_hfp(const bd_addr_t *bd_addr) +// { +// errcode_t ret = (errcode_t)hfp_ag_connect(bd_addr); +// WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"ret: %u\n", ret); +// return ret; +// } + +// /* */ +// errcode_t hfp_ag_cmd_disconn_hfp(const bd_addr_t *bd_addr) +// { + +// errcode_t ret = (errcode_t)hfp_ag_disconnect(bd_addr); +// WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"ret: %u\n", ret); +// return ret; +// } + +// /* */ +// void hfp_ag_cmd_conn_sco(const bd_addr_t *bd_addr ) +// { +// // if(headset_Is_connect) +// errcode_t ret = (errcode_t)hfp_ag_audio_connect(bd_addr); +// WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"ret: %u %02X %02X %02X %02X %02X %02X\n", ret,bd_addr->addr[5] +// ,bd_addr->addr[4],bd_addr->addr[3],bd_addr->addr[2],bd_addr->addr[1],bd_addr->addr[0]); +// } + +// /* */ +// void hfp_ag_cmd_disconn_sco(const bd_addr_t *bd_addr ) +// { +// errcode_t ret = (errcode_t)hfp_ag_audio_disconnect(bd_addr); +// WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"ret: %u\n", ret); +// } + +// /* */ +// static void sample_hfp_ag_cmd_get_dev_conn_state(const char **params, int32_t params_cnt) +// { +// // if (params_cnt != 1) { +// // WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"sample hfp ag dev conn state param is invalid.\n"); +// // return; +// // } +// // bd_addr_t bd_addr; +// // if (decode_bd_addr_from_str(params[0], bd_addr.addr, BD_ADDR_LEN) != EXT_ERR_SUCCESS) { +// // WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"sample hfp ag dev conn state decode addr error!\n"); +// // return; +// // } +// // int ret = hfp_ag_get_device_connect_state(&bd_addr); +// // WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"ret: %d\n", ret); +// } + +// /* */ +// static void sample_hfp_ag_cmd_get_sco_conn_state(const char **params, int32_t params_cnt) +// { +// // if (params_cnt != 1) { +// // WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"sample hfp ag sco state param is invalid.\n"); +// // return; +// // } +// // bd_addr_t bd_addr; +// // if (decode_bd_addr_from_str(params[0], bd_addr.addr, BD_ADDR_LEN) != EXT_ERR_SUCCESS) { +// // WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"sample hfp ag sco state decode addr error!\n"); +// // return; +// // } +// // int ret = hfp_ag_get_sco_connect_state(&bd_addr); +// // WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"ret: %d\n", ret); +// } + +// /* */ +// static void sample_hfp_ag_cmd_answer_call(const char **params, int32_t params_cnt) +// { +// // if (params_cnt != 1) { +// // WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"sample hfp ag answer call param is invalid.\n"); +// // return; +// // } +// // bd_addr_t bd_addr; +// // if (decode_bd_addr_from_str(params[0], bd_addr.addr, BD_ADDR_LEN) != EXT_ERR_SUCCESS) { +// // WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"sample hfp ag answer call decode addr error!\n"); +// // return; +// // } +// // errcode_t ret = (errcode_t)hfp_ag_send_answer_call_event(&bd_addr); +// // WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"ret: %d\n", ret); +// } + +// /* */ +// static void sample_hfp_ag_cmd_finish_call(const char **params, int32_t params_cnt) +// { +// // if (params_cnt != 2) { /* 2: param count */ +// // WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"sample hfp ag finish call param is invalid.\n"); +// // return; +// // } +// // bd_addr_t bd_addr; +// // if (decode_bd_addr_from_str(params[0], bd_addr.addr, BD_ADDR_LEN) != EXT_ERR_SUCCESS) { +// // WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"sample hfp ag finish call decode addr error!\n"); +// // return; +// // } +// // hfp_ag_action_t type = (hfp_ag_action_t)atoi(params[1]); +// // errcode_t ret = (errcode_t)hfp_ag_send_finish_call_event(&bd_addr, type); +// // WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"type: %d ret: %d\n", type, ret); +// } + +// /* */ +// static void sample_hfp_ag_cmd_set_volume(const char **params, int32_t params_cnt) +// { +// // if (params_cnt != 3) { /* 3个参数 */ +// // WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"params cnt err: %d!\n", params_cnt); +// // return; +// // } +// // bd_addr_t bd_addr; +// // if (decode_bd_addr_from_str(params[0], bd_addr.addr, BD_ADDR_LEN) != EXT_ERR_SUCCESS) { +// // WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"sample hfp ag set volume decode addr error!\n"); +// // return; +// // } +// // hfp_volume_type_t type = (hfp_volume_type_t)atoi(params[1]); /* 第1个参数 */ +// // uint8_t volume = (uint8_t)atoi(params[2]); /* 第2个参数 */ +// // errcode_t ret = (errcode_t)hfp_ag_set_volume(&bd_addr, type, volume); +// // WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"type: %d volume: %u ret: %u\n", type, volume, ret); +// } + +// /* */ +// static void sample_hfp_ag_cmd_send_network_event(const char **params, int32_t params_cnt) +// { +// // if (params_cnt != 3) { /* 3个参数 */ +// // WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"params cnt err: %d!\n", params_cnt); +// // return; +// // } +// // bd_addr_t bd_addr; +// // if (decode_bd_addr_from_str(params[0], bd_addr.addr, BD_ADDR_LEN) != EXT_ERR_SUCCESS) { +// // WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"sample hfp ag set volume decode addr error!\n"); +// // return; +// // } +// // hfp_ag_network_event_t event = (hfp_ag_network_event_t)atoi(params[1]); /* 第1个参数 */ +// // uint8_t param = (uint8_t)atoi(params[2]); /* 第2个参数 */ +// // errcode_t ret = (errcode_t)hfp_ag_send_network_event(&bd_addr, event, param); +// // WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"event: %d param: %u ret: %u\n", event, param, ret); +// } + +// /* */ +// static void sample_hfp_ag_cmd_send_incoming_event(const char **params, int32_t params_cnt) +// { +// // if (params_cnt != 5) { /* 5个参数 */ +// // WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"params cnt err: %d!\n", params_cnt); +// // return; +// // } +// // bd_addr_t bd_addr; +// // if (decode_bd_addr_from_str(params[0], bd_addr.addr, BD_ADDR_LEN) != EXT_ERR_SUCCESS) { +// // WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"sample hfp ag set volume decode addr error!\n"); +// // return; +// // } + +// // uint8_t type = (uint8_t)atoi(params[1]); /* index:1 */ +// // uint8_t service = (uint8_t)atoi(params[2]); /* index:2 */ +// // char *number_str = params[3]; /* index:3 */ +// // size_t str_len = strlen(number_str); +// // if (str_len > HFP_AG_PHONENUM_MAX_DIGITS) { /* number最大长度为32 */ +// // WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"number len exceeds max limit! str_len = %u \n", str_len); +// // return; +// // } +// // uint8_t number_len = (uint8_t)str_len; + +// // char *name_str = params[4]; /* index:4 *//* index:4 */ +// // size_t name_str_len = strlen(name_str); +// // if (name_str_len > 256) { /* name最大长度为256 */ +// // WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"name len exceeds max limit! str_len = %u \n", str_len); +// // return; +// // } +// // uint8_t name_len = (uint8_t)name_str_len; + +// // hfp_phone_info_t *info = bt_os_new(sizeof(hfp_phone_info_t) + name_len); +// // if (memset_s(info, sizeof(hfp_phone_info_t) + name_len, 0, +// // sizeof(hfp_phone_info_t) + name_len) != EOK) { +// // bt_os_free(info); +// // return; +// // } +// // info->type = type; +// // info->service = service; +// // info->num_len = number_len; +// // if (memcpy_s(info->number, HFP_AG_PHONENUM_MAX_DIGITS, (uint8_t *)number_str, str_len) != EOK) { +// // WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"number memcpy error.\n"); +// // bt_os_free(info); +// // return; +// // } +// // info->name_len = name_len; +// // if (memcpy_s(info->alpha_str, name_len, (int8_t *)name_str, name_len) != EOK) { +// // WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"name memcpy error.\n"); +// // bt_os_free(info); +// // return; +// // } +// // errcode_t ret = (errcode_t)hfp_ag_send_network_incoming_event(&bd_addr, info); +// // bt_os_free(info); +// // WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"ret: %u\n", ret); +// } + +// /* */ +// static void sample_hfp_ag_cmd_send_call_list(const char **params, int32_t params_cnt) +// { +// // if (params_cnt != 9) { /* 9个参数 */ +// // WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"params cnt err: %d!\n", params_cnt); +// // return; +// // } +// // bd_addr_t bd_addr; +// // if (decode_bd_addr_from_str(params[0], bd_addr.addr, BD_ADDR_LEN) != EXT_ERR_SUCCESS) { +// // WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"sample hfp ag set volume decode addr error!\n"); +// // return; +// // } +// // uint8_t number_len = 0; +// // char *number_str = params[7]; /* 7:idx */ +// // size_t str_len = strlen(number_str); +// // if (str_len > HFP_AG_PHONENUM_MAX_DIGITS) { /* number最大长度为32 */ +// // WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"number len exceeds max limit! str_len = %u \n", str_len); +// // return; +// // } +// // number_len = (uint8_t)str_len; +// // hfp_clcc_info_t *info = bt_os_new(sizeof(hfp_clcc_info_t) + number_len); +// // if (memset_s(info, sizeof(hfp_clcc_info_t) + number_len, 0, +// // sizeof(hfp_clcc_info_t) + number_len) != EOK) { +// // bt_os_free(info); +// // return; +// // } +// // info->idx = (uint8_t)atoi(params[1]); +// // info->dir = (uint8_t)atoi(params[2]); /* 2:idx */ +// // info->status = (uint8_t)atoi(params[3]); /* 3:idx */ +// // info->mode = (uint8_t)atoi(params[4]); /* 4:idx */ +// // info->mpty = (uint8_t)atoi(params[5]); /* 5:idx */ +// // info->type = (uint8_t)atoi(params[6]); /* 6:idx */ +// // info->num_len = number_len; +// // if (memcpy_s(info->number, number_len, (uint8_t *)number_str, str_len) != EOK) { +// // WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"number memcpy error.\n"); +// // bt_os_free(info); +// // return; +// // } + +// // hfp_ag_last_t is_last = (hfp_ag_last_t)atoi(params[8]); /* 8:idx */ +// // errcode_t ret = (errcode_t)hfp_ag_send_current_calls(&bd_addr, info, is_last); +// // bt_os_free(info); +// // WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"ret: %u\n", ret); +// } + +// /* */ +// static void sample_hfp_ag_cmd_send_subscriber_number(const char **params, int32_t params_cnt) +// { +// // if (params_cnt != 6) { /* 6个参数 */ +// // WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"params cnt err: %d!\n", params_cnt); +// // return; +// // } +// // bd_addr_t bd_addr; +// // if (decode_bd_addr_from_str(params[0], bd_addr.addr, BD_ADDR_LEN) != EXT_ERR_SUCCESS) { +// // WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"sample hfp ag set volume decode addr error!\n"); +// // return; +// // } + +// // uint8_t type = (uint8_t)atoi(params[1]); /* index:1 */ +// // uint8_t service = (uint8_t)atoi(params[2]); /* index:2 */ +// // char *number_str = params[3]; /* index:3 */ +// // size_t str_len = strlen(number_str); +// // if (str_len > 32) { /* number最大长度为32 */ +// // WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"number len exceeds max limit! str_len = %u \n", str_len); +// // return; +// // } +// // uint8_t number_len = (uint8_t)str_len; + +// // char *name_str = params[4]; /* index:4 *//* index:4 */ +// // size_t name_str_len = strlen(name_str); +// // if (name_str_len > 256) { /* name最大长度为256 */ +// // WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"name len exceeds max limit! str_len = %u \n", str_len); +// // return; +// // } +// // uint8_t name_len = (uint8_t)name_str_len; + +// // hfp_phone_info_t *info = bt_os_new(sizeof(hfp_phone_info_t) + name_len); +// // if (memset_s(info, sizeof(hfp_phone_info_t) + name_len, 0, +// // sizeof(hfp_phone_info_t) + name_len) != EOK) { +// // bt_os_free(info); +// // return; +// // } +// // info->type = type; +// // info->service = service; +// // info->num_len = number_len; +// // if (memcpy_s(info->number, HFP_AG_PHONENUM_MAX_DIGITS, (uint8_t *)number_str, str_len) != EOK) { +// // bt_os_free(info); +// // return; +// // } +// // info->name_len = name_len; +// // if (memcpy_s(info->alpha_str, name_len, (int8_t *)name_str, name_len) != EOK) { +// // bt_os_free(info); +// // return; +// // } +// // hfp_ag_last_t is_last = (hfp_ag_last_t)atoi(params[5]); +// // errcode_t ret = (errcode_t)hfp_ag_send_subscriber_number(&bd_addr, info, is_last); +// // bt_os_free(info); +// // WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"ret: %u\n", ret); +// } + +// /* */ +// static void sample_hfp_ag_cmd_send_battery_charge(const char **params, int32_t params_cnt) +// { +// // if (params_cnt != 2) { /* 2个参数 */ +// // WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"params cnt err: %d!\n", params_cnt); +// // return; +// // } +// // bd_addr_t bd_addr; +// // if (decode_bd_addr_from_str(params[0], bd_addr.addr, BD_ADDR_LEN) != EXT_ERR_SUCCESS) { +// // WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"sample hfp ag send battery charge decode addr error!\n"); +// // return; +// // } +// // uint8_t value = (uint8_t)atoi(params[1]); /* 第1个参数 */ +// // errcode_t ret = (errcode_t)hfp_ag_send_battery_charge(&bd_addr, value); +// // WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"value: %d ret: %u\n", value, ret); +// } + +// /* */ +// static void sample_hfp_ag_cmd_send_cmee_error(const char **params, int32_t params_cnt) +// { +// // if (params_cnt != 2) { /* 2个参数 */ +// // WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"params cnt err: %d!\n", params_cnt); +// // return; +// // } +// // bd_addr_t bd_addr; +// // if (decode_bd_addr_from_str(params[0], bd_addr.addr, BD_ADDR_LEN) != EXT_ERR_SUCCESS) { +// // WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"sample hfp ag send cmee error decode addr error!\n"); +// // return; +// // } +// // hfp_ag_cmee_error_t error_code = (hfp_ag_cmee_error_t)atoi(params[1]); /* 第1个参数 */ +// // errcode_t ret = (errcode_t)hfp_ag_send_cmee_error(&bd_addr, error_code); +// // WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"error_code: %d ret: %u\n", error_code, ret); +// } + +// /* */ +// static void sample_hfp_ag_cmd_send_network_operator(const char **params, int32_t params_cnt) +// { +// // if (params_cnt != 4) { /* 4个参数 */ +// // WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"params cnt err: %d!\n", params_cnt); +// // return; +// // } +// // bd_addr_t bd_addr; +// // if (decode_bd_addr_from_str(params[0], bd_addr.addr, BD_ADDR_LEN) != EXT_ERR_SUCCESS) { +// // WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"sample hfp ag send network operator decode addr error!\n"); +// // return; +// // } + +// // char *operator_name = params[3]; /* index3 */ +// // uint8_t operator_len = 0; +// // size_t name_str_len = strlen(operator_name); +// // if (name_str_len > HFP_AG_COPS_OPERATOR_MAXLEN) { /* name最大长度为16 */ +// // WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"name len exceeds max limit! str_len = %u \n", name_str_len); +// // return; +// // } +// // operator_len = (uint8_t)name_str_len; + +// // hfp_cops_info_t *info = bt_os_new(sizeof(hfp_cops_info_t) + operator_len); +// // if (memset_s(info, sizeof(hfp_cops_info_t) + operator_len, 0, +// // sizeof(hfp_cops_info_t) + operator_len) != EOK) { +// // bt_os_free(info); +// // return; +// // } +// // info->mode = (uint8_t)atoi(params[1]); +// // info->format = (uint8_t)atoi(params[2]); /* index2 */ +// // info->operator_len = operator_len; +// // if (memcpy_s(info->operator_name, operator_len, (int8_t *)operator_name, operator_len) != EOK) { +// // WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"name memcpy error.\n"); +// // bt_os_free(info); +// // return; +// // } + +// // errcode_t ret = (errcode_t)hfp_ag_send_network_operator(&bd_addr, info); +// // bt_os_free(info); +// // WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"ret: %u\n", ret); +// } + +// /* */ +// static void sample_hfp_ag_cmd_send_indicator_val(const char **params, int32_t params_cnt) +// { +// // if (params_cnt != 8) { /* 8个参数 */ +// // WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"params cnt err: %d!\n", params_cnt); +// // return; +// // } +// // bd_addr_t bd_addr; +// // if (decode_bd_addr_from_str(params[0], bd_addr.addr, BD_ADDR_LEN) != EXT_ERR_SUCCESS) { +// // WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"sample hfp ag send indicator val decode addr error!\n"); +// // return; +// // } + +// // g_sample_hfp_cind_info.service = (uint8_t)atoi(params[1]); +// // g_sample_hfp_cind_info.call = (uint8_t)atoi(params[2]); /* index:2 */ +// // g_sample_hfp_cind_info.callsetup = (uint8_t)atoi(params[3]); /* index:3 */ +// // g_sample_hfp_cind_info.callheld = (uint8_t)atoi(params[4]); /* index:4 */ +// // g_sample_hfp_cind_info.signal = (uint8_t)atoi(params[5]); /* index:5 */ +// // g_sample_hfp_cind_info.roam = (uint8_t)atoi(params[6]); /* index:6 */ +// // g_sample_hfp_cind_info.battchg = (uint8_t)atoi(params[7]); /* index:7 */ + +// // errcode_t ret = (errcode_t)hfp_ag_send_indicator_val(&bd_addr, &g_sample_hfp_cind_info); +// // WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"ret: %u\n", ret); +// } + +// /* */ + + +// bool headset_Is_connect(void) +// { +// // int state = hfp_ag_get_device_connect_state(&AG_bd_addr); +// sample_hfp_ag_print_addr(&AG_bd_addr); +// if(AG_connect_state==PROFILE_STATE_CONNECTED) +// { +// return true; +// } +// else +// { +// WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"NO PROFILE_STATE_CONNECTED"); +// return false; +// } +// } + + +// bool headset_SCO_Is_connect(void) +// { +// int state = hfp_ag_get_sco_connect_state(&AG_bd_addr); +// if(state==PROFILE_STATE_CONNECTED) +// { +// return true; +// } +// else +// { +// return false; +// } +// } + + +// bool headset_SCO_Is_connect_extend(bd_addr_t *bd_addr) +// { +// sample_hfp_ag_print_addr(bd_addr); +// int sco_state = hfp_ag_get_sco_connect_state(bd_addr); +// int ag_state= hfp_ag_get_device_connect_state(bd_addr); +// bool ACL_state= bt_is_acl_connected(bd_addr); +// if(sco_state==PROFILE_STATE_CONNECTED && ag_state==PROFILE_STATE_CONNECTED && ACL_state==true) +// { +// WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"PROFILE_STATE_CONNECTED"); +// return true; +// } +// else +// { +// WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"NO PROFILE_STATE_CONNECTED"); +// return false; +// } +// } + + +// void cat1_connect_sco_(uint8_t time) +// { +// //AudioActInterrupt(AUDIO_STREAM_VOICE_CALL_VOLTE); +// #ifdef SUPPORT_CAT1_HFP_AG_SERV +// if(time) +// osal_msleep(time); +// hfp_ag_cmd_conn_sco(&AG_bd_addr); +// #endif + +// } + + +// void cat1_disconn_sco_(void) +// { +// //AudioActInterrupt(AUDIO_STREAM_VOICE_CALL_VOLTE); +// #ifdef SUPPORT_CAT1_HFP_AG_SERV +// hfp_ag_cmd_disconn_sco(&AG_bd_addr); +// #endif + +// } + +// void cat1_set_headset_volume( unsigned char volume) +// { +// //AudioActInterrupt(AUDIO_STREAM_VOICE_CALL_VOLTE); +// hfp_ag_set_volume(&AG_bd_addr,HFP_VOLUME_SPEAKER,volume); + +// } + + +// // uint8_t type; /*!< @if Eng The format of the phone number provided, the region of value is 128-175 +// // @else 电话号码类型，值范围是128-175 @endif */ +// // uint8_t service; /*!< @if Eng Indicates which service this phone number relates to. +// // Shall be either 4 (voice) or 5 (fax). See @ref hfp_ag_cnum_service_t +// // @else 服务类型，协议支持4或5，见 @ref hfp_ag_cnum_service_t @endif */ +// // uint8_t num_len; /*!< @if Eng The length of the phone number @else 电话号码长度 @endif */ +// // int8_t number[HFP_AG_PHONENUM_MAX_DIGITS]; /*!< @if Eng Subscriber number, the length shall be 32 +// // @else 订阅号码，最大长度是32 @endif */ +// // uint8_t name_len; /*!< @if Eng Length of subaddr @else 子地址长度 @endif */ +// // int8_t alpha_str[1]; /*!< @if Eng string type subaddress of format specified by +// // @else 子地址，协议默认是0 @endif */ + + +// int cat1_ag_send_call_event( uint32_t event_topic, const char* info) +// { +// //AudioActInterrupt(AUDIO_STREAM_VOICE_CALL_VOLTE); +// int ret=0; + +// hfp_phone_info_t phone_info={0}; +// if(info!=nullptr) +// { +// phone_info.type=128; +// phone_info.service=4; +// phone_info.num_len=strlen(info); +// memcpy_s(phone_info.number,HFP_AG_PHONENUM_MAX_DIGITS,info,phone_info.num_len); +// phone_info.name_len=strlen(info); +// phone_info.alpha_str[0]=0; +// } + +// switch (event_topic) +// { +// case TOPIC_EVENT_CAT1_INCOMMING: +// ret=hfp_ag_send_network_incoming_event(&AG_bd_addr,&phone_info); +// break; +// case TOPIC_EVENT_CAT1_CALLCONNTED: +// ret=hfp_ag_send_answer_call_event(&AG_bd_addr); +// break; +// case TOPIC_EVENT_CAT1_CALLENDED: +// ret=hfp_ag_send_finish_call_event(&AG_bd_addr,HFP_AG_CANCELED_LASTCALL); +// break; +// case TOPIC_EVENT_CAT1_CALLDIAL: +// ret=hfp_ag_send_originate_call_event(&AG_bd_addr); +// break; +// default: +// ret=ERRCODE_BT_FAIL; +// break; +// } +// WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"cat1_ag_send_call_event %X %X %X %X %d %X\n", +// AG_bd_addr.addr[5],AG_bd_addr.addr[4], +// AG_bd_addr.addr[3],AG_bd_addr.addr[2], +// event_topic,ret); +// return ret; +// } + + + +// // #ifdef __cplusplus +// // } +// // #endif diff --git a/code/sdk/application/wearable/fd230/nativeapp/nativeui/phoneservice/src/PhoneAudio.cpp b/code/sdk/application/wearable/fd230/nativeapp/nativeui/phoneservice/src/PhoneAudio.cpp index 8b695c89a..0827015f5 100644 --- a/code/sdk/application/wearable/fd230/nativeapp/nativeui/phoneservice/src/PhoneAudio.cpp +++ b/code/sdk/application/wearable/fd230/nativeapp/nativeui/phoneservice/src/PhoneAudio.cpp @@ -14,6 +14,11 @@ #include "audio_stream_out.h" #include "audio_errors.h" #include "wearable_log.h" +#include "audio_manager_c_wrapper.h" +#include "CallerLogModel.h" +#include "cat1_ctl.h" +#include "PhoneServiceC.h" + #ifdef __cplusplus extern "C" { @@ -32,7 +37,7 @@ using Audio::AudioInterrupt; static constexpr int32 AUDIO_CHANNEL_1 = 1; static constexpr int32 AUDIO_SAMPLE_RATE_16K = 16000; static constexpr int32 AUDIO_SAMPLE_RATE_8K = 8000; -static constexpr int32 AUDIO_STREAM_MAX_INSTANCE_NUM = 2; +static constexpr int32 AUDIO_STREAM_MAX_INSTANCE_NUM = 4; static constexpr int32 INVALID_AUDIO_VALUE = (-1); class PhoneAudioInterruptListener : public InterruptListener { @@ -55,6 +60,35 @@ std::shared_ptr g_audioIntListener = nullptr; static AudioSession g_sessionId; static AudioInterrupt g_interrupt; +int32 PhoneAudioGetCAT1MinVolume(void) +{ + int32 ret= g_amInstance.GetMinVolume(AUDIO_STREAM_VOICE_CALL_VOLTE); + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "%d",ret); + return ret; +} + +int32 PhoneAudioGetCAT1MAXVolume(void) +{ + int32 ret= g_amInstance.GetMaxVolume(AUDIO_STREAM_VOICE_CALL_VOLTE); + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "%d",ret); + return ret; +} + +int32 PhoneCAT1AudioGetVolume(void) +{ + int32 ret= g_amInstance.GetVolume(AUDIO_STREAM_VOICE_CALL_VOLTE); + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "%d",ret); + return ret; +} + + +bool PhoneCATAudioSetVolume(int32 volume) +{ + return g_amInstance.SetVolume(AUDIO_STREAM_VOICE_CALL_VOLTE, volume); +} + + + int32 PhoneAudioGetMinVolume(void) { return g_amInstance.GetMinVolume(AUDIO_STREAM_VOICE_CALL_BT_SCO); @@ -98,16 +132,34 @@ bool PhoneAudioSetSpeakerMute(bool isMute) bool PhoneAudioSetMicMute(bool isMute) { bool ret; - WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[PhoneAudioSetMicMute] start"); + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[PhoneAudioSetMicMute] start"); ret = g_amInstance.IsMicrophoneMute(); if (ret == isMute) { return true; } ret = g_amInstance.SetMicrophoneMute(isMute); - WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[PhoneAudioSetMicMute] end! ret = %d", ret); + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[PhoneAudioSetMicMute] end! ret = %d", ret); return ret; } +//cat1取消静音 +int32_t PhoneAudioSetMicMuteCat1(bool isMute) +{ + + int32_t ret; + // if(!volte_voice_state()) + // { + // return 0; + // } + ret=AudioStreamOutSetMute(isMute); + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[AudioStreamOutSetMute] end! ret = %d", ret); + return 0; + + +} + + + static bool CheckParam(int32 instanceNum) { if (instanceNum == 0 || instanceNum == 1) { @@ -480,6 +532,88 @@ int32 PhoneAudioManagerDeactInterrupt(void) WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[%s] line:%d success", __FUNCTION__, __LINE__); return AUDIO_SUCCESS; +} + +void Sample_audio_init(void) +{ + + + g_sessionId = g_amInstance.MakeSessionId(); + if (g_sessionId == AUDIO_SESSION_ID_NONE) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[%s] line:%d, make session id failed", __FUNCTION__, __LINE__); + return ; + } + + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[%s] line:%d, session id = %d", __FUNCTION__, __LINE__, g_sessionId); + + g_audioIntListener = std::make_shared(); + if (g_audioIntListener.get() == nullptr) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[%s] line:%d, g_audioIntListener is null", __FUNCTION__, __LINE__); + return ; + } + g_interrupt = { AUDIO_STREAM_VOICE_CALL_VOLTE, g_sessionId, g_audioIntListener }; + if (g_amInstance.ActivateAudioInterrupt(g_interrupt) == INTERRUPT_FAILED) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[%s] line:%d, ActivateAudioInterrupt failed", __FUNCTION__, __LINE__); + return ; + } + + + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[%s] line:%d, success", __FUNCTION__, __LINE__); + + g_amInstance.SetDeviceConnectionState(IN_BLUETOOTH_SCO, AUDIO_DEVICE_CONNECTED); + g_amInstance.SetDeviceConnectionState(OUT_BLUETOOTH_SCO, AUDIO_DEVICE_CONNECTED); + g_amInstance.SetDeviceConnectionState(IN_MODEM_HEADSET, AUDIO_DEVICE_CONNECTED); + g_amInstance.SetDeviceConnectionState(OUT_MODEM_HEADSET, AUDIO_DEVICE_CONNECTED); + + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[%s] line:%d, success", __FUNCTION__, __LINE__); + + g_streamIn[2] = std::make_shared(); + g_streamOut[2] = std::make_shared(); + + g_streamOut[3] = std::make_shared(); + g_streamIn [3]= std::make_shared(); + + /* 初始化通话上行流实例 */ + CapturerInputConfig captureConfig = {}; + captureConfig.audioFormat = mSBC; + captureConfig.channelCount = 1; + captureConfig.linkDir = AUDIO_DOWN_LINK; + captureConfig.sampleRate = 16000; + captureConfig.sessionID = g_sessionId; + captureConfig.streamType = AUDIO_STREAM_VOICE_CALL_VOLTE; + + g_streamIn[2]->Init(captureConfig); + g_streamIn[3]->Init(captureConfig); + + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[%s] line:%d, success", __FUNCTION__, __LINE__); + + /* 初始化通话上下行流实例 */ + AudioRendererConfig renderConfig = {}; + renderConfig.audioFormat = mSBC; + renderConfig.channelCount = 1; + renderConfig.linkDir = AUDIO_UP_LINK; + renderConfig.sampleRate = 16000; + renderConfig.sessionID = g_sessionId; + renderConfig.streamType = AUDIO_STREAM_VOICE_CALL_VOLTE; + + g_streamOut[2]->Init(renderConfig); + g_streamOut[3]->Init(renderConfig); + + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[%s] line:%d, success", __FUNCTION__, __LINE__); + + /* 启动通话上行流 */ + g_streamIn[2] ->Start(); + g_streamOut[2]->Play(); + /* 启动通话下行流 */ + g_streamIn[3] ->Start(); + g_streamOut[3]->Play(); + + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[%s] line:%d, success", __FUNCTION__, __LINE__); + + + + + } #ifdef __cplusplus diff --git a/code/sdk/application/wearable/fd230/nativeapp/nativeui/phoneservice/src/PhoneService.cpp b/code/sdk/application/wearable/fd230/nativeapp/nativeui/phoneservice/src/PhoneService.cpp index adaf6ce57..96d72b08d 100644 --- a/code/sdk/application/wearable/fd230/nativeapp/nativeui/phoneservice/src/PhoneService.cpp +++ b/code/sdk/application/wearable/fd230/nativeapp/nativeui/phoneservice/src/PhoneService.cpp @@ -5,6 +5,8 @@ */ #include "PhoneService.h" +#include "PhoneServiceC.h" + #include "PhoneAudio.h" #include "securec.h" #include @@ -22,17 +24,32 @@ #include "broadcast_service.h" #include "broadcast_feature.h" #include "service_id_define.h" -#include "graphic_mutex.h" #include "samgr_lite.h" #include "ui_service.h" - +#include "cat1_server_hal.h" +#include "BluetoothModel.h" +#include "notification_manager.h" +#include "CallerLogModel.h" +#include "custom_utils.h" +#include "Bluetooyhpabpserver.h" +#include "AlarmClockModel.h" +#include "ConfigModel.h" +#include "custom_runtime.h" +#include "vibrator_service.h" +#include "gfx_utils/mem_api.h" +#include "ConfigModelC.h" +#include "cat1_ctl.h" +#include "UiConfig.h" +#include "PhoneAGService.h" +#include "cmath" #ifdef __cplusplus extern "C" { #endif - -#define CALL_LOG_PATH "/user/data/calllog.bin" -#define CALL_TMP_LOG_PATH "/user/data/calltmplog.bin" -#define CALL_LOG_DIR "/user/data" +#include "bleService.h" +#include "custom_save_runtime.h" +#define CALL_LOG_PATH "/user/userdata/calllog.bin" +#define CALL_TMP_LOG_PATH "/user/userdata/calltmplog.bin" +#define CALL_LOG_DIR "/user/userdata" #ifndef UNUSED #define UNUSED(x) ((void)(x)) @@ -69,10 +86,13 @@ static int g_hdlUpSco = INVALID_PHONE_SERVICE_VALUE; static int g_hdlDnSpk = INVALID_PHONE_SERVICE_VALUE; static int g_hdlDnSco = INVALID_PHONE_SERVICE_VALUE; + +static uint8_t TransCallToMobilePhone_falg=0; + PhoneServiceCb g_callChanged; void HfpIncomingEventPublish(uint16 topic, const PhoneHfpCallInfo &callsInfo); -static void PhoneServiceScreenCtr(bool turnOnFlag) +void PhoneServiceScreenCtr(bool turnOnFlag) { if (turnOnFlag) { ScreenTurnOn(-1); @@ -83,7 +103,7 @@ static void PhoneServiceScreenCtr(bool turnOnFlag) static void InitMutex(void) { -} + } uint32 GetCallCodec(void) { @@ -137,26 +157,29 @@ static void AudioDeactInterrupt(AudioStreamType type) type, g_audioState); if ((type == AUDIO_STREAM_VOICE_CALL_BT_SCO && g_audioState >= AUDIO_ACT_INTERRUPT_BT_SCO) || - (type == AUDIO_STREAM_RING && g_audioState == AUDIO_ACT_INTERRUPT_WATCH_RING)) { + (type == AUDIO_STREAM_RING && g_audioState == AUDIO_ACT_INTERRUPT_WATCH_RING) + || (type ==AUDIO_STREAM_VOICE_CALL_VOLTE && g_audioState >= AUDIO_STREAM_VOICE_CALL_VOLTE) ) { (void)PhoneAudioManagerDeactInterrupt(); } } + + // 申请音频焦点 -static void AudioActInterrupt(AudioStreamType type) +void AudioActInterrupt(AudioStreamType type) { int ret = OHOS_SUCCESS; - WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[AudioActInterrupt] start type:0x%x, audioState:0x%x", + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[AudioActInterrupt] start type:0x%x, audioState:0x%x", type, g_audioState); - if (type != AUDIO_STREAM_VOICE_CALL_BT_SCO && type != AUDIO_STREAM_RING) { +if (type != AUDIO_STREAM_VOICE_CALL_BT_SCO && type != AUDIO_STREAM_RING && type != AUDIO_STREAM_VOICE_CALL_VOLTE) { WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[AudioActInterrupt] failed! type:0x%x, audioState:0x%x", type, g_audioState); return; } - g_audioMutex.Lock(); + g_audioMutex.Lock(); // 申请蓝牙通话焦点 if (type == AUDIO_STREAM_VOICE_CALL_BT_SCO && g_audioState < AUDIO_ACT_INTERRUPT_BT_SCO) { if (g_audioState == AUDIO_ACT_INTERRUPT_WATCH_RING) { @@ -170,10 +193,10 @@ static void AudioActInterrupt(AudioStreamType type) } else if (type == AUDIO_STREAM_RING && g_audioState < AUDIO_ACT_INTERRUPT_WATCH_RING) { ret = PhoneAudioManagerActInterrupt(type); if (ret == OHOS_SUCCESS) { - g_audioState = AUDIO_ACT_INTERRUPT_WATCH_RING; + g_audioState = AUDIO_ACT_INTERRUPT_WATCH_RING; } } - + if (ret != OHOS_SUCCESS) { WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[AudioActInterrupt] failed! type:0x%x, audioState:0x%x", type, g_audioState); @@ -187,9 +210,11 @@ static void AudioConnectScoDevInit(void) { int ret; - WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[AudioConnectScoDevInit] start scoFlag:0x%x, audioState:0x%x", + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[AudioConnectScoDevInit] start scoFlag:0x%x, audioState:0x%x", g_scoFlag, g_audioState); if (g_scoFlag != HFP_SCO_STATE_CONNECTED || g_audioState < AUDIO_ACT_INTERRUPT_BT_SCO) { + + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"AudioConnectScoDevInit"); return; } @@ -248,7 +273,7 @@ static void AudioUpStart(void) if (g_scoFlag != HFP_SCO_STATE_CONNECTED || g_audioState < AUDIO_STREAM_INIT) { return; - } +} g_audioMutex.Lock(); if (g_audioState < AUDIO_STREAM_START_UP) { @@ -356,6 +381,35 @@ static void AudioDnStart(void) return; } +#include "PlayersModelC.h" +#include "BluetoothModelC.h" + +void cat1_audio_AudioSetup(void) +{ + //AudioActInterrupt(AUDIO_STREAM_VOICE_CALL_VOLTE); + if(stopPhonePlayingMusic()) + { + BtA2dpSnkAudioDestroy(); + sleep(1);//等待释放音频 + } + // uapi_cat1_start_volte_voice(); + usleep(5000);//等待释放音频 + +} + +void cat1_audio_AudioRelease(void) +{ + // uapi_cat1_stop_volte_voice(); +} + +void cat1_audio_stop(void) +{ + // uapi_stop_call(); +} + + + + // 同步音量 static void SyncVolume(void) { @@ -363,6 +417,20 @@ static void SyncVolume(void) SetSpeakerVolume(volume); } +#ifdef __cplusplus +extern "C" { +#endif + +static void PostGraphicEvent(void (*fun)(void)) +{ + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[PostGraphicEvent] start"); + GraphicService::GetInstance()->PostGraphicEvent(*fun); +} + +#ifdef __cplusplus +} +#endif + // 蓝牙通话下行 static void AudioDn(void) { @@ -392,8 +460,14 @@ static void AudioUp(void) WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[AudioUp] audioState:%d", g_audioState); } + static void AudioSetup(void) { + //如果已经建立了cat1 媒体通路，不能再建立，SCO通路 + // if(volte_voice_state()) + // { + // return; + // } if (g_audioState < AUDIO_STREAM_START_DN) { AudioDn(); } @@ -403,6 +477,9 @@ static void AudioSetup(void) } } + + + static void AudioUpRelease(void) { int ret; @@ -492,7 +569,7 @@ void AudioRelease(void) /* 释放音频焦点 */ AudioDeactInterrupt(AUDIO_STREAM_VOICE_CALL_BT_SCO); AudioDeactInterrupt(AUDIO_STREAM_RING); // 适配某些机型不触发SCO - g_audioState = AUDIO_UNKNOW; + g_audioState = AUDIO_UNKNOW; WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[AudioRelease] audioState:%d,", g_audioState); g_audioMutex.Unlock(); @@ -500,9 +577,14 @@ void AudioRelease(void) static void CallListInit(void) { + int i; + g_currCallNum = 0; + (void)memset_s(g_callList, sizeof(g_callList), 0, sizeof(g_callList)); - for (int i = 0; i < MULTI_CALL_MAX_NUME; i++) { + for (i = 0; i < MULTI_CALL_MAX_NUME; i++) { + (void)memset_s(g_callList[i].name, NAME_SIZE, '\0', NAME_SIZE); + (void)memset_s(g_callList[i].tel, MAX_PHONE_NUM, '\0', MAX_PHONE_NUM); g_callList[i].lastStatus = HFP_HF_CALL_STATE_FINISHED; } } @@ -512,7 +594,7 @@ static void CopyBdAddr(const bd_addr_t &bdAddr) unsigned char addr[BD_ADDR_LEN] = {0}; if (strncmp((const char*)g_bdAddr.addr, (const char*)addr, BD_ADDR_LEN) == 0) { (void)memcpy_s(g_bdAddr.addr, BD_ADDR_LEN, bdAddr.addr, BD_ADDR_LEN); - } + } } static void CatBdAddr(const bd_addr_t &bdAddr) @@ -523,7 +605,7 @@ static void CatBdAddr(const bd_addr_t &bdAddr) } printf(""); #else - UNUSED(bdAddr); + UNUSED(bdAddr); #endif } @@ -561,16 +643,42 @@ static void BtDisconnectedPro(void) // 蓝牙状态连接 static void ConnStateChanged(const bd_addr_t &bdAddr, profile_connect_state_t state) { - WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[ConnStateChanged] state = 0x%X bdAddr: ", state); - CatBdAddr(bdAddr); + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ConnStateChanged] state = 0x%X bdAddr: ", state); + CatBdAddr(bdAddr); switch (state) { case PROFILE_STATE_CONNECTING: // 蓝牙正在连接 - WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[ConnStateChanged] BT connecting"); + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[ConnStateChanged] BT connecting"); + #ifdef BR_DISCONNECT + if(!cm_get_HFP_switch()) + { + uapi_hfp_disconnect(); + return; + } + #endif + // uapi_pbap_cmd_start_client(); break; case PROFILE_STATE_CONNECTED: // 蓝牙连接成功 WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[ConnStateChanged] BT connected"); + #ifdef BR_DISCONNECT + if(!cm_get_HFP_switch()) + { + uapi_hfp_disconnect(); + return; + } + + if(cm_get_A2DP_switch() && OHOS::uapi_a2dp_snk_get_device_connect_state()==0) + { + OHOS::uapi_a2dp_snk_connect(); + } + + #endif BtConnectedPro(bdAddr); + SendMsgToUIService(BT_CONNECTED_TO_UI, 0, nullptr, 0); + + // uapi_pbap_cmd_start_client(); + uapi_save_runtime_log(RUNTIME_LOG_BR_CONNECT_HFP); + //SendMsgToMsgCenterService(BT_CONNECTED_TO_MSGCENTER, 0, nullptr, 0); break; case PROFILE_STATE_DISCONNECTING: // 蓝牙连接断连 WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[ConnStateChanged] BT disconnecting"); @@ -578,6 +686,13 @@ static void ConnStateChanged(const bd_addr_t &bdAddr, profile_connect_state_t st case PROFILE_STATE_DISCONNECTED: // 蓝牙断开连接 WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[ConnStateChanged] BT disconnected"); BtDisconnectedPro(); + //if(0==OHOS::uapi_a2dp_snk_get_device_connect_state() && 0==uapi_hfp_connect_state()) + { + SendMsgToUIService(BT_DISCONNECTED_TO_UI, 0, nullptr, 0); + //SendMsgToMsgCenterService(BT_DISCONNECTED_TO_MSGCENTER, 0, nullptr, 0); + } + uapi_save_runtime_log(RUNTIME_LOG_BR_DISCONNECT_HFP); + break; default: break; @@ -601,14 +716,14 @@ static void ScoConnectPro(void) { WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[ScoConnectPro] CallNum:%d, ScoFlag:%d", g_currCallNum, g_scoFlag); // 通知sco建立连接(或通话转移：手机 -> 手表) - ScoStatusCb(HFP_SCO_STATE_CONNECTED); + ScoStatusCb(HFP_SCO_STATE_CONNECTED); if (g_currCallState == HFP_HF_CALL_STATE_ACTIVE && g_scoFlag == HFP_SCO_STATE_CONNECTED) { // The call is transferred from the phone to the watch. Need to show the call notification view. PhoneHfpCallInfo call = {0}; HfpIncomingEventPublish(TOPIC_EVENT_HFP_PHONE_TO_WATCH, call); } - - AudioSetup(); + +AudioSetup(); WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[ScoConnectPro] audioState:%d", g_audioState); } @@ -636,7 +751,7 @@ static void ScoStateChanged(const bd_addr_t &bdAddr, hfp_sco_connect_state_t sta g_scoFlag, g_currCallNum); switch (state) { - case HFP_SCO_STATE_CONNECTING: + case HFP_SCO_STATE_CONNECTING: PhoneServiceScreenCtr(1); if (g_scoFlag != HFP_SCO_STATE_CONNECTED) { g_scoFlag = HFP_SCO_STATE_CONNECTED; @@ -644,18 +759,26 @@ static void ScoStateChanged(const bd_addr_t &bdAddr, hfp_sco_connect_state_t sta ScoConnectPro(); WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[ScoStateChanged] SCO connecting!"); } - break; + break; case HFP_SCO_STATE_CONNECTED: // 同步音量 SyncVolume(); + + if(TransCallToMobilePhone_falg) + { + TransCallToMobilePhone(); + } + + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[ScoStateChanged] SCO connected!"); break; - + // SCO断连中 case HFP_SCO_STATE_DISCONNECTING: WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[ScoStateChanged] SCO disconnecting!"); break; - case HFP_SCO_STATE_DISCONNECTED: + //语音助手断联 + CustomEventPublish(TOPIC_EVENT_ASSISTANT_NOTE,NULL,0); WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[ScoStateChanged] SCO disconnected!"); ScoDisconnectPro(); PhoneServiceScreenCtr(0); @@ -718,7 +841,7 @@ static void AddToCallLog(const CallLogInfo &info) WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[AddToCallLog] fopen %s failed!", CALL_LOG_PATH); return; } - + ret = fwrite(&info, sizeof(CallLogInfo), 1, fp); if (ret != 1) { WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[AddToCallLog] fwrite failed! ret:%d", ret); @@ -828,10 +951,31 @@ END: info = nullptr; return ret; } +void AddToCallLog_CAT1(CallLogInfo *callInfo) +{ + if (callInfo == nullptr) { + return; + } + int fileSize = GetCallLogFileSize(); + int num = fileSize / sizeof(CallLogInfo); + if (num >= CALL_LOG_MAX_NUM) { + int ret = RemoveFirstCallLog(); + if (ret == OHOS_FAILURE) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[AddToCallLogPro] RemoveFirstCallLog error"); + return; + } + } + callInfo->calllogtype=CALL_CAT1; + AddToCallLog(*callInfo); +} // 添加通话记录 -static void AddToCallLogPro(const PhoneCallInfo *callInfo) +static void AddToCallLogPro(PhoneCallInfo *callInfo) { + if (callInfo == nullptr) { + return; + } + int fileSize = GetCallLogFileSize(); int num = fileSize / sizeof(CallLogInfo); if (num >= CALL_LOG_MAX_NUM) { @@ -842,7 +986,9 @@ static void AddToCallLogPro(const PhoneCallInfo *callInfo) } } - CallLogInfo info = { 0 }; + CallLogInfo info; + (void)memset_s(info.name, NAME_SIZE, '\0', NAME_SIZE); + (void)memset_s(info.tel, MAX_PHONE_NUM, '\0', MAX_PHONE_NUM); int ret = memcpy_s(info.name, NAME_SIZE, callInfo->name, callInfo->nameLen); if (ret != EOK) { info.nameLen = 0; @@ -872,10 +1018,12 @@ static void AddToCallLogPro(const PhoneCallInfo *callInfo) } else { info.status = CALL_INCOMING; } - + info.calllogtype=CALL_HFP; AddToCallLog(info); } + + // 获取通话记录 int GetCallLog(CallLogInfo **info, int *num) { @@ -895,28 +1043,54 @@ int GetCallLog(CallLogInfo **info, int *num) int number = fileSize / sizeof(CallLogInfo); WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[GetCallLog] fileSize:%d, number:%d", fileSize, number); - CallLogInfo *callInfo = new CallLogInfo[number]; - if (callInfo == nullptr) { - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[GetCallLog] new callInfo fail!"); - *info = nullptr; - *num = 0; - fclose(fp); - return OHOS_FAILURE; - } - (void)memset_s(callInfo, fileSize, 0, fileSize); +CallLogInfo *callInfo = new CallLogInfo[number]; + if (callInfo == nullptr) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[GetCallLog] new callInfo fail!"); + *info = nullptr; + *num = 0; + fclose(fp); + return OHOS_FAILURE; + } + (void)memset_s(callInfo, fileSize, 0, fileSize); - int ret = fread(callInfo, sizeof(CallLogInfo), number, fp); - if (ret != number) { + int ret = fread(callInfo, sizeof(CallLogInfo), number, fp); +if (ret != number) { WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[GetCallLog] fread fp fail ret:%d", ret); delete[] callInfo; *info = nullptr; *num = 0; fclose(fp); return OHOS_FAILURE; - } - + } + *info = callInfo; - *num = number; + *num = number; + fclose(fp); + return OHOS_SUCCESS; +} + + +int SaveCallLog(CallLogInfo **info,int num) +{ + FILE *fp = fopen(CALL_LOG_PATH, "wb+"); + if (fp == nullptr) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[AddToCallLog] fopen %s failed!", CALL_LOG_PATH); + return OHOS_FAILURE; + } + if (info == nullptr) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[GetCallLog] malloc callInfo fail!"); + return OHOS_FAILURE; + } + for(int i=0;ioperate = OPERATE_WAITING; } + + if(OHOS::CallerLogModel::GetInstance()->GetCallSource() == OHOS::CallerLogModel::CallSourceCat1 + && OHOS::NotificationManager::GetInstance()->GetWatchCallStatus()) + { + if(call.state==HFP_HF_CALL_STATE_INCOMING) + { + phoneCall->operate = OPERATE_WAITING; + } + } + phoneCall->lastStatus = call.state; phoneCall->creationTime = time(nullptr); @@ -1197,7 +1381,7 @@ static void CallChangeActivePro(const PhoneHfpCallInfo &call) // 通话状态变化--拒接/结束流程处理 static void CallChangeFinishPro(const PhoneHfpCallInfo &call) { - WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[CallChangeFinishPro] start scoFlag:%d, CallNum:%d", + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[CallChangeFinishPro] start scoFlag:%d, CallNum:%d", g_scoFlag, g_currCallNum); if (g_currCallNum == 0) { return; @@ -1227,7 +1411,7 @@ static void CallChangeFinishPro(const PhoneHfpCallInfo &call) // 通知手表通话结束 CallChangedCb(phoneCall); - (void)memset_s(phoneCall, sizeof(PhoneCallInfo), 0, sizeof(PhoneCallInfo)); +(void)memset_s(phoneCall, sizeof(PhoneCallInfo), 0, sizeof(PhoneCallInfo)); phoneCall->lastStatus = HFP_HF_CALL_STATE_FINISHED; WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[CallChangeFinishPro] end scoFlag:%d, CallNum:%d", g_scoFlag, g_currCallNum); @@ -1258,24 +1442,25 @@ static void CallChangeHeldPro(const PhoneHfpCallInfo &call) static void PlayWatchRing(void) { WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[PlayWatchRing] start"); -} + } static void CallAudioHandle(const PhoneHfpCallInfo &call) { int state = call.state; - + if (state == HFP_HF_CALL_STATE_INCOMING || state == HFP_HF_CALL_STATE_DIALING || state == HFP_HF_CALL_STATE_ALERTING) { // 电话呼入，支持播放手机铃声 if (call.in_band_ring) { - // 播放手机端铃声 - AudioDn(); - } else { + // 播放手机端铃声 + AudioDn(); + } else { if (g_scoFlag != HFP_SCO_STATE_CONNECTED) { // 播放手表铃声 - PlayWatchRing(); + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"xxxxxxxxxxx"); + PostGraphicEvent(PlayWatchRing); } } - } else if (state == HFP_HF_CALL_STATE_FINISHED) { + } else if (state == HFP_HF_CALL_STATE_FINISHED) { return; } else if (g_scoFlag == HFP_SCO_STATE_CONNECTED) { AudioSetup(); @@ -1312,6 +1497,22 @@ bool IsCompleteCallFlow(void) return g_completeCallFlag; } +static void stop_ring(void) +{ + OHOS::AlarmClockModel::GetInstance()->AlarmPlayerStop(); +} + + +static uint8_t find_phone_count=0; + +static void find_address_book(std::string number,uint8_t len) +{ + find_phone_count++; + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "find_address_book %d", find_phone_count); + // uapi_pbap_cmd_pull_vcard_listing((unsigned char *)number.c_str(),len); + +} + // 通话状态变化上报回调 static void CallStateChanged(const bd_addr_t &bdAddr, const PhoneHfpCallInfo &call) { @@ -1319,39 +1520,85 @@ static void CallStateChanged(const bd_addr_t &bdAddr, const PhoneHfpCallInfo &ca WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "call is null or BT disconnected connStatus: 0x%X", g_btConnState); return; } + + if(OHOS::CallerLogModel::GetInstance()->GetCallDial() == OHOS::CallerLogModel::HFP_PHONE_DIAL) + { + if(call.state==HFP_HF_CALL_STATE_DIALING||call.state==HFP_HF_CALL_STATE_ALERTING) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "HFP_PHONE_DIAL 手机拨号"); + TransCallToMobilePhone(); + uapi_save_runtime_log(RUNTIME_LOG_PHONE_HFP_TO_MOBILE_PHONE); + return; + } + } - CopyBdAddr(bdAddr); + if((OHOS::CallerLogModel::GetInstance()->GetCallSource() == OHOS::CallerLogModel::CallSourceCat1 + && OHOS::NotificationManager::GetInstance()->GetWatchCallStatus())||uapi_dev_runtime_get_train_status() ) + { + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "4G 电话中"); + if(call.state==HFP_HF_CALL_STATE_INCOMING||call.state==HFP_HF_CALL_STATE_WAITING) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "hint 新电话"); + HfpIncomingEventPublish(TOPIC_EVENT_HFP_HINT,call); + } + TransCallToMobilePhone(); + uapi_save_runtime_log(RUNTIME_LOG_PHONE_HFP_TO_MOBILE_PHONE); + return; + } + } + SetCompleteCallFlag(call); CatCallStateChangedInfo(bdAddr, call); CallAudioHandle(call); + + if(call.state==HFP_HF_CALL_STATE_INCOMING || call.state==HFP_HF_CALL_STATE_DIALING + || call.state==HFP_HF_CALL_STATE_ALERTING) + { + GraphicService::GetInstance()->PostGraphicEvent(std::bind(find_address_book,call.number,call.number_len)); + } + + if(HFP_HF_CALL_STATE_INCOMING!=call.state) + { + PostGraphicEvent(stop_ring); + // + } WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "CallStateChanged state:%d", call.state); + switch (call.state) { case HFP_HF_CALL_STATE_ACTIVE: // 正在通话 CallChangeActivePro(call); + uapi_save_runtime_log(RUNTIME_LOG_PHONE_HFP_ACTIVE); break; case HFP_HF_CALL_STATE_HELD: // 挂起 CallChangeHeldPro(call); + uapi_save_runtime_log(RUNTIME_LOG_PHONE_HFP_HELD); break; case HFP_HF_CALL_STATE_DIALING: // 呼出，正在拨号 PhoneServiceScreenCtr(1); CallChangeDialPro(call); + uapi_save_runtime_log(RUNTIME_LOG_PHONE_HFP_DIALING); break; case HFP_HF_CALL_STATE_ALERTING: // 呼出，对方响铃 PhoneServiceScreenCtr(1); CallChangeAlertPro(call); + uapi_save_runtime_log(RUNTIME_LOG_PHONE_HFP_ALERTING); break; case HFP_HF_CALL_STATE_INCOMING: // 呼入 PhoneServiceScreenCtr(1); CallChangeIncomePro(call); + uapi_save_runtime_log(RUNTIME_LOG_PHONE_HFP_INCOMING); break; case HFP_HF_CALL_STATE_WAITING: // 呼入等待 PhoneServiceScreenCtr(1); CallChangeIncomePro(call); + uapi_save_runtime_log(RUNTIME_LOG_PHONE_HFP_WAITING); break; case HFP_HF_CALL_STATE_FINISHED: // 拒接/结束电话 CallChangeFinishPro(call); - PhoneServiceScreenCtr(0); + uapi_save_runtime_log(RUNTIME_LOG_PHONE_HFP_FINISHED); + //PhoneServiceScreenCtr(0); break; default: break; @@ -1537,12 +1784,18 @@ void PhoneServiceInit(void) (void)memset_s(g_bdAddr.addr, BD_ADDR_LEN, 0, BD_ADDR_LEN); CallListInit(); RegisterHfpHfCallbacks(); +//AG 服务注册 +#ifdef SUPPORT_CAT1_HFP_AG_SERV + // hfp_ag_reg_callback(); +#endif + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[PhoneServiceInit] end"); } // 手表主动拨打电话 int DialCall(unsigned char *number, unsigned char len) { + OHOS::CallerLogModel::GetInstance()->SetCallDial(OHOS::CallerLogModel::HFP_WATCH_DIAL); int ret; unsigned char *tel = nullptr; WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[DialCall] start"); @@ -1716,45 +1969,213 @@ int GetCallInfoInCallList(PhoneCallInfo callList[], int listNum, int *retNum) // hfp音量范围 0-15, media 音量范围 0-100 unsigned char GetCallCurrVolume(void) { - int32_t volume = PhoneAudioGetVolume(); - int32_t minVolume = PhoneAudioGetMinVolume(); - int32_t maxVolume = PhoneAudioGetMaxVolume(); - unsigned char hfpVolume = (unsigned char)((volume * CALL_VOLUME_MAX) / (maxVolume - minVolume)); // 转换 + if(OHOS::CallerLogModel::GetInstance()->GetCallSource() == OHOS::CallerLogModel::CallSourceCat1) + { + // int32_t volume = PhoneCAT1AudioGetVolume(); + // int32_t minVolume = PhoneAudioGetCAT1MinVolume(); + // int32_t maxVolume = PhoneAudioGetCAT1MAXVolume(); + // // unsigned char hfpVolume = (unsigned char)((volume * CALL_VOLUME_MAX) / (maxVolume - minVolume)); // 转换 + + + // if (volume != 0 && hfpVolume == 0) { + // hfpVolume = 1; + // } + // WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[GetCallCurrVolume] volume:%d, minVolume:%d, maxVolume:%d, hfpVolume:%d", + // volume, minVolume, maxVolume, hfpVolume); + // return hfpVolume; + return PhoneCAT1AudioGetVolume(); + } + else + { + // int32_t volume = PhoneAudioGetVolume(); + // int32_t minVolume = PhoneAudioGetMinVolume(); + // int32_t maxVolume = PhoneAudioGetMaxVolume(); + // // unsigned char hfpVolume = (unsigned char)((volume * CALL_VOLUME_MAX) / (maxVolume - minVolume)); // 转换 + + // // if (volume != 0 && hfpVolume == 0) { + // // hfpVolume = 1; + // // } + // WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[GetCallCurrVolume] volume:%d, minVolume:%d, maxVolume:%d, hfpVolume:%d", + // volume, minVolume, maxVolume, hfpVolume); + // return hfpVolume; + return PhoneAudioGetVolume(); - if (volume != 0 && hfpVolume == 0) { - hfpVolume = 1; } - WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[GetCallCurrVolume] volume:%d, minVolume:%d, maxVolume:%d, hfpVolume:%d", - volume, minVolume, maxVolume, hfpVolume); - return hfpVolume; + } void SetSpeakerVolume(unsigned char hfpVolume) { - WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[SetSpeakerVolume] start, hfpVolume:%d", hfpVolume); - int32_t minVolume = PhoneAudioGetMinVolume(); - int32_t maxVolume = PhoneAudioGetMaxVolume(); - int32_t volume = hfpVolume * (maxVolume - minVolume) / CALL_VOLUME_MAX; // 转换 - WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[SetSpeakerVolume] minVolume:%d, maxVolume:%d, volume:%d", - minVolume, maxVolume, volume); + if(OHOS::CallerLogModel::GetInstance()->GetCallSource() == OHOS::CallerLogModel::CallSourceCat1) + { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[SetSpeakerVolume] start, CallSourceCat1:4G音量调节传入%d", hfpVolume); + // int32_t minVolume = PhoneAudioGetCAT1MinVolume(); + // int32_t maxVolume = PhoneAudioGetCAT1MAXVolume(); + // int32_t volume = hfpVolume * (maxVolume - minVolume)/ CALL_VOLUME_MAX;// 转换 + // WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[SetSpeakerVolume] minVolume:%d, maxVolume:%d, G音量调节映射后volume:%d", + // minVolume, maxVolume, volume); + + // int32_t ret = PhoneCATAudioSetVolume(volume); + // if (!ret) { + // WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[SetSpeakerVolume] PhoneAudioSetVolume ret:%d", ret); + // return; + // } + // WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[SetSpeakerVolume] success!"); + + //4G 音量调节传入0~100不需要映射 + int32_t volume = hfpVolume; + int32_t ret = PhoneCATAudioSetVolume(volume); + if (!ret) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[SetSpeakerVolume] PhoneAudioSetVolume ret:%d", ret); + return; + } - int32_t ret = PhoneAudioSetVolume(volume); - if (!ret) { - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[SetSpeakerVolume] PhoneAudioSetVolume ret:%d", ret); - return; + #ifdef SUPPORT_CAT1_HFP_AG_SERV + int32_t minVolume = PhoneAudioGetMinVolume(); + int32_t maxVolume = PhoneAudioGetMaxVolume(); + + unsigned char volumeValue = (unsigned char) round(((double) (hfpVolume * CALL_VOLUME_MAX) / (maxVolume - minVolume))); // 音量转换 + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[SetSpeakerVolume] minVolume:%d, maxVolume:%d, 蓝牙音量调节映射后volume:%d",minVolume,maxVolume, volumeValue); + + + + // cat1_set_headset_volume(volumeValue) + #endif + + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[SetSpeakerVolume] success!"); } + else + { + // WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[SetSpeakerVolume] start, hfpVolume:%d", hfpVolume); + // int32_t minVolume = PhoneAudioGetMinVolume(); + // int32_t maxVolume = PhoneAudioGetMaxVolume(); + // int32_t volume = hfpVolume * (maxVolume - minVolume) / CALL_VOLUME_MAX; // 转换 + // WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[SetSpeakerVolume] minVolume:%d, maxVolume:%d, volume:%d", + // minVolume, maxVolume, volume); - ret = hfp_hf_set_volume(&g_bdAddr, HFP_VOLUME_SPEAKER, hfpVolume); - if (ret != ERRCODE_BT_SUCCESS) { - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[SetSpeakerVolume] set_volume ret:%d, hfpVolume:%d", - ret, hfpVolume); - return; + // int32_t ret = PhoneAudioSetVolume(volume); + // if (!ret) { + // WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[SetSpeakerVolume] PhoneAudioSetVolume ret:%d", ret); + // return; + // } + + // ret = hfp_hf_set_volume(&g_bdAddr, HFP_VOLUME_SPEAKER, hfpVolume); + // if (ret != ERRCODE_BT_SUCCESS) { + // WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[SetSpeakerVolume] set_volume ret:%d, hfpVolume:%d", + // ret, hfpVolume); + // return; + // } + // WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[SetSpeakerVolume] success!"); + + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[SetSpeakerVolume] start, hfpVolume:蓝牙音量调节传入%d", hfpVolume); + int32_t minVolume = PhoneAudioGetMinVolume(); + int32_t maxVolume = PhoneAudioGetMaxVolume(); + unsigned char volumeValue = (unsigned char) round(((double) (hfpVolume * CALL_VOLUME_MAX) / (maxVolume - minVolume))); // 音量转换 + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[SetSpeakerVolume] minVolume:%d, maxVolume:%d, 蓝牙音量调节映射后volume:%d",minVolume,maxVolume, volumeValue); + + int32_t ret = PhoneAudioSetVolume(hfpVolume); + if (!ret) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[SetSpeakerVolume] PhoneAudioSetVolume ret:%d", ret); + return; + } + + ret = hfp_hf_set_volume(&g_bdAddr, HFP_VOLUME_SPEAKER, volumeValue); + if (ret != ERRCODE_BT_SUCCESS) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[SetSpeakerVolume] set_volume ret:%d, hfpVolume:%d", + ret, hfpVolume); + return; + } + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[SetSpeakerVolume] success!"); } - WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[SetSpeakerVolume] success!"); + return; } +void set_speaker_volume(unsigned char hfpVolume,int type) +{ + if(type != AUDIO_STREAM_VOICE_CALL_BT_SCO) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[SetSpeakerVolume] start, CallSourceCat1:%d", hfpVolume); + int32_t minVolume = PhoneAudioGetCAT1MinVolume(); + int32_t maxVolume = PhoneAudioGetCAT1MAXVolume(); + // int32_t volume = hfpVolume * (maxVolume - minVolume)/ CALL_VOLUME_MAX;// 转换 + int32_t volume = hfpVolume; + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[SetSpeakerVolume] minVolume:%d, maxVolume:%d, volume:%d", + minVolume, maxVolume, volume); + + int32_t ret = PhoneCATAudioSetVolume(volume); + if (!ret) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[SetSpeakerVolume] PhoneAudioSetVolume ret:%d", ret); + return; + } + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[SetSpeakerVolume] success!"); + } + else + { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[SetSpeakerVolume] start, hfpVolume:%d", hfpVolume); + int32_t minVolume = PhoneAudioGetMinVolume(); + int32_t maxVolume = PhoneAudioGetMaxVolume(); + // int32_t volume = hfpVolume * (maxVolume - minVolume) / CALL_VOLUME_MAX; // 转换 + int32_t volume = hfpVolume; + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[SetSpeakerVolume] minVolume:%d, maxVolume:%d, volume:%d", + minVolume, maxVolume, volume); + + int32_t ret = PhoneAudioSetVolume(volume); + if (!ret) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[SetSpeakerVolume] PhoneAudioSetVolume ret:%d", ret); + return; + } + + ret = hfp_hf_set_volume(&g_bdAddr, HFP_VOLUME_SPEAKER, hfpVolume); + if (ret != ERRCODE_BT_SUCCESS) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[SetSpeakerVolume] set_volume ret:%d, hfpVolume:%d", + ret, hfpVolume); + return; + } + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[SetSpeakerVolume] success!"); + } + + + return; +} +static uint8_t SetSpeaker=false; + +void uapi_SetSpeaker_Mute(bool isMute) +{ + //return; + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[SetSpeakerMute] start!"); + + if(isMute==true ) + // && (true == OHOS::ConfigModel::GetInstance()->GetDnotdisturb() || + // (uapi_sleep_mode_flag_get()) || true == OHOS::ConfigModel::GetInstance()->GetSilentMode())) + { + if(isMute!=SetSpeaker) + { + if(true== SetSpeakerMute(isMute)) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[SetSpeakerMute] true!"); + SetSpeaker=isMute; + } + } + + } + else if(isMute==false) + { + if(isMute!=SetSpeaker) + { + if(true== SetSpeakerMute(isMute)) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[SetSpeakerMute] false!"); + SetSpeaker=isMute; + } + } + } + + + +} + // 设置通话speaker静音 bool SetSpeakerMute(bool isMute) { @@ -1767,6 +2188,16 @@ bool SetMicMute(bool isMute) return PhoneAudioSetMicMute(isMute); } +static uint8_t Mutecat1_data; +int32_t SetMicMutecat1(bool isMute) +{ + + Mutecat1_data=isMute; + do_custom_cmd_service_check_msg(CUSTOM_CMD_MSG_CAT1_MIC_CTRL, &Mutecat1_data, sizeof(bool)); + return 0; + +} + // 获取SCO的连接状态 int GetScoConnectState(void) { @@ -1796,11 +2227,16 @@ int TransCallToWatch(void) } } + +void set_TransCallToMobilePhone_falg(uint8_t date) +{ + TransCallToMobilePhone_falg=date; +} // 通话转移到手机 int TransCallToMobilePhone(void) { int ret; - WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[TransCallToMobilePhone] start"); + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[TransCallToMobilePhone] start"); if (g_btConnState != PROFILE_STATE_CONNECTED) { WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[TransCallToMobilePhone] BT connStatus: 0x%X", g_btConnState); @@ -1809,16 +2245,178 @@ int TransCallToMobilePhone(void) ret = GetScoConnectState(); if (ret == HFP_SCO_STATE_DISCONNECTED || ret == HFP_SCO_STATE_DISCONNECTING) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[TransCallToMobilePhone] >>"); + TransCallToMobilePhone_falg=1; + return OHOS_SUCCESS; } else { ret = hfp_hf_disconnect_sco(&g_bdAddr); if (ret != 0) { WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[TransCallToMobilePhone] ret:%d", ret); } + TransCallToMobilePhone_falg=1; return ret; } } +#include "los_base.h" + +int uapi_hfp_disconnect_(void) +{ + if( get_BT_is_init()==0) + { + return 0; + } + + int ret; + bd_addr_t bdaddr={0}; + OHOS:: uapi_get_br_address(&bdaddr); + ret = hfp_hf_disconnect(&bdaddr); + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "addr: ****%02x %02x %02x %02x g_bdAddr.type: %x\n", + bdaddr.addr[3], bdaddr.addr[2], bdaddr.addr[1], bdaddr.addr[0], bdaddr.type); /* 3 2 1 0 idx */ + + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[hfp_disconnect] ret:%X", ret); + return ret; +} + +int uapi_hfp_connect_(void) +{ + if( get_BT_is_init()==0) + { + return 0; + } + + int ret; + bd_addr_t bdaddr={0}; + OHOS:: uapi_get_br_address(&bdaddr); + + if(false==bt_is_acl_connected(&bdaddr) && + !( bdaddr.addr[0] == 0 && bdaddr.addr[1] == 0 && bdaddr.addr[2] == 0 + && bdaddr.addr[3] == 0 && bdaddr.addr[4] == 0 && bdaddr.addr[5] == 0 ) + ) + { + ret=gap_reconnect_media_device(&bdaddr); + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[gap_connect_remote_device] ret:%X", ret); + } + else + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[bt_is_acl_connected is true"); + ret = hfp_hf_connect(&bdaddr); + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[uapi_hfp_connect] ret:%X", ret); + if(ret==0x8000600B) + { + gap_disconnect_remote_device(&bdaddr); + sleep(1); + //if(ret!=ERRCODE_SUCC) + { + ret=gap_reconnect_media_device(&bdaddr); + } + + + } + else + { + if(ret!=ERRCODE_SUCC) + { + ret=gap_reconnect_media_device(&bdaddr); + } + } + + + + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[uapi_hfp_connect] ret:%X", ret); + } + + if(ret!=ERRCODE_SUCC) + { + uint8_t br_cmd_code[5]={0}; + br_cmd_code[0]=BR_HFP_CONNECT_FAIL; + memcpy_s(&br_cmd_code[1],4,&ret,4); + + do_custom_cmd_service_check_msg(CUSTOM_CMD_MSG_BR_CONNECT,br_cmd_code,sizeof(uint8_t)*5); + } + + + + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "addr: ****%02x %02x %02x %02x g_bdAddr.type: %x\n", + bdaddr.addr[3], bdaddr.addr[2], bdaddr.addr[1], bdaddr.addr[0], bdaddr.type); /* 3 2 1 0 idx */ + + return ret; +} + +int uapi_hfp_connect_state(void) +{ + if( get_BT_is_init()==0) + { + return 0; + } + + int ret; + bd_addr_t bdaddr={0}; + OHOS:: uapi_get_br_address(&bdaddr); + + ret = hfp_hf_get_device_connect_state(&bdaddr); + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[hfp_connect_hfp] ret:%d", ret); + if(PROFILE_STATE_CONNECTED==ret || PROFILE_STATE_CONNECTING ==ret) + return 1; + else + return 0; +} + + +void uapi_hfp_send_DTMF_CODE(char code) +{ + bd_addr_t bdaddr={0}; + OHOS:: uapi_get_br_address(&bdaddr); + + int ret= hfp_hf_send_dtmf_tone(&bdaddr,code); + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[hfp_hf_send_dtmf_tone] ret:%d", ret); +} + + +static uint8_t br_cmd=0; +int uapi_hfp_connect() +{ + br_cmd=BR_HFP_CONNECT; + do_custom_cmd_service_check_msg(CUSTOM_CMD_MSG_BR_CONNECT,&br_cmd,sizeof(br_cmd)); + return 0; +} + + +int uapi_hfp_disconnect() +{ + br_cmd=BR_HFP_DISCONNECT; + do_custom_cmd_service_check_msg(CUSTOM_CMD_MSG_BR_CONNECT,&br_cmd,sizeof(br_cmd)); + return 0; +} + + +int uapi_hfp_fail_cbk(int32_t errcode) +{ + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "%X", errcode); + + return 0; +} + + +int uapi_open_voice_recognition(void ) +{ + bd_addr_t bdaddr={0}; + OHOS:: uapi_get_br_address(&bdaddr); + errcode_t ret = (errcode_t)hfp_hf_open_voice_recognition(&bdaddr); + return ret; +} + + +int uapi_close_voice_recognition(void ) +{ + bd_addr_t bdaddr={0}; + OHOS:: uapi_get_br_address(&bdaddr); + errcode_t ret = (errcode_t)hfp_hf_close_voice_recognition(&bdaddr); + return ret; +} + + #ifdef __cplusplus } #endif diff --git a/code/sdk/application/wearable/fd230/nativeapp/nativeui/player/src/PlayersModel.cpp b/code/sdk/application/wearable/fd230/nativeapp/nativeui/player/src/PlayersModel.cpp index d9e1f80c4..f4371a116 100644 --- a/code/sdk/application/wearable/fd230/nativeapp/nativeui/player/src/PlayersModel.cpp +++ b/code/sdk/application/wearable/fd230/nativeapp/nativeui/player/src/PlayersModel.cpp @@ -1320,12 +1320,12 @@ void ble_mp3_list_update_(void) extern bleInstruct_t_ bleInstruct_t; -// void ble_mp3_init(void) -// { -// bleInstruct_t.IS_free_save_Mp3=IS_free_save_Mp3_; -// bleInstruct_t.ble_mp3_list_update=ble_mp3_list_update_; +void ble_mp3_init(void) +{ + bleInstruct_t.IS_free_save_Mp3=IS_free_save_Mp3_; + bleInstruct_t.ble_mp3_list_update=ble_mp3_list_update_; -// } +} #endif diff --git a/code/sdk/zhihui/services/ble_service/blemoder/ble_congfig_adapt.cpp b/code/sdk/zhihui/services/ble_service/blemoder/ble_congfig_adapt.cpp index 7c1346941..5551e854c 100644 --- a/code/sdk/zhihui/services/ble_service/blemoder/ble_congfig_adapt.cpp +++ b/code/sdk/zhihui/services/ble_service/blemoder/ble_congfig_adapt.cpp @@ -540,26 +540,26 @@ void null_doing(void) -bool IS_free_save_Mp3_(uint32_t size) -{ - return true;//canSyncMusic(size); -} +// bool IS_free_save_Mp3_(uint32_t size) +// { +// return true;//canSyncMusic(size); +// } -void ble_mp3_list_update_(void) -{ - // SendMsgToUIService(UI_UPDATE_MUSIC_PLAYER_LIST,0,nullptr,0); -} +// void ble_mp3_list_update_(void) +// { +// // SendMsgToUIService(UI_UPDATE_MUSIC_PLAYER_LIST,0,nullptr,0); +// } extern bleInstruct_t_ bleInstruct_t; -void ble_mp3_init(void) -{ - bleInstruct_t.IS_free_save_Mp3=IS_free_save_Mp3_; - bleInstruct_t.ble_mp3_list_update=ble_mp3_list_update_; +// void ble_mp3_init(void) +// { +// bleInstruct_t.IS_free_save_Mp3=IS_free_save_Mp3_; +// bleInstruct_t.ble_mp3_list_update=ble_mp3_list_update_; -} +// } diff --git a/code/sdk/zhihui/services/ble_service/blemoder/ble_instruct_init.cpp b/code/sdk/zhihui/services/ble_service/blemoder/ble_instruct_init.cpp index 5ee5aece9..cf555db63 100644 --- a/code/sdk/zhihui/services/ble_service/blemoder/ble_instruct_init.cpp +++ b/code/sdk/zhihui/services/ble_service/blemoder/ble_instruct_init.cpp @@ -9,7 +9,7 @@ #include "AlarmClockModel.h" // #include "SetDialModel.h" #include "SleepModel.h" -// #include "PlayersModel.h" +#include "PlayersModel.h" #include "app_store.h" void ble_instruct_init(void) diff --git a/code/sdk/zhihui/services/ble_service/bleservice/bleEvent.c b/code/sdk/zhihui/services/ble_service/bleservice/bleEvent.c index 39f66b7ae..c5548d649 100644 --- a/code/sdk/zhihui/services/ble_service/bleservice/bleEvent.c +++ b/code/sdk/zhihui/services/ble_service/bleservice/bleEvent.c @@ -2963,7 +2963,7 @@ uint8_t parse_jsonCheck_weather(uint8_t *buf,uint8_t *check)//json 格式解析 } else if(cm_get_HFP_switch()) { - // uapi_hfp_connect(); + uapi_hfp_connect(); } } @@ -8344,15 +8344,15 @@ void type2AE6Data(ble_read_data *buffer_handle,uint8_t *cmd_buf ,uint8_t *data,u break; case APP_DELETE_CMD : - delete_app( cmd, *data,datalen,crcvalue); + delete_app( cmd, data,datalen,crcvalue); break; case GET_LIST_CMD : - get_app_list( cmd, *data,datalen,crcvalue); + get_app_list( cmd, data,datalen,crcvalue); break; case GET_APP_MSG_CMD: - get_watch_msg( cmd, *data,datalen,crcvalue); + get_watch_msg( cmd, data,datalen,crcvalue); break; default: @@ -8722,7 +8722,7 @@ void bleLongRecvData(ble_read_data *buffer_handle,uint8_t *data, uint16_t data_s { type2AE1Data(buf_cmd,data,data_size,totalData,crcvalue); } - else if (buffer_handle->handle==data2ae0Cmd) + else if (buffer_handle->handle==data2ae0Cmd) { type2AE0Data(buffer_handle); } diff --git a/code/sdk/zhihui/services/ble_service/bleservice/bleService.c b/code/sdk/zhihui/services/ble_service/bleservice/bleService.c index 3d9e22e25..593137afb 100644 --- a/code/sdk/zhihui/services/ble_service/bleservice/bleService.c +++ b/code/sdk/zhihui/services/ble_service/bleservice/bleService.c @@ -783,7 +783,7 @@ void svr_pair_result_cbt_cb(uint16_t conn_id, const bd_addr_t *addr, errcode_t s } else if(cm_get_HFP_switch()) { - // uapi_hfp_connect(); + uapi_hfp_connect(); } diff --git a/code/sdk/zhihui/utils/custom_cmd_service.c b/code/sdk/zhihui/utils/custom_cmd_service.c index 274bf13dd..65faf31bb 100644 --- a/code/sdk/zhihui/utils/custom_cmd_service.c +++ b/code/sdk/zhihui/utils/custom_cmd_service.c @@ -47,14 +47,14 @@ // void Check_ble_adv_status(void){} // void check_dial_space(void){} -int uapi_hfp_disconnect_(void){return 0;} -int uapi_hfp_connect_(void){return 0;} -int uapi_hfp_fail_cbk(int32_t errcode){return 0;} -int uapi_open_voice_recognition(void ){return 0;} -int uapi_close_voice_recognition(void ){return 0;} -void cat1_audio_AudioSetup(void){} -void cat1_audio_AudioRelease(void){} -int32_t PhoneAudioSetMicMuteCat1(bool isMute){return 0;} +// int uapi_hfp_disconnect_(void){return 0;} +// int uapi_hfp_connect_(void){return 0;} +// int uapi_hfp_fail_cbk(int32_t errcode){return 0;} +// int uapi_open_voice_recognition(void ){return 0;} +// int uapi_close_voice_recognition(void ){return 0;} +// void cat1_audio_AudioSetup(void){} +// void cat1_audio_AudioRelease(void){} +// int32_t PhoneAudioSetMicMuteCat1(bool isMute){return 0;} void cat1_connect_sco_(void){} void cat1_disconn_sco_(void){} void cat1_start_SCO_audio_(void){} -- 2.17.1