\r
if(cm_get_HFP_switch() && uapi_hfp_connect_state()==0)\r
{\r
- // uapi_hfp_connect();\r
+ uapi_hfp_connect();\r
}\r
#endif\r
\r
{
ConfigModel::GetInstance()->SetHFPState(true);
#ifdef FD230_650
- // uapi_hfp_connect();
+ uapi_hfp_connect();
#endif
classicBlueToothView->init_connect_timer(BluetoothServiceOptionsView::CONNECT_HFP);
}
--- /dev/null
+/*
+ * 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 <stdint.h>
+
+#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 */
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
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);
// 电话服务失败回调函数
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
--- /dev/null
+/*
+ * 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
--- /dev/null
+// /*
+// * Copyright (c) @CompanyNameMagicTag 2021. All rights reserved.
+// * Description: This module include test function of BT HFP Service module.
+// */
+
+// #include "PhoneAGService.h"
+// #include <soc_osal.h>
+// #include <td_base.h>
+// #include <stdlib.h>
+// #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);
+// }
+
+// /* <addr> */
+// 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;
+// }
+
+// /* <addr> */
+// 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;
+// }
+
+// /* <addr> */
+// 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]);
+// }
+
+// /* <addr> */
+// 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);
+// }
+
+// /* <addr> */
+// 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);
+// }
+
+// /* <addr> */
+// 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);
+// }
+
+// /* <addr> */
+// 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);
+// }
+
+// /* <addr> <type> */
+// 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);
+// }
+
+// /* <addr> <volume_type> <volume> */
+// 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);
+// }
+
+// /* <addr> <event> <param> */
+// 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);
+// }
+
+// /* <addr> <type> <service> <number> <alpha_str> */
+// 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);
+// }
+
+// /* <addr> <idx> <dir> <status> <mode> <mpty> <type> <number> <is_last> */
+// 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);
+// }
+
+// /* <addr> <type> <service> <number> <alpha_str> <is_last> */
+// 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);
+// }
+
+// /* <addr> <value> */
+// 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);
+// }
+
+// /* <addr> <error_code> */
+// 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);
+// }
+
+// /* <addr> <mode> <format> <operator_name> */
+// 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);
+// }
+
+// /* <addr> <service> <call> <callsetup> <callheld> <signal> <roam> <battchg> */
+// 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);
+// }
+
+// /* <addr> */
+
+
+// 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 <cli_validity>
+// // @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
#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" {
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 {
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);
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) {
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<PhoneAudioInterruptListener>();
+ 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<AudioStreamIn>();
+ g_streamOut[2] = std::make_shared<AudioStreamOut>();
+
+ g_streamOut[3] = std::make_shared<AudioStreamOut>();
+ g_streamIn [3]= std::make_shared<AudioStreamIn>();
+
+ /* 初始化通话上行流实例 */
+ 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
*/
#include "PhoneService.h"
+#include "PhoneServiceC.h"
+
#include "PhoneAudio.h"
#include "securec.h"
#include <cstdio>
#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))
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);
static void InitMutex(void)
{
-}
+ }
uint32 GetCallCodec(void)
{
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) {
} 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);
{
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;
}
if (g_scoFlag != HFP_SCO_STATE_CONNECTED || g_audioState < AUDIO_STREAM_INIT) {
return;
- }
+}
g_audioMutex.Lock();
if (g_audioState < AUDIO_STREAM_START_UP) {
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)
{
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)
{
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();
}
}
}
+
+
+
static void AudioUpRelease(void)
{
int ret;
/* 释放音频焦点 */
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();
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;
}
}
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)
}
printf("");
#else
- UNUSED(bdAddr);
+ UNUSED(bdAddr);
#endif
}
// 蓝牙状态连接
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");
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;
{
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);
}
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;
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);
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);
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) {
}
}
- 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;
} else {
info.status = CALL_INCOMING;
}
-
+ info.calllogtype=CALL_HFP;
AddToCallLog(info);
}
+
+
// 获取通话记录
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;i<num;i++)
+ {
+ int ret = fwrite(info[i], sizeof(CallLogInfo), 1, fp);
+ if (ret != 1) {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[GetCallLog] fread fp fail ret:%d", ret);
+
+ fclose(fp);
+ return OHOS_FAILURE;
+ }
+ }
fclose(fp);
return OHOS_SUCCESS;
}
// 通话状态变化--呼出，正在拨号处理
static void CallChangeDialPro(const PhoneHfpCallInfo &call)
{
- g_currCallNum++;
+ g_currCallNum++;
int32_t tmp = g_currCallNum - 1;
PhoneCallInfo *phoneCall = &g_callList[tmp];
} else {
phoneCall->operate = 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);
// 通话状态变化--拒接/结束流程处理
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;
// 通知手表通话结束
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);
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();
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)
{
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;
(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");
// 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)
{
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)
{
}
}
+
+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);
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
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
-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_;
-}
+// }
#include "AlarmClockModel.h"
// #include "SetDialModel.h"
#include "SleepModel.h"
-// #include "PlayersModel.h"
+#include "PlayersModel.h"
#include "app_store.h"
void ble_instruct_init(void)
}\r
else if(cm_get_HFP_switch())\r
{\r
- // uapi_hfp_connect();\r
+ uapi_hfp_connect();\r
}\r
\r
}\r
break;\r
\r
case APP_DELETE_CMD :\r
- delete_app( cmd, *data,datalen,crcvalue);\r
+ delete_app( cmd, data,datalen,crcvalue);\r
break; \r
case GET_LIST_CMD :\r
\r
- get_app_list( cmd, *data,datalen,crcvalue);\r
+ get_app_list( cmd, data,datalen,crcvalue);\r
\r
break; \r
case GET_APP_MSG_CMD:\r
- get_watch_msg( cmd, *data,datalen,crcvalue);\r
+ get_watch_msg( cmd, data,datalen,crcvalue);\r
\r
break; \r
default:\r
{\r
type2AE1Data(buf_cmd,data,data_size,totalData,crcvalue);\r
}\r
- else if (buffer_handle->handle==data2ae0Cmd)\r
+ else if (buffer_handle->handle==data2ae0Cmd)\r
{\r
type2AE0Data(buffer_handle);\r
}\r
}\r
else if(cm_get_HFP_switch())\r
{\r
- // uapi_hfp_connect();\r
+ uapi_hfp_connect();\r
}\r
\r
\r
// 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){}
projects / mirrors / FD230.git / commitdiff