Uahpet/AC707N
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
project
AC707N/SDK/apps/watch/mode/bt/phone_call.c
T
huxi bc195654bf 初版
2025-12-03 11:12:34 +08:00

1038 lines
31 KiB
C
Raw Permalink Blame History

#ifdef SUPPORT_MS_EXTENSIONS
#pragma bss_seg(".phone_call.data.bss")
#pragma data_seg(".phone_call.data")
#pragma const_seg(".phone_call.text.const")
#pragma code_seg(".phone_call.text")
#endif
#include "system/includes.h"
#include "media/includes.h"
#include "btstack/avctp_user.h"
#include "btstack/btstack_task.h"
#include "btstack/a2dp_media_codec.h"
#include "btstack/bluetooth.h"
#include "btctrler/btctrler_task.h"
#include "btctrler/btcontroller_modules.h"
#include "classic/hci_lmp.h"
#include "bt_common.h"
#include "bt_ble.h"
#include "pbg_user.h"
#include "user_cfg.h"
#include "audio_cvp.h"
#include "app_tone.h"
#include "a2dp_player.h"
#include "esco_player.h"
#include "esco_recoder.h"
#include "bt.h"
#include "app_config.h"
#include "app_testbox.h"
#include "app_online_cfg.h"
#include "app_main.h"
#include "vol_sync.h"
#include "audio_config.h"
#include "bt_slience_detect.h"
#include "mic_effect.h"
#if TCFG_SMART_VOICE_ENABLE
#include "asr/jl_kws.h"
#include "smart_voice/smart_voice.h"
#endif
#include "ui_api.h"
#include "data_storage.h"
#include "app_common.h"
#if(TCFG_USER_TWS_ENABLE == 0)
#define LOG_TAG "[PHONECALL]"
#define LOG_ERROR_ENABLE
#define LOG_DEBUG_ENABLE
#define LOG_INFO_ENABLE
#define LOG_CLI_ENABLE
#include "debug.h"
#if TCFG_APP_BT_EN
/*配置通话时前面丢掉的数据包包数*/
#define ESCO_DUMP_PACKET_ADJUST 1 /*配置使能*/
#define ESCO_DUMP_PACKET_DEFAULT 0
#define ESCO_DUMP_PACKET_CALL 60 /*0~0xFF*/
#define SYNC_TONE_PHONE_RING_TIME 300
enum {
CMD_OPEN_ESCO_PLAYER = 1,
CMD_CLOSE_ESCO_PLAYER,
CMD_PHONE_INCOME,
CMD_PHONE_OUT,
CMD_PHONE_HANGUP,
CMD_PHONE_ACTIVE,
CMD_PHONE_LASET_CALL_TYPE,
CMD_PHONE_SIRI,
};
static void phone_income_num_check(void *priv);
static void phone_call_send_cmd(u8 cmd, u8 *btaddr, u8 bt_value, u8 tx_do_action);
#if (defined(CONFIG_UI_STYLE_JL_PUBLIC_MODLS_ENABLE))
extern void ui_phone_call_end_status_check(void);
#endif
static u8 g_play_addr[6];
static u8 esco_dump_packet = ESCO_DUMP_PACKET_CALL;
static unsigned long phone_call_start = 0;
static u8 phone_call_status = 0; //用于记录通话开始时间
unsigned long bt_phone_call_start_time_get()
{
printf("%s %d", __func__, (u32)phone_call_start);
return phone_call_start;
}
void tone_ring_player_stop()
{
tone_player_stop();
ring_player_stop();
}
#if TCFG_BT_CALL_PHONE_BY_WATCH
extern void lmp_esco_rejust_establish(u8 value);
#define WATCH_SCO_DLY_MS (300) // 延时断开sco链路
static u16 bt_esco_by_watch_time;
static u16 disable_sco_timer;
static bool bt_esco_by_watch;
static u8 disable_sco_mod = 0; //通话拦截模式选择 0：连接后断开 1：拒绝esco连接
void set_bt_esco_by_watch(bool flag)
{
bt_esco_by_watch = flag;
}
bool get_bt_esco_by_watch()
{
return bt_esco_by_watch;
}
static void display_call_dly()
{
printf("%s dec_begin:%d call_status():%d", __func__, g_bt_hdl.phone_call_dec_begin, bt_get_call_status());
if (g_bt_hdl.phone_call_dec_begin) {
if (bt_get_call_status() == BT_CALL_ACTIVE) {
UI_WINDOW_PREEMPTION_POSH(ID_WINDOW_PHONE_CALL_STATUS, NULL, NULL, UI_WINDOW_PREEMPTION_TYPE_PHONE);
}
} else {
if (bt_get_call_status() == BT_CALL_ACTIVE) {
#if TCFG_UI_ENABLE && CONFIG_JL_UI_ENABLE
if (get_need_password() == 1) {
/* UI_HIDE_CURR_WINDOW(); */
UI_WINDOW_PREEMPTION_POP(ID_WINDOW_PHONE_CALL_STATUS);
UI_SHOW_WINDOW(ID_WINDOW_POWERON_PASSWORD);
} else {
UI_WINDOW_PREEMPTION_POP(ID_WINDOW_PHONE_CALL_STATUS);
}
/* UI_WINDOW_PREEMPTION_POP(ID_WINDOW_PHONE_CALL_STATUS); */
#endif
}
}
}
/* ***************************************************************************/
/**
* @brief ：手机接听电话后定时器函数
@param
@return
@note 用于判断手机接听后一秒内禁止esco连接的计时函数
bt_esco_by_watch_time = sys_timeout_add (NULL,bt_esco_conn_time,1000);
*/
/* ***************************************************************************/
static void bt_esco_conn_time()
{
if (disable_sco_mod) {
lmp_esco_rejust_establish(0);
}
if (bt_esco_by_watch_time) {
sys_timeout_del(bt_esco_by_watch_time);
bt_esco_by_watch_time = 0;
}
}
static void watch_sco_dly_time_del(void)
{
if (disable_sco_timer) {
sys_timeout_del(disable_sco_timer);
disable_sco_timer = 0;
}
}
static void send_sco_disconn(void *priv)
{
disable_sco_timer = 0;
bt_cmd_prepare(USER_CTRL_DISCONN_SCO, 0, NULL);
}
static void watch_sco_dly_disconnection()
{
watch_sco_dly_time_del();
disable_sco_timer = sys_timeout_add(NULL, send_sco_disconn, WATCH_SCO_DLY_MS);
}
/* ***************************************************************************/
/**
* @brief ：手机接听电话后定时时间内禁止esco连接
@param
@return
@note 用于判断手机接听后一秒内禁止esco连接的函数
放于esco发生连接状态中调用
*/
/* ***************************************************************************/
static bool bt_esco_ban_conn()
{
if (bt_esco_by_watch_time) {
watch_sco_dly_disconnection();
return true;
}
return false;
}
#endif
static u8 phone_ring_play_start(void)
{
log_info("%s,%d\n", __FUNCTION__, g_bt_hdl.inband_ringtone);
/* check if support inband ringtone */
if (BT_CALL_INCOMING != bt_get_call_status_for_addr(g_bt_hdl.phone_ring_addr)) {
return 0;
}
if (!g_bt_hdl.inband_ringtone) {
play_ring_file_alone(get_tone_files()->phone_in);
return 1;
}
return 0;
}
void phone_second_call_ring_play_start(void *priv)
{
//音频设计只有在ESCO工作的时候，播嘟嘟声才能叠加
//两种情况，一是先有嘟嘟声，然后来了ESCO铃声，要先关嘟嘟再开。
//二是两个都是ESCO铃声，第二个打断了第一个之后，第一个的铃声变成嘟嘟叠加。指示有两个来电
log_info("%s\n", __FUNCTION__);
u8 *other_addr = NULL;
if (priv) {
other_addr = btstack_get_other_dev_addr(priv) ;
put_buf(priv, 6);
printf("bt_get_call_status_for_addr=%d,%d\n", bt_get_call_status_for_addr(priv), bt_get_call_status_for_addr(other_addr));
}
if (bt_stack_get_incoming_call_num() > 1 || (priv && bt_get_call_status_for_addr(priv) == BT_CALL_INCOMING && bt_get_call_status_for_addr(other_addr) != BT_CALL_OUTGOING)) {
play_ring_file_alone(get_tone_files()->phone_in);
}
}
int bt_phone_income(u8 after_conn, u8 *bt_addr)
{
#if TCFG_BT_INBAND_RING
#else
lmp_private_esco_suspend_resume(3);
#endif
tone_ring_player_stop();
memcpy(g_bt_hdl.phone_ring_addr, bt_addr, 6);
put_buf(g_bt_hdl.phone_ring_addr, 6);
void *device = btstack_get_conn_device(bt_addr);
if (!device || BT_CALL_HANGUP == btstack_bt_get_call_status(device)) {
puts("bt_phone_income err 1\n");
return 1;
}
#if TCFG_BT_INBAND_RING
g_bt_hdl.inband_ringtone = btstack_get_inband_ringtone_flag_for_addr(bt_addr);
#else
g_bt_hdl.inband_ringtone = 0 ;
#endif
printf("inband_ringtone=0x%x %d\n", g_bt_hdl.inband_ringtone, after_conn);
g_bt_hdl.phone_ring_flag = 1;
g_bt_hdl.phone_income_flag = 1;
if (bt_stack_get_incoming_call_num() > 1) {
//第一次来电被置上一次。第二次再来就有值了
sys_timeout_add(g_bt_hdl.phone_ring_addr, phone_second_call_ring_play_start, 2000);
} else {
if (g_bt_hdl.inband_ringtone) {
if (after_conn == 2) { //强制播本地铃声
sys_timeout_add(g_bt_hdl.phone_ring_addr, phone_second_call_ring_play_start, 2000);
}
} else {
#if TCFG_BT_PHONE_NUMBER_ENABLE
if (after_conn) {
phone_ring_play_start();
} else {
phone_income_num_check(NULL);
}
#else
phone_ring_play_start();
#endif
}
}
return 0;
}
int bt_phone_hangup(u8 *bt_addr)
{
esco_dump_packet = ESCO_DUMP_PACKET_CALL;
log_info("phone_handup\n");
if (g_bt_hdl.phone_ring_flag) {
g_bt_hdl.phone_ring_flag = 0;
tone_ring_player_stop();
if (g_bt_hdl.phone_timer_id) {
sys_timeout_del(g_bt_hdl.phone_timer_id);
g_bt_hdl.phone_timer_id = 0;
}
}
g_bt_hdl.phone_income_flag = 0;
g_bt_hdl.phone_num_flag = 0;
lmp_private_esco_suspend_resume(4);
/*
* 挂断的时候会清除了一些标识并且会stop了提示音
* 判断如果另一个手机还在来电并且不支持inband ring，那就恢复一个嘟嘟声提示音
*/
u8 temp_btaddr[6];
u8 *addr = btstack_get_other_dev_addr(bt_addr);
if (addr && bt_get_call_status_for_addr(bt_addr) != BT_CALL_OUTGOING) {
//有另一个连接存在
u8 call_status = bt_get_call_status_for_addr(addr);
u8 inband_ring_flag = btstack_get_inband_ringtone_flag_for_addr(addr);
printf("other connect call sta:%d-%d-%d\n", call_status,
inband_ring_flag, bt_check_esco_state_via_addr(addr));
if (call_status == BT_CALL_INCOMING) {
memcpy(g_bt_hdl.phone_ring_addr, addr, 6);
if ((inband_ring_flag == 0) || (inband_ring_flag && bt_check_esco_state_via_addr(g_bt_hdl.phone_ring_addr) == BT_ESCO_STATUS_CLOSE)) {
phone_call_send_cmd(CMD_PHONE_INCOME, g_bt_hdl.phone_ring_addr, 2, 1);
}
}
}
return 0;
}
static int bt_phone_out(u8 *bt_addr)
{
esco_dump_packet = ESCO_DUMP_PACKET_CALL;
g_bt_hdl.phone_income_flag = 0;
return 0;
}
static int esco_audio_open(u8 *bt_addr)
{
esco_player_open(bt_addr);
#if TCFG_TWS_POWER_BALANCE_ENABLE && TCFG_USER_TWS_ENABLE
/* #if 0 //功能未完善，暂时关闭 */
if (tws_api_get_role() == TWS_ROLE_MASTER) {
log_info("tws_master open esco recoder\n");
esco_recoder_open(COMMON_SCO, bt_addr);
} else {
log_info("tws_slave don't open esco recoder\n");
}
#else
esco_recoder_open(COMMON_SCO, bt_addr);
#endif/*TCFG_TWS_POWER_BALANCE_ENABLE && TCFG_USER_TWS_ENABLE*/
return 0;
}
static int bt_phone_active(u8 *bt_addr)
{
if (g_bt_hdl.phone_call_dec_begin) {
log_info("call_active,dump_packet clear\n");
esco_dump_packet = ESCO_DUMP_PACKET_DEFAULT;
}
if (g_bt_hdl.phone_ring_flag) {
g_bt_hdl.phone_ring_flag = 0;
tone_ring_player_stop();
if (g_bt_hdl.phone_timer_id) {
sys_timeout_del(g_bt_hdl.phone_timer_id);
g_bt_hdl.phone_timer_id = 0;
}
}
lmp_private_esco_suspend_resume(4);
g_bt_hdl.phone_income_flag = 0;
g_bt_hdl.phone_num_flag = 0;
/* g_bt_hdl.phone_con_sync_ring = 0; */
g_bt_hdl.phone_vol = 15;
r_printf("phone_active:%d\n", app_var.call_volume);
app_audio_set_volume(APP_AUDIO_STATE_CALL, app_var.call_volume, 1);
return 0;
}
#define ESCO_SIRI_WAKEUP() (app_var.siri_stu == 1 || app_var.siri_stu == 2)
static void esco_smart_voice_detect_handler(void)
{
#if TCFG_SMART_VOICE_ENABLE && !TCFG_AUDIO_ASR_DEVELOP
#if TCFG_CALL_KWS_SWITCH_ENABLE
if (ESCO_SIRI_WAKEUP() || (bt_get_call_status() != BT_CALL_INCOMING)) {
audio_smart_voice_detect_close();
}
#else
audio_smart_voice_detect_close();
#endif
#endif
}
int bt_phone_esco_play(u8 *bt_addr)
{
puts("<<<<<<<<<<<esco_dec_stat\n");
u8 temp_btaddr[6];
if (esco_player_get_btaddr(temp_btaddr)) {
//已经有设备在用了，不能重复初始化
printf("CMD_OPEN_ESCO_PLAYER error\n");
return 1;
}
#if TCFG_SMART_VOICE_ENABLE && !TCFG_AUDIO_ASR_DEVELOP
esco_smart_voice_detect_handler();
#endif
a2dp_player_close(bt_addr);
bt_stop_a2dp_slience_detect(bt_addr);
a2dp_media_close(bt_addr);
#if 0 //debug
void mic_capless_feedback_toggle(u8 toggle);
mic_capless_feedback_toggle(0);
#endif
#if TCFG_BT_INBAND_RING
tone_ring_player_stop();
#else
if (BT_CALL_INCOMING == bt_get_call_status_for_addr(bt_addr)) {
lmp_private_esco_suspend_resume(3);
} else {
tone_ring_player_stop();
}
#endif
bt_api_esco_status(bt_addr, BT_ESCO_STATUS_OPEN);
esco_audio_open(bt_addr);
g_bt_hdl.phone_call_dec_begin = 1;
if (bt_get_call_status() == BT_CALL_ACTIVE) {
log_info("dec_begin,dump_packet clear\n");
esco_dump_packet = ESCO_DUMP_PACKET_DEFAULT;
}
pbg_user_mic_fixed_deal(1);
return 0;
}
int bt_phone_esco_stop(u8 *bt_addr)
{
puts("<<<<<<<<<<<esco_dec_stop\n");
g_bt_hdl.phone_call_dec_begin = 0;
esco_dump_packet = ESCO_DUMP_PACKET_CALL;
bt_api_esco_status(bt_addr, BT_ESCO_STATUS_CLOSE);
esco_recoder_close();
esco_player_close();
#if TCFG_SMART_VOICE_ENABLE && !TCFG_AUDIO_ASR_DEVELOP
audio_smart_voice_detect_open(JL_KWS_COMMAND_KEYWORD);
#endif
if (app_var.goto_poweroff_flag) {
return 0;
}
pbg_user_mic_fixed_deal(0);
return 0;
}
int bt_phone_last_call_type(u8 *bt_addr, u8 bt_value)
{
g_bt_hdl.last_call_type = bt_value;
return 0;
}
////当手机app与手表传输过程中不能响应通话事件
void set_rcsp_watch_upgrade_flag(u8 flag)
{
g_bt_hdl.smartbox_watch_upgrade_flag = flag;
printf("%s need to do \n", __FUNCTION__);
}
int bt_phone_siri(u8 *bt_addr, u8 bt_value)
{
app_var.siri_stu = bt_value;
esco_dump_packet = ESCO_DUMP_PACKET_DEFAULT;
return 0;
}
//通话前判断剩余内存\错峰策略
#define ESCO_MEM_CHECK 1
#define ESCO_MEM_CHECK_SAVE_SIZE (50*1024)
#if ESCO_MEM_CHECK
static u16 esco_check_timer;
static u8 esco_cmd_data[9];
static void esco_play_in_task(u8 *data);
extern u32 lmp_private_clear_sco_packet(u8 clear_num);
extern u32 esco_media_get_packet_num();
extern size_t xPortGetPhysiceMemorySize(void);
static void memory_esco_opt_phone_timer()
{
if (!esco_check_timer) {
return;
}
int num = esco_media_get_packet_num();
if (num) {
printf("free esco %d\n", num);
lmp_private_clear_sco_packet(num);
}
printf("call status %x,please check to call ui\n", phone_call_status);
if (xPortGetPhysiceMemorySize() >= ESCO_MEM_CHECK_SAVE_SIZE) {
printf("esco ram is is ok \n");
esco_play_in_task(esco_cmd_data);
sys_timer_del(esco_check_timer);
esco_check_timer = 0;
}
}
#endif
static void esco_play_in_task(u8 *data)
{
u8 *bt_addr = data + 2;
u8 bt_value = data[8] ;
r_printf("esco_play_in_task=%d\n", data[0]);
switch (data[0]) {
case CMD_OPEN_ESCO_PLAYER:
#if ESCO_MEM_CHECK
//先丟包
int num = esco_media_get_packet_num();
if (num) {
printf("free esco %d\n", num);
lmp_private_clear_sco_packet(num);
}
//解决通话瞬态内存问题
#if (defined(CONFIG_UI_STYLE_JL_PUBLIC_MODLS_ENABLE))
if (UI_GET_WINDOW_ID() != ID_WINDOW_PHONE_CALL_STATUS) {
if (call_ctrl_get_status() != BT_SIRI_STATE) { // 如果是siri状态，不显示通话界面
UI_WINDOW_PREEMPTION_POSH(ID_WINDOW_PHONE_CALL_STATUS, NULL, NULL, UI_WINDOW_PREEMPTION_TYPE_PHONE);
}
}
#endif
//释放内存
if (xPortGetPhysiceMemorySize() < ESCO_MEM_CHECK_SAVE_SIZE) {
printf("esco ram is dangerous \n");
memcpy(esco_cmd_data, data, 9);
if (!esco_check_timer) {
esco_check_timer = sys_timer_add(NULL, memory_esco_opt_phone_timer, 100);
}
break;
}
#endif
#if (TCFG_BT_ESCO_PLAYER_ENABLE == 0)
lmp_private_esco_suspend_resume(1);
break;
#endif
bt_phone_esco_play(bt_addr);
break;
case CMD_CLOSE_ESCO_PLAYER:
#if ESCO_MEM_CHECK
if (esco_check_timer) {
sys_timer_del(esco_check_timer);
esco_check_timer = 0;
}
#endif
bt_phone_esco_stop(bt_addr);
break;
case CMD_PHONE_HANGUP:
bt_phone_hangup(bt_addr);
break;
case CMD_PHONE_ACTIVE:
bt_phone_active(bt_addr);
break;
case CMD_PHONE_INCOME:
bt_phone_income(bt_value, bt_addr);
break;
case CMD_PHONE_OUT:
bt_phone_out(bt_addr);
break;
case CMD_PHONE_LASET_CALL_TYPE:
bt_phone_last_call_type(bt_addr, bt_value);
break;
case CMD_PHONE_SIRI:
bt_phone_siri(bt_addr, bt_value);
break;
}
}
static void phone_call_send_cmd(u8 cmd, u8 *btaddr, u8 bt_value, u8 tx_do_action)
{
u8 data[9];
data[0] = cmd;
data[1] = 2;
memcpy(data + 2, btaddr, 6);
data[8] = bt_value;
esco_play_in_task(data);
}
void phone_sync_vol(void)
{
bt_cmd_prepare(USER_CTRL_HFP_CALL_SET_VOLUME, 1, &g_bt_hdl.phone_vol);
}
#if ESCO_DUMP_PACKET_ADJUST
u8 get_esco_packet_dump(void)
{
//log_info("esco_dump_packet:%d\n", esco_dump_packet);
return esco_dump_packet;
}
#endif
static u8 check_phone_income_idle(void)
{
if (g_bt_hdl.phone_ring_flag) {
return 0;
}
return 1;
}
REGISTER_LP_TARGET(phone_incom_lp_target) = {
.name = "phone_check",
.is_idle = check_phone_income_idle,
};
static int bt_phone_num_to_file_list(const char *file_list[], int max_file_num)
{
int i;
char *num = (char *)(g_bt_hdl.income_phone_num);
printf("phone_num: %s\n", num);
for (i = 0; i < max_file_num && num[i] != '\0'; i++) {
file_list[i] = get_tone_files()->num[num[i] - '0'];
}
return i;
}
int phone_income_num_play_end(void *priv, enum stream_event ev)
{
printf("%s\n", __func__);
switch (ev) {
case STREAM_EVENT_STOP:
///来电报号结束，启动本地铃声播放
phone_ring_play_start();
break;
default:
break;
}
return 0;
}
static void phone_income_num_check(void *priv)
{
const char *file_list[20];
g_bt_hdl.phone_timer_id = 0;
if (g_bt_hdl.phone_num_flag) {
if (g_bt_hdl.phone_ring_flag) {
tone_ring_player_stop();
int file_num = bt_phone_num_to_file_list(file_list, ARRAY_SIZE(file_list));
if (g_bt_hdl.inband_ringtone == 0) {
play_tone_files_alone_callback(file_list, file_num, NULL, phone_income_num_play_end);
} else {
play_tone_files_alone(file_list, file_num);
}
}
} else {
/*电话号码还没有获取到，定时查询*/
g_bt_hdl.phone_timer_id = sys_timeout_add(NULL, phone_income_num_check, 200);
}
}
bool is_siri_open()
{
if (app_var.siri_stu == 1 || app_var.siri_stu == 2) {
return 1;
}
return 0;
}
/*
* 对应原来的状态处理函数，连接，电话状态等
*/
static int bt_phone_status_event_handler(int *msg)
{
u8 *phone_number = NULL;
struct bt_event *bt = (struct bt_event *)msg;
switch (bt->event) {
case BT_STATUS_PHONE_INCOME:
log_info("BT_STATUS_PHONE_INCOME\n");
put_buf(bt->args, 6);
phone_call_status = CMD_PHONE_INCOME;
esco_dump_packet = ESCO_DUMP_PACKET_CALL;
u8 tmp_bd_addr[6];
memcpy(tmp_bd_addr, bt->args, 6);
/*
*(1)1t2有一台通话的时候，另一台如果来电会叠加
*/
phone_call_send_cmd(CMD_PHONE_INCOME, bt->args, 0, 1);
/* bt_phone_income(0, 0, tmp_bd_addr); */
bt_cmd_prepare(USER_CTRL_HFP_CALL_CURRENT, 0, NULL); //发命令获取电话号码
#if TCFG_DATA_STORAGE_ENABLE
small_file_call_log_set_sel(CALL_SEL_BT);
small_file_call_log_set_type(CALL_INCOME);
#endif
UI_MOTO_RUN(1);
#if (defined(CONFIG_UI_STYLE_JL_PUBLIC_MODLS_ENABLE))
if (UI_GET_WINDOW_ID() == ID_WINDOW_PHONE_CALL_STATUS) {
ui_phone_call_end_status_check();
UI_MSG_POST("phone_income:status=%4", 1);
} else {
UI_WINDOW_PREEMPTION_POSH(ID_WINDOW_PHONE_CALL_STATUS, NULL, NULL, UI_WINDOW_PREEMPTION_TYPE_PHONE);
}
#endif
break;
case BT_STATUS_PHONE_OUT:
log_info("BT_STATUS_PHONE_OUT\n");
put_buf(bt->args, 6);
phone_call_status = CMD_PHONE_OUT;
bt_phone_out(bt->args);
phone_call_send_cmd(CMD_PHONE_OUT, bt->args, 0, 0);
bt_cmd_prepare(USER_CTRL_HFP_CALL_CURRENT, 0, NULL); //发命令获取电话号码
#if TCFG_BT_CALL_PHONE_BY_WATCH
if (get_bt_esco_by_watch() == FALSE) { // 增加手机去电mic使用手机端，同时会禁掉微信来电走手表这个功能
/* 延时200ms发送断开esco的命令，测试发现立马发送断开命令，手机会再次发送esco请求 */
/* 此处定时1s，在1s内发起的esco链路都会被断开 */
if (disable_sco_mod) {
lmp_esco_rejust_establish(1);
}
bt_esco_by_watch_time = sys_timeout_add(NULL, bt_esco_conn_time, 1000);
break;
} else {
if (disable_sco_mod) {
lmp_esco_rejust_establish(0);
}
}
#endif
#if TCFG_DATA_STORAGE_ENABLE
small_file_call_log_set_sel(CALL_SEL_BT);
small_file_call_log_set_type(CALL_OUT);
#endif
#if (defined(CONFIG_UI_STYLE_JL_PUBLIC_MODLS_ENABLE))
if (UI_GET_WINDOW_ID() == ID_WINDOW_PHONE_CALL_STATUS) {
ui_phone_call_end_status_check();
UI_MSG_POST("phone_out:status=%4", 1);
} else {
UI_WINDOW_PREEMPTION_POSH(ID_WINDOW_PHONE_CALL_STATUS, NULL, NULL, UI_WINDOW_PREEMPTION_TYPE_PHONE);
}
#endif
break;
case BT_STATUS_PHONE_ACTIVE:
log_info("BT_STATUS_PHONE_ACTIVE\n");
if ((phone_call_status == CMD_PHONE_INCOME) || (phone_call_status == CMD_PHONE_OUT)) {
phone_call_start = jiffies_msec();
}
phone_call_status = CMD_PHONE_ACTIVE;
phone_call_send_cmd(CMD_PHONE_ACTIVE, bt->args, 0, 1);
UI_MOTO_RUN(0);
#if TCFG_BT_CALL_PHONE_BY_WATCH
if (get_bt_esco_by_watch() == FALSE) {
/* 延时200ms发送断开esco的命令，测试发现立马发送断开命令，手机会再次发送esco请求 */
/* 此处定时1.5s，在1.5s内发起的esco链路都会被断开 */ /* 针对iphone se修改增加定时 */
if (disable_sco_mod) {
lmp_esco_rejust_establish(1);
}
watch_sco_dly_disconnection();
bt_esco_by_watch_time = sys_timeout_add(NULL, bt_esco_conn_time, 1500);
#if TCFG_UI_ENABLE
if (UI_GET_WINDOW_ID() == ID_WINDOW_PHONE_CALL_STATUS) {//判断手表在来电界面，退出界面
UI_WINDOW_PREEMPTION_POP(ID_WINDOW_PHONE_CALL_STATUS);
}
#endif /* #if TCFG_UI_ENABLE */
break;
} else {
if (disable_sco_mod) {
lmp_esco_rejust_establish(0);
}
}
#endif
#if TCFG_DATA_STORAGE_ENABLE
small_file_call_log_set_date();
#endif
UI_MSG_POST("phone_active:status=%4", 1);
break;
case BT_STATUS_PHONE_HANGUP:
log_info("BT_STATUS_PHONE_HANGUP\n");
put_buf(bt->args, 6);
phone_call_start = 0;
phone_call_status = CMD_PHONE_HANGUP;
phone_call_send_cmd(CMD_PHONE_HANGUP, bt->args, 0, 1);
#if TCFG_BT_CALL_PHONE_BY_WATCH
set_bt_esco_by_watch(0);
#endif
#if TCFG_DATA_STORAGE_ENABLE
u32 utc_time = small_file_call_log_get_date();
if (utc_time == 0) {
small_file_call_log_set_date();
}
small_file_call_log_save();
#endif
if (UI_GET_WINDOW_ID() == ID_WINDOW_PHONE_CALL_STATUS) {
UI_MSG_POST("phone_hangup:status=%4", 1);
} else {
/*通话页面存于抢占页面缓存时候,当前抢占页面一直未退出时候
这时候挂断，得pop通话页面*/
UI_WINDOW_PREEMPTION_POP(ID_WINDOW_PHONE_CALL_STATUS);
}
UI_MOTO_RUN(0);
break;
case BT_STATUS_PHONE_NUMBER:
log_info("BT_STATUS_PHONE_NUMBER\n");
#if TCFG_BT_SUPPORT_PBAP_LIST
bt_cmd_prepare(USER_CTRL_PBAP_READ_LIST, 0, NULL);
#endif
phone_number = (u8 *)bt->value;
if (g_bt_hdl.phone_num_flag == 1) {
break;
}
g_bt_hdl.income_phone_len = 0;
memset(g_bt_hdl.income_phone_num, '\0',
sizeof(g_bt_hdl.income_phone_num));
for (int i = 0; i < strlen((const char *)phone_number); i++) {
if (phone_number[i] >= '0' && phone_number[i] <= '9') {
//过滤，只有数字才能报号
g_bt_hdl.income_phone_num[g_bt_hdl.income_phone_len++] = phone_number[i];
if (g_bt_hdl.income_phone_len >= sizeof(g_bt_hdl.income_phone_num)) {
break; /*buffer 空间不够，后面不要了*/
}
}
}
if (g_bt_hdl.income_phone_len > 0) {
g_bt_hdl.phone_num_flag = 1;
#if TCFG_DATA_STORAGE_ENABLE
char name[CALL_LOG_NAME_LEN] = {0};
if (small_file_phonebook_get_name_by_number(name, (char *)&g_bt_hdl.income_phone_num)) {
small_file_call_log_set_name(name, sizeof(name));
}
small_file_call_log_set_number((char *)&g_bt_hdl.income_phone_num, sizeof(g_bt_hdl.income_phone_num));
#endif
UI_MSG_POST("phone_num:status=%4", 1);
} else {
log_info("PHONE_NUMBER len err\n");
}
break;
case BT_STATUS_PHONE_NAME:
log_info("BT_STATUS_PHONE_NAME\n");
u8 *phone_name = NULL;
phone_name = (u8 *)bt->value;
log_info(">>name:%s\n", phone_name);
#if TCFG_DATA_STORAGE_ENABLE
small_file_call_log_set_name((char *)phone_name, strlen((const char *)phone_name) + 1);
#endif
UI_MSG_POST("phone_name:name=%4", (u8 *)bt->value);
break;
case BT_STATUS_INBAND_RINGTONE:
log_info("BT_STATUS_INBAND_RINGTONE\n");
#if TCFG_BT_INBAND_RING
g_bt_hdl.inband_ringtone = bt->value;
#else
g_bt_hdl.inband_ringtone = 0;
#endif
printf("inband_ringtone=0x%x\n", g_bt_hdl.inband_ringtone);
break;
case BT_STATUS_SCO_STATUS_CHANGE:
printf("BT_STATUS_SCO_STATUS_CHANGE len:%d, type:%d\n",
(bt->value >> 16), (bt->value & 0x0000ffff));
if (bt->value != 0xff) {
#if TCFG_BT_CALL_PHONE_BY_WATCH
if (bt_esco_ban_conn()) {
break;
} else if (get_bt_esco_by_watch() == FALSE) {
/* 用于判断部分手机来电铃声会发起esco请求 */
#if !TCFG_BT_INBAND_RING
if (bt_get_call_status() != BT_CALL_ACTIVE) {
watch_sco_dly_disconnection();
break;
}
#endif
}
#endif
u8 call_vol = 15;
//为了解决两个手机都在通话，在手机上轮流切声卡的音量问题
call_vol = bt_get_call_vol_for_addr(bt->args);
//r_printf("---bt_get_call_vol_for_addr--%d\n", call_vol);
app_audio_state_switch(APP_AUDIO_STATE_CALL, app_var.aec_dac_gain, NULL);
app_audio_set_volume(APP_AUDIO_STATE_CALL, call_vol, 1);
#if TCFG_MIC_EFFECT_ENABLE
mic_effect_player_pause(1);
#endif
phone_call_send_cmd(CMD_OPEN_ESCO_PLAYER, bt->args, 0, 1);
} else {
u8 bt_esco_play[6];
int ret = esco_player_get_btaddr(bt_esco_play);
#if TCFG_BT_CALL_PHONE_BY_WATCH
watch_sco_dly_time_del();
#endif
if (ret && memcmp(bt_esco_play, bt->args, 6) != 0) {
//如果有地址在是用esco音频，但跟传出来的值地址不一致，就不更新了。
puts("<<<<<<<<<<<bt_esco_stop err,check addr\n");
break;
}
/* bt_phone_esco_stop(bt->args); */
phone_call_send_cmd(CMD_CLOSE_ESCO_PLAYER, bt->args, 0, 1);
#if TCFG_MIC_EFFECT_ENABLE
mic_effect_player_pause(0);
#endif
}
#if TCFG_BT_CALL_PHONE_BY_WATCH
printf("[esco change] display_call_dly");
sys_timeout_add(NULL, display_call_dly, 300);
#endif
break;
case BT_STATUS_CALL_VOL_CHANGE:
//判断是当前地址的音量值才更新
u8 bt_esco_play[6];
int ret = esco_player_get_btaddr(bt_esco_play);
if (ret && memcmp(bt_esco_play, bt->args, 6) != 0) {
//如果有地址在是用esco音频，但跟传出来的值地址不一致，就不更新了。
break;
}
printf("call_vol:%d", bt->value);
u8 volume = bt->value;
u8 call_status = bt_get_call_status_for_addr(bt->args);
#if TCFG_BT_INBAND_RING
if ((call_status != BT_CALL_ACTIVE) && (bt->value == 0)) {
printf("not set vol\n");
break;
}
#endif
g_bt_hdl.phone_vol = bt->value;
if ((call_status == BT_CALL_ACTIVE) ||
(call_status == BT_CALL_OUTGOING) || app_var.siri_stu) {
app_audio_set_volume(APP_AUDIO_STATE_CALL, volume, 1);
} else {
/*
*只保存，不设置到dac
*微信语音通话的时候，会更新音量到app，但是此时的call status可能是hangup
*/
app_var.call_volume = volume;
}
UI_MSG_POST("phone_volume:volume=%4", volume);
break;
case BT_STATUS_LAST_CALL_TYPE_CHANGE:
log_info("BT_STATUS_LAST_CALL_TYPE_CHANGE:%d\n", bt->value);
g_bt_hdl.last_call_type = bt->value;
phone_call_send_cmd(CMD_PHONE_LASET_CALL_TYPE, bt->args, bt->value, 0);
break;
case BT_STATUS_CONN_HFP_CH:
r_printf("++++++++ BT_STATUS_CONN_HFP_CH +++++++++ \n");
break;
case BT_STATUS_DISCON_HFP_CH:
r_printf("++++++++ BT_STATUS_DISCON_HFP_CH +++++++++ \n");
break;
case BT_STATUS_PHONE_MANUFACTURER:
log_info("BT_STATUS_PHONE_MANUFACTURER:%d\n", bt->value);
app_var.remote_dev_company = bt->value;
break;
case BT_STATUS_SIRI_OPEN:
case BT_STATUS_SIRI_CLOSE:
case BT_STATUS_SIRI_GET_STATE:
/* case BT_STATUS_VOICE_RECOGNITION: */
log_info(" BT_STATUS_SIRI_RECOGNITION:%d \n", bt->value);
/* put_buf(bt, sizeof(struct bt_event)); */
app_var.siri_stu = bt->value;
esco_dump_packet = ESCO_DUMP_PACKET_DEFAULT;
phone_call_send_cmd(CMD_PHONE_SIRI, bt->args, bt->value, 0);
break;
default:
log_info(" BT STATUS DEFAULT\n");
break;
}
return 0;
}
APP_MSG_HANDLER(bt_phone_msg_handler_stub) = {
.owner = 0xff,
.from = MSG_FROM_BT_STACK,
.handler = bt_phone_status_event_handler,
};
static int phone_hci_event_handler(int *event)
{
struct bt_event *bt = (struct bt_event *)event;
switch (bt->event) {
case HCI_EVENT_DISCONNECTION_COMPLETE:
if (esco_player_is_playing(bt->args)) {
bt_phone_esco_stop(bt->args);
}
break;
}
return 0;
}
APP_MSG_HANDLER(phone_hci_msg_stub) = {
.owner = 0xff,
.from = MSG_FROM_BT_HCI,
.handler = phone_hci_event_handler,
};
#endif
#endif
Reference in New Issue View Git Blame Copy Permalink