rudism
/
pinebuds
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
pinebuds/apps/main/apps.cpp

2925 lines
89 KiB
C++
Raw Normal View History

add first commit
2022-08-15 04:20:27 -05:00
/***************************************************************************
*
* Copyright 2015-2019 BES.
* All rights reserved. All unpublished rights reserved.
*
* No part of this work may be used or reproduced in any form or by any
* means, or stored in a database or retrieval system, without prior written
* permission of BES.
*
* Use of this work is governed by a license granted by BES.
* This work contains confidential and proprietary information of
* BES. which is protected by copyright, trade secret,
* trademark and other intellectual property rights.
*
****************************************************************************/
#include "stdio.h"
#include "cmsis_os.h"
#include "list.h"
#include "string.h"
#include "hal_timer.h"
#include "hal_trace.h"
#include "hal_bootmode.h"
#include "hal_sleep.h"
#include "pmu.h"
#include "audioflinger.h"
#include "apps.h"
#include "app_thread.h"
#include "app_key.h"
#include "app_bt_media_manager.h"
#include "app_pwl.h"
#include "app_audio.h"
#include "app_overlay.h"
#include "app_battery.h"
#include "app_utils.h"
#include "app_status_ind.h"
#include "bt_drv_interface.h"
#include "besbt.h"
#include "norflash_api.h"
#include "nvrecord.h"
#include "nvrecord_dev.h"
#include "nvrecord_env.h"
#include "crash_dump_section.h"
#include "log_section.h"
#include "factory_section.h"
#include "a2dp_api.h"
#include "me_api.h"
#include "os_api.h"
#include "btapp.h"
#include "app_bt.h"
#include "bt_if.h"
#include "gapm_task.h"
#include "app_ble_include.h"
#include "app_bt_func.h"
#include "tgt_hardware.h"
#include "hal_i2c.h"
#ifdef __AI_VOICE__
#include "app_ai_if.h"
#include "app_ai_tws.h"
#include "ai_manager.h"
#include "app_ai_manager_api.h"
#endif
#include "app_tws_ibrt_cmd_handler.h"
#include "audio_process.h"
#ifdef __PC_CMD_UART__
#include "app_cmd.h"
#endif
#ifdef __FACTORY_MODE_SUPPORT__
#include "app_factory.h"
#include "app_factory_bt.h"
#endif
#ifdef __INTERCONNECTION__
#include "app_interconnection.h"
#include "app_interconnection_ble.h"
#include "app_interconnection_logic_protocol.h"
#include "app_ble_mode_switch.h"
#endif
#ifdef __INTERACTION__
#include "app_interaction.h"
#endif
#ifdef BISTO_ENABLED
#include "app_ai_manager_api.h"
#include "gsound_custom_reset.h"
#include "nvrecord_gsound.h"
#include "gsound_custom_actions.h"
#include "gsound_custom_ota.h"
#endif
#ifdef IBRT_OTA
#include "ota_bes.h"
#endif
#ifdef MEDIA_PLAYER_SUPPORT
#include "resources.h"
#include "app_media_player.h"
#endif
#ifdef VOICE_DATAPATH
#include "app_voicepath.h"
#endif
#ifdef BT_USB_AUDIO_DUAL_MODE
#include "btusb_audio.h"
#include "usbaudio_thread.h"
#endif
#ifdef TILE_DATAPATH
#include "tile_target_ble.h"
#endif
#if defined(IBRT)
#include "app_ibrt_if.h"
#include "app_ibrt_customif_ui.h"
#include "app_ibrt_ui_test.h"
#include "app_ibrt_voice_report.h"
#include "app_tws_if.h"
#include "app_ibrt_customif_cmd.h"
#endif
#ifdef GFPS_ENABLED
#include "app_gfps.h"
#endif
#ifdef BTIF_BLE_APP_DATAPATH_SERVER
#include "app_ble_cmd_handler.h"
#endif
#ifdef ANC_APP
#include "app_anc.h"
#endif
#ifdef __THIRDPARTY
#include "app_thirdparty.h"
#endif
#ifdef OTA_ENABLED
#include "nvrecord_ota.h"
#include "ota_common.h"
#endif
add base work success
2022-08-15 20:30:33 -05:00
#ifdef WL_DET
#include "app_mic_alg.h"
#endif
add first commit
2022-08-15 04:20:27 -05:00
#ifdef AUDIO_DEBUG_V0_1_0
extern "C" int speech_tuning_init(void);
#endif
#if (defined(BTUSB_AUDIO_MODE) || defined(BT_USB_AUDIO_DUAL_MODE))
extern "C" bool app_usbaudio_mode_on(void) ;
#endif
#ifdef BES_OTA_BASIC
extern "C" void ota_flash_init(void);
#endif
#define APP_BATTERY_LEVEL_LOWPOWERTHRESHOLD (1)
#define POWERON_PRESSMAXTIME_THRESHOLD_MS (5000)
#ifdef FPGA
uint32_t __ota_upgrade_log_start[100];
#endif
enum APP_POWERON_CASE_T {
APP_POWERON_CASE_NORMAL = 0,
APP_POWERON_CASE_DITHERING,
APP_POWERON_CASE_REBOOT,
APP_POWERON_CASE_ALARM,
APP_POWERON_CASE_CALIB,
APP_POWERON_CASE_BOTHSCAN,
APP_POWERON_CASE_CHARGING,
APP_POWERON_CASE_FACTORY,
APP_POWERON_CASE_TEST,
APP_POWERON_CASE_LINKLOSE_REBOOT,
APP_POWERON_CASE_INVALID,
APP_POWERON_CASE_NUM
};
#ifdef RB_CODEC
extern int rb_ctl_init();
extern bool rb_ctl_is_init_done(void);
extern void app_rbplay_audio_reset_pause_status(void);
#endif
#ifdef __SUPPORT_ANC_SINGLE_MODE_WITHOUT_BT__
extern bool app_pwr_key_monitor_get_val(void);
static bool anc_single_mode_on = false;
extern "C" bool anc_single_mode_is_on(void)
{
return anc_single_mode_on;
}
#endif
#ifdef __ANC_STICK_SWITCH_USE_GPIO__
extern bool app_anc_switch_get_val(void);
#endif
#ifdef GFPS_ENABLED
extern "C" void app_fast_pairing_timeout_timehandler(void);
#endif
uint8_t app_poweroff_flag = 0;
static enum APP_POWERON_CASE_T g_pwron_case = APP_POWERON_CASE_INVALID;
#ifndef APP_TEST_MODE
static uint8_t app_status_indication_init(void)
{
struct APP_PWL_CFG_T cfg;
hal_iomux_init((struct HAL_IOMUX_PIN_FUNCTION_MAP *)cfg_hw_pinmux_pwl, sizeof(cfg_hw_pinmux_pwl)/sizeof(struct HAL_IOMUX_PIN_FUNCTION_MAP));
memset(&cfg, 0, sizeof(struct APP_PWL_CFG_T));
app_pwl_open();
app_pwl_setup(APP_PWL_ID_0, &cfg);
app_pwl_setup(APP_PWL_ID_1, &cfg);
return 0;
}
#endif
#if defined(__BTIF_EARPHONE__) && defined(__BTIF_AUTOPOWEROFF__)
void PairingTransferToConnectable(void);
typedef void (*APP_10_SECOND_TIMER_CB_T)(void);
void app_pair_timerout(void);
void app_poweroff_timerout(void);
void CloseEarphone(void);
typedef struct
{
uint8_t timer_id;
uint8_t timer_en;
uint8_t timer_count;
uint8_t timer_period;
APP_10_SECOND_TIMER_CB_T cb;
}APP_10_SECOND_TIMER_STRUCT;
#define INIT_APP_TIMER(_id, _en, _count, _period, _cb) \
{ \
.timer_id = _id, \
.timer_en = _en, \
.timer_count = _count, \
.timer_period = _period, \
.cb = _cb, \
}
APP_10_SECOND_TIMER_STRUCT app_10_second_array[] =
{
INIT_APP_TIMER(APP_PAIR_TIMER_ID, 0, 0, 6, PairingTransferToConnectable),
INIT_APP_TIMER(APP_POWEROFF_TIMER_ID, 0, 0, 90, CloseEarphone),
#ifdef GFPS_ENABLED
INIT_APP_TIMER(APP_FASTPAIR_LASTING_TIMER_ID, 0, 0, APP_FAST_PAIRING_TIMEOUT_IN_SECOND/10,
app_fast_pairing_timeout_timehandler),
#endif
};
void app_stop_10_second_timer(uint8_t timer_id)
{
APP_10_SECOND_TIMER_STRUCT *timer = &app_10_second_array[timer_id];
timer->timer_en = 0;
timer->timer_count = 0;
}
void app_start_10_second_timer(uint8_t timer_id)
{
APP_10_SECOND_TIMER_STRUCT *timer = &app_10_second_array[timer_id];
timer->timer_en = 0;
timer->timer_count = 0;
}
void app_set_10_second_timer(uint8_t timer_id, uint8_t enable, uint8_t period)
{
APP_10_SECOND_TIMER_STRUCT *timer = &app_10_second_array[timer_id];
timer->timer_en = enable;
timer->timer_count = period;
}
void app_10_second_timer_check(void)
{
APP_10_SECOND_TIMER_STRUCT *timer = app_10_second_array;
unsigned int i;
for(i = 0; i < ARRAY_SIZE(app_10_second_array); i++) {
if (timer->timer_en) {
timer->timer_count++;
if (timer->timer_count >= timer->timer_period) {
timer->timer_en = 0;
if (timer->cb)
timer->cb();
}
}
timer++;
}
}
void CloseEarphone(void)
{
int activeCons;
osapi_lock_stack();
activeCons = btif_me_get_activeCons();
osapi_unlock_stack();
#ifdef ANC_APP
if(app_anc_work_status()) {
app_set_10_second_timer(APP_POWEROFF_TIMER_ID, 1, 30);
return;
}
#endif /* ANC_APP */
if(activeCons == 0) {
TRACE(0,"!!!CloseEarphone\n");
app_shutdown();
}
}
#endif /* #if defined(__BTIF_EARPHONE__) && defined(__BTIF_AUTOPOWEROFF__) */
int signal_send_to_main_thread(uint32_t signals);
uint8_t stack_ready_flag = 0;
void app_notify_stack_ready(uint8_t ready_flag)
{
TRACE(2,"app_notify_stack_ready %d %d", stack_ready_flag, ready_flag);
stack_ready_flag |= ready_flag;
#ifdef __IAG_BLE_INCLUDE__
if(stack_ready_flag == (STACK_READY_BT|STACK_READY_BLE))
#endif
{
signal_send_to_main_thread(0x3);
}
}
bool app_is_stack_ready(void)
{
bool ret = false;
if (stack_ready_flag == (STACK_READY_BT
#ifdef __IAG_BLE_INCLUDE__
| STACK_READY_BLE
#endif
))
{
ret = true;
}
return ret;
}
static void app_stack_ready_cb(void)
{
TRACE(0,"stack init done");
#ifdef BLE_ENABLE
app_ble_stub_user_init();
app_ble_start_connectable_adv(BLE_ADVERTISING_INTERVAL);
#endif
}
//#if (HF_CUSTOM_FEATURE_SUPPORT & HF_CUSTOM_FEATURE_BATTERY_REPORT) || (HF_SDK_FEATURES & HF_FEATURE_HF_INDICATORS)
#if defined(SUPPORT_BATTERY_REPORT) || defined(SUPPORT_HF_INDICATORS)
extern void app_hfp_set_battery_level(uint8_t level);
#endif
int app_status_battery_report(uint8_t level)
{
#ifdef __SUPPORT_ANC_SINGLE_MODE_WITHOUT_BT__
if (anc_single_mode_on) //anc power on,anc only mode
return 0;
#endif
#if defined(__BTIF_EARPHONE__)
if (app_is_stack_ready())
{
app_bt_state_checker();
}
app_10_second_timer_check();
#endif
if (level <= APP_BATTERY_LEVEL_LOWPOWERTHRESHOLD)
{
//add something
}
if (app_is_stack_ready())
{
// #if (HF_CUSTOM_FEATURE_SUPPORT & HF_CUSTOM_FEATURE_BATTERY_REPORT) || (HF_SDK_FEATURES & HF_FEATURE_HF_INDICATORS)
#if defined(SUPPORT_BATTERY_REPORT) || defined(SUPPORT_HF_INDICATORS)
#if defined(IBRT)
if (app_tws_ibrt_mobile_link_connected())
{
app_hfp_set_battery_level(level);
}
#else
app_hfp_set_battery_level(level);
#endif
#else
TRACE(1,"[%s] Can not enable SUPPORT_BATTERY_REPORT", __func__);
#endif
osapi_notify_evm();
}
return 0;
}
void stopAuto_Shutdowm_Timer(void);
void app_bt_power_off_customize()
{
#if(TWS_Sync_Shutdowm)
app_ibrt_poweroff_notify_force();
#endif
app_shutdown();
}
#ifdef MEDIA_PLAYER_SUPPORT
void app_status_set_num(const char* p)
{
media_Set_IncomingNumber(p);
}
static u8 last_voice_waring = APP_STATUS_INDICATION_NUM;
int app_voice_report_handler(APP_STATUS_INDICATION_T status, uint8_t device_id, uint8_t isMerging)
{
#if (defined(BTUSB_AUDIO_MODE) || defined(BT_USB_AUDIO_DUAL_MODE))
if(app_usbaudio_mode_on()) return 0;
#endif
TRACE(3,"%s %d",__func__, status);
AUD_ID_ENUM id = MAX_RECORD_NUM;
#ifdef __SUPPORT_ANC_SINGLE_MODE_WITHOUT_BT__
if(anc_single_mode_on)
return 0;
#endif
if(((last_voice_waring == APP_STATUS_INDICATION_POWERON)&&(status == APP_STATUS_INDICATION_POWERON))||
((last_voice_waring == APP_STATUS_INDICATION_BOTHSCAN)&&(status == APP_STATUS_INDICATION_BOTHSCAN))||
((last_voice_waring == APP_STATUS_INDICATION_BOTHSCAN)&&(status == APP_STATUS_INDICATION_DISCONNECTED))){
last_voice_waring = status;
return 0;
}
if (app_poweroff_flag == 1){
switch (status) {
case APP_STATUS_INDICATION_POWEROFF:
id = AUD_ID_POWER_OFF;
break;
default:
return 0;
break;
}
}else{
switch (status) {
case APP_STATUS_INDICATION_POWERON:
id = AUD_ID_POWER_ON;
break;
case APP_STATUS_INDICATION_POWEROFF:
id = AUD_ID_POWER_OFF;
break;
case APP_STATUS_INDICATION_CONNECTED:
id = AUD_ID_BT_CONNECTED;
break;
case APP_STATUS_INDICATION_DISCONNECTED:
id = AUD_ID_BT_DIS_CONNECT;
break;
case APP_STATUS_INDICATION_CALLNUMBER:
id = AUD_ID_BT_CALL_INCOMING_NUMBER;
break;
case APP_STATUS_INDICATION_CHARGENEED:
id = AUD_ID_BT_CHARGE_PLEASE;
break;
case APP_STATUS_INDICATION_FULLCHARGE:
id = AUD_ID_BT_CHARGE_FINISH;
break;
case APP_STATUS_INDICATION_PAIRSUCCEED:
id = AUD_ID_BT_PAIRING_SUC;
break;
case APP_STATUS_INDICATION_PAIRFAIL:
id = AUD_ID_BT_PAIRING_FAIL;
break;
case APP_STATUS_INDICATION_HANGUPCALL:
id = AUD_ID_BT_CALL_HUNG_UP;
break;
case APP_STATUS_INDICATION_REFUSECALL:
id = AUD_ID_BT_CALL_REFUSE;
isMerging = false;
break;
case APP_STATUS_INDICATION_ANSWERCALL:
id = AUD_ID_BT_CALL_ANSWER;
break;
case APP_STATUS_INDICATION_CLEARSUCCEED:
id = AUD_ID_BT_CLEAR_SUCCESS;
break;
case APP_STATUS_INDICATION_CLEARFAIL:
id = AUD_ID_BT_CLEAR_FAIL;
break;
case APP_STATUS_INDICATION_INCOMINGCALL:
id = AUD_ID_BT_CALL_INCOMING_CALL;
break;
case APP_STATUS_INDICATION_BOTHSCAN:
id = AUD_ID_BT_PAIR_ENABLE;
break;
case APP_STATUS_INDICATION_WARNING:
id = AUD_ID_BT_WARNING;
break;
case APP_STATUS_INDICATION_ALEXA_START:
id = AUDIO_ID_BT_ALEXA_START;
break;
case APP_STATUS_INDICATION_ALEXA_STOP:
id = AUDIO_ID_BT_ALEXA_STOP;
break;
case APP_STATUS_INDICATION_GSOUND_MIC_OPEN:
id = AUDIO_ID_BT_GSOUND_MIC_OPEN;
break;
case APP_STATUS_INDICATION_GSOUND_MIC_CLOSE:
id = AUDIO_ID_BT_GSOUND_MIC_CLOSE;
break;
case APP_STATUS_INDICATION_GSOUND_NC:
id = AUDIO_ID_BT_GSOUND_NC;
break;
#ifdef __BT_WARNING_TONE_MERGE_INTO_STREAM_SBC__
case APP_STATUS_RING_WARNING:
id = AUD_ID_RING_WARNING;
break;
#endif
case APP_STATUS_INDICATION_MUTE:
id = AUDIO_ID_BT_MUTE;
break;
#ifdef __INTERACTION__
case APP_STATUS_INDICATION_FINDME:
id = AUD_ID_BT_FINDME;
break;
#endif
case APP_STATUS_INDICATION_FIND_MY_BUDS:
id = AUDIO_ID_FIND_MY_BUDS;
break;
case APP_STATUS_INDICATION_TILE_FIND:
id = AUDIO_ID_FIND_TILE;
break;
case APP_STATUS_INDICATION_DUDU:
id = AUDIO_ID_BT_DUDU;
break;
case APP_STATUS_INDICATION_DU:
id = AUDIO_ID_BT_DU;
break;
default:
break;
}
}
uint16_t aud_pram = 0;
if (isMerging){
aud_pram |= PROMOT_ID_BIT_MASK_MERGING;
}
#ifdef BT_USB_AUDIO_DUAL_MODE
if(!btusb_is_usb_mode())
{
#if defined(IBRT)
app_ibrt_if_voice_report_handler(id, aud_pram);
#else
trigger_media_play(id, device_id, aud_pram);
#endif
}
#else
#if defined(IBRT)
aud_pram |= PROMOT_ID_BIT_MASK_CHNLSEl_ALL;
app_ibrt_if_voice_report_handler(id, aud_pram);
#else
trigger_media_play(id, device_id, aud_pram);
#endif
#endif
return 0;
}
extern "C" int app_voice_report(APP_STATUS_INDICATION_T status, uint8_t device_id)
{
return app_voice_report_handler(status, device_id, true);
}
extern "C" int app_voice_report_generic(APP_STATUS_INDICATION_T status, uint8_t device_id, uint8_t isMerging)
{
return app_voice_report_handler(status, device_id, isMerging);
}
extern "C" int app_voice_stop(APP_STATUS_INDICATION_T status, uint8_t device_id)
{
AUD_ID_ENUM id = MAX_RECORD_NUM;
TRACE(2,"%s %d", __func__, status);
if (status == APP_STATUS_INDICATION_FIND_MY_BUDS)
id = AUDIO_ID_FIND_MY_BUDS;
if (id != MAX_RECORD_NUM)
trigger_media_stop(id, device_id);
return 0;
}
#endif
add base 2300_open source on it
2022-09-02 22:23:40 -05:00
#if 1//!defined(BLE_ONLY_ENABLED)
add first commit
2022-08-15 04:20:27 -05:00
static void app_poweron_normal(APP_KEY_STATUS *status, void *param)
{
TRACE(3,"%s %d,%d",__func__, status->code, status->event);
g_pwron_case = APP_POWERON_CASE_NORMAL;
signal_send_to_main_thread(0x2);
}
static void app_poweron_scan(APP_KEY_STATUS *status, void *param)
{
TRACE(3,"%s %d,%d",__func__, status->code, status->event);
g_pwron_case = APP_POWERON_CASE_BOTHSCAN;
signal_send_to_main_thread(0x2);
}
#endif
#if 0//def __ENGINEER_MODE_SUPPORT__
#if !defined(BLE_ONLY_ENABLED)
static void app_poweron_factorymode(APP_KEY_STATUS *status, void *param)
{
TRACE(3,"%s %d,%d",__func__, status->code, status->event);
hal_sw_bootmode_clear(HAL_SW_BOOTMODE_REBOOT);
app_factorymode_enter();
}
#endif
#endif
#ifndef __POWERKEY_CTRL_ONOFF_ONLY__
static bool g_pwron_finished = false;
static void app_poweron_finished(APP_KEY_STATUS *status, void *param)
{
TRACE(3,"%s %d,%d",__func__, status->code, status->event);
g_pwron_finished = true;
signal_send_to_main_thread(0x2);
}
#endif
void app_poweron_wait_finished(void)
{
#ifndef __POWERKEY_CTRL_ONOFF_ONLY__
if (!g_pwron_finished)
#endif
{
osSignalWait(0x2, osWaitForever);
}
}
#if defined(__POWERKEY_CTRL_ONOFF_ONLY__)
void app_bt_key_shutdown(APP_KEY_STATUS *status, void *param);
const APP_KEY_HANDLE pwron_key_handle_cfg[] = {
{{APP_KEY_CODE_PWR,APP_KEY_EVENT_UP}, "power on: shutdown" , app_bt_key_shutdown, NULL},
};
#elif defined(__ENGINEER_MODE_SUPPORT__)
const APP_KEY_HANDLE pwron_key_handle_cfg[] = {
{{APP_KEY_CODE_PWR,APP_KEY_EVENT_INITUP}, "power on: normal" , app_poweron_normal, NULL},
#if !defined(BLE_ONLY_ENABLED)
{{APP_KEY_CODE_PWR,APP_KEY_EVENT_INITLONGPRESS}, "power on: both scan" , app_poweron_scan , NULL},
// {{APP_KEY_CODE_PWR,APP_KEY_EVENT_INITLONGLONGPRESS},"power on: factory mode", app_poweron_factorymode , NULL},
#endif
{{APP_KEY_CODE_PWR,APP_KEY_EVENT_INITFINISHED}, "power on: finished" , app_poweron_finished , NULL},
};
#else
const APP_KEY_HANDLE pwron_key_handle_cfg[] = {
{{APP_KEY_CODE_PWR,APP_KEY_EVENT_INITUP}, "power on: normal" , app_poweron_normal, NULL},
{{APP_KEY_CODE_PWR,APP_KEY_EVENT_INITLONGPRESS}, "power on: both scan" , app_poweron_scan , NULL},
{{APP_KEY_CODE_PWR,APP_KEY_EVENT_INITFINISHED}, "power on: finished" , app_poweron_finished , NULL},
};
#endif
#ifndef APP_TEST_MODE
static void app_poweron_key_init(void)
{
uint8_t i = 0;
TRACE(1,"%s",__func__);
for (i=0; i<(sizeof(pwron_key_handle_cfg)/sizeof(APP_KEY_HANDLE)); i++){
app_key_handle_registration(&pwron_key_handle_cfg[i]);
}
}
static uint8_t app_poweron_wait_case(void)
{
#ifdef __POWERKEY_CTRL_ONOFF_ONLY__
g_pwron_case = APP_POWERON_CASE_NORMAL;
#else
add base 2300_open source on it
2022-09-02 22:23:40 -05:00
uint32_t stime = 0, etime = 0;
add first commit
2022-08-15 04:20:27 -05:00
TRACE(1,"poweron_wait_case enter:%d", g_pwron_case);
if (g_pwron_case == APP_POWERON_CASE_INVALID){
stime = hal_sys_timer_get();
osSignalWait(0x2, POWERON_PRESSMAXTIME_THRESHOLD_MS);
etime = hal_sys_timer_get();
}
TRACE(2,"powon raw case:%d time:%d", g_pwron_case, TICKS_TO_MS(etime - stime));
#endif
return g_pwron_case;
}
#endif
static void app_wait_stack_ready(void)
{
uint32_t stime, etime;
stime = hal_sys_timer_get();
osSignalWait(0x3, 1000);
etime = hal_sys_timer_get();
TRACE(1,"app_wait_stack_ready: wait:%d ms", TICKS_TO_MS(etime - stime));
app_stack_ready_cb();
}
extern "C" int system_shutdown(void);
int app_shutdown(void)
{
system_shutdown();
return 0;
}
int system_reset(void);
int app_reset(void)
{
system_reset();
return 0;
}
static void app_postponed_reset_timer_handler(void const *param);
osTimerDef(APP_POSTPONED_RESET_TIMER, app_postponed_reset_timer_handler);
static osTimerId app_postponed_reset_timer = NULL;
#define APP_RESET_PONTPONED_TIME_IN_MS 2000
static void app_postponed_reset_timer_handler(void const *param)
{
// hal_cmu_sys_reboot();
app_reset();
}
void app_start_postponed_reset(void)
{
if (NULL == app_postponed_reset_timer)
{
app_postponed_reset_timer = osTimerCreate(osTimer(APP_POSTPONED_RESET_TIMER), osTimerOnce, NULL);
}
hal_sw_bootmode_set(HAL_SW_BOOTMODE_ENTER_HIDE_BOOT);
osTimerStart(app_postponed_reset_timer, APP_RESET_PONTPONED_TIME_IN_MS);
}
void app_bt_key_shutdown(APP_KEY_STATUS *status, void *param)
{
TRACE(3,"%s %d,%d",__func__, status->code, status->event);
#ifdef __POWERKEY_CTRL_ONOFF_ONLY__
hal_sw_bootmode_clear(HAL_SW_BOOTMODE_REBOOT);
app_reset();
#else
app_shutdown();
#endif
}
void app_bt_key_enter_testmode(APP_KEY_STATUS *status, void *param)
{
TRACE(1,"%s\n",__FUNCTION__);
if(app_status_indication_get() == APP_STATUS_INDICATION_BOTHSCAN){
#ifdef __FACTORY_MODE_SUPPORT__
app_factorymode_bt_signalingtest(status, param);
#endif
}
}
void app_bt_key_enter_nosignal_mode(APP_KEY_STATUS *status, void *param)
{
TRACE(1,"%s\n",__FUNCTION__);
if(app_status_indication_get() == APP_STATUS_INDICATION_BOTHSCAN){
#ifdef __FACTORY_MODE_SUPPORT__
app_factorymode_bt_nosignalingtest(status, param);
#endif
}
}
void app_bt_singleclick(APP_KEY_STATUS *status, void *param)
{
TRACE(3,"%s %d,%d",__func__, status->code, status->event);
}
void app_bt_doubleclick(APP_KEY_STATUS *status, void *param)
{
TRACE(3,"%s %d,%d",__func__, status->code, status->event);
}
void app_power_off(APP_KEY_STATUS *status, void *param)
{
TRACE(0,"app_power_off\n");
}
extern "C" void OS_NotifyEvm(void);
#define PRESS_KEY_TO_ENTER_OTA_INTERVEL (15000) // press key 15s enter to ota
#define PRESS_KEY_TO_ENTER_OTA_REPEAT_CNT ((PRESS_KEY_TO_ENTER_OTA_INTERVEL - 2000) / 500)
void app_otaMode_enter(APP_KEY_STATUS *status, void *param)
{
TRACE(1,"%s",__func__);
hal_norflash_disable_protection(HAL_NORFLASH_ID_0);
hal_sw_bootmode_set(HAL_SW_BOOTMODE_ENTER_HIDE_BOOT);
#ifdef __KMATE106__
app_status_indication_set(APP_STATUS_INDICATION_OTA);
app_voice_report(APP_STATUS_INDICATION_WARNING, 0);
osDelay(1200);
#endif
hal_cmu_sys_reboot();
}
#ifdef __USB_COMM__
void app_usb_cdc_comm_key_handler(APP_KEY_STATUS *status, void *param)
{
TRACE(3,"%s %d,%d", __func__, status->code, status->event);
hal_sw_bootmode_clear(HAL_SW_BOOTMODE_REBOOT);
hal_sw_bootmode_set(HAL_SW_BOOTMODE_CDC_COMM);
pmu_usb_config(PMU_USB_CONFIG_TYPE_DEVICE);
hal_cmu_reset_set(HAL_CMU_MOD_GLOBAL);
}
#endif
#if 0
void app_dfu_key_handler(APP_KEY_STATUS *status, void *param)
{
TRACE(1,"%s ",__func__);
hal_sw_bootmode_clear(HAL_SW_BOOTMODE_REBOOT);
hal_sw_bootmode_set(HAL_SW_BOOTMODE_FORCE_USB_DLD);
pmu_usb_config(PMU_USB_CONFIG_TYPE_DEVICE);
hal_cmu_reset_set(HAL_CMU_MOD_GLOBAL);
}
#else
void app_dfu_key_handler(APP_KEY_STATUS *status, void *param)
{
TRACE(1,"%s ",__func__);
hal_sw_bootmode_clear(0xffffffff);
hal_sw_bootmode_set(HAL_SW_BOOTMODE_FORCE_USB_DLD | HAL_SW_BOOTMODE_SKIP_FLASH_BOOT);
pmu_usb_config(PMU_USB_CONFIG_TYPE_DEVICE);
hal_cmu_reset_set(HAL_CMU_MOD_GLOBAL);
}
#endif
void app_ota_key_handler(APP_KEY_STATUS *status, void *param)
{
static uint32_t time = hal_sys_timer_get();
static uint16_t cnt = 0;
TRACE(3,"%s %d,%d",__func__, status->code, status->event);
if (TICKS_TO_MS(hal_sys_timer_get() - time) > 600) // 600 = (repeat key intervel)500 + (margin)100
cnt = 0;
else
cnt++;
if (cnt == PRESS_KEY_TO_ENTER_OTA_REPEAT_CNT) {
app_otaMode_enter(NULL, NULL);
}
time = hal_sys_timer_get();
}
extern "C" void app_bt_key(APP_KEY_STATUS *status, void *param)
{
TRACE(3,"%s %d,%d",__func__, status->code, status->event);
#define DEBUG_CODE_USE 0
switch(status->event)
{
case APP_KEY_EVENT_CLICK:
TRACE(0,"first blood!");
#if DEBUG_CODE_USE
if (status->code == APP_KEY_CODE_PWR)
{
#ifdef __INTERCONNECTION__
// add favorite music
// app_interconnection_handle_favorite_music_through_ccmp(1);
// ask for ota update
ota_update_request();
return;
#else
static int m = 0;
if (m == 0) {
m = 1;
hal_iomux_set_analog_i2c();
}
else {
m = 0;
hal_iomux_set_uart0();
}
#endif
}
#endif
break;
case APP_KEY_EVENT_DOUBLECLICK:
TRACE(0,"double kill");
#if DEBUG_CODE_USE
if (status->code == APP_KEY_CODE_PWR)
{
#ifdef __INTERCONNECTION__
// play favorite music
app_interconnection_handle_favorite_music_through_ccmp(2);
#else
app_otaMode_enter(NULL, NULL);
#endif
return;
}
#endif
break;
case APP_KEY_EVENT_TRIPLECLICK:
TRACE(0,"triple kill");
if (status->code == APP_KEY_CODE_PWR)
{
#ifndef __BT_ONE_BRING_TWO__
if(btif_me_get_activeCons() < 1){
#else
if(btif_me_get_activeCons() < 2){
#endif
app_bt_accessmode_set(BTIF_BT_DEFAULT_ACCESS_MODE_PAIR);
#ifdef __INTERCONNECTION__
app_interceonnection_start_discoverable_adv(INTERCONNECTION_BLE_FAST_ADVERTISING_INTERVAL,
APP_INTERCONNECTION_FAST_ADV_TIMEOUT_IN_MS);
return;
#endif
#ifdef GFPS_ENABLED
app_enter_fastpairing_mode();
#endif
app_voice_report(APP_STATUS_INDICATION_BOTHSCAN,0);
}
return;
}
break;
case APP_KEY_EVENT_ULTRACLICK:
TRACE(0,"ultra kill");
break;
case APP_KEY_EVENT_RAMPAGECLICK:
TRACE(0,"rampage kill!you are crazy!");
break;
case APP_KEY_EVENT_UP:
break;
}
#if 0//def __FACTORY_MODE_SUPPORT__
if (app_status_indication_get() == APP_STATUS_INDICATION_BOTHSCAN && (status->event == APP_KEY_EVENT_DOUBLECLICK)){
app_factorymode_languageswitch_proc();
}else
#endif
{
#ifdef __SUPPORT_ANC_SINGLE_MODE_WITHOUT_BT__
if(!anc_single_mode_on)
#endif
bt_key_send(status);
}
}
#ifdef RB_CODEC
extern bool app_rbcodec_check_hfp_active(void );
void app_switch_player_key(APP_KEY_STATUS *status, void *param)
{
TRACE(3,"%s %d,%d",__func__, status->code, status->event);
if(!rb_ctl_is_init_done()) {
TRACE(0,"rb ctl not init done");
return ;
}
if( app_rbcodec_check_hfp_active() ) {
app_bt_key(status,param);
return;
}
app_rbplay_audio_reset_pause_status();
if(app_rbplay_mode_switch()) {
app_voice_report(APP_STATUS_INDICATION_POWERON, 0);
app_rbcodec_ctr_play_onoff(true);
} else {
app_rbcodec_ctr_play_onoff(false);
app_voice_report(APP_STATUS_INDICATION_POWEROFF, 0);
}
return ;
}
#endif
void app_voice_assistant_key(APP_KEY_STATUS *status, void *param)
{
TRACE(2,"%s event %d", __func__, status->event);
#if defined(BISTO_ENABLED) || defined(__AI_VOICE__)
if (app_ai_manager_is_in_multi_ai_mode())
{
if (app_ai_manager_spec_get_status_is_in_invalid()) {
TRACE(0,"AI feature has been diabled");
return;
}
#ifdef MAI_TYPE_REBOOT_WITHOUT_OEM_APP
if (app_ai_manager_get_spec_update_flag()) {
TRACE(0,"device reboot is ongoing...");
return;
}
#endif
if (app_ai_manager_is_need_reboot())
{
TRACE(1, "%s ai need to reboot", __func__);
return;
}
if(app_ai_manager_voicekey_is_enable()) {
if (AI_SPEC_GSOUND == app_ai_manager_get_current_spec()) {
#ifdef BISTO_ENABLED
gsound_custom_actions_handle_key(status, param);
#endif
} else if(AI_SPEC_INIT != app_ai_manager_get_current_spec()) {
app_ai_key_event_handle(status, 0);
}
}
}
else
{
app_ai_key_event_handle(status, 0);
#if defined(BISTO_ENABLED)
gsound_custom_actions_handle_key(status, param);
#endif
}
#endif
}
#ifdef IS_MULTI_AI_ENABLED
void app_voice_gva_onoff_key(APP_KEY_STATUS *status, void *param)
{
uint8_t current_ai_spec = app_ai_manager_get_current_spec();
TRACE(2,"%s current_ai_spec %d", __func__, current_ai_spec);
if (current_ai_spec == AI_SPEC_INIT)
{
app_ai_manager_enable(true, AI_SPEC_GSOUND);
}
else if(current_ai_spec == AI_SPEC_GSOUND)
{
app_ai_manager_enable(false, AI_SPEC_GSOUND);
}
else if(current_ai_spec == AI_SPEC_AMA)
{
app_ai_manager_switch_spec(AI_SPEC_GSOUND);
}
app_ble_refresh_adv_state(BLE_ADVERTISING_INTERVAL);
}
void app_voice_ama_onoff_key(APP_KEY_STATUS *status, void *param)
{
uint8_t current_ai_spec = app_ai_manager_get_current_spec();
TRACE(2,"%s current_ai_spec %d", __func__, current_ai_spec);
if (current_ai_spec == AI_SPEC_INIT)
{
app_ai_manager_enable(true, AI_SPEC_AMA);
}
else if(current_ai_spec == AI_SPEC_AMA)
{
app_ai_manager_enable(false, AI_SPEC_AMA);
}
else if(current_ai_spec == AI_SPEC_GSOUND)
{
app_ai_manager_switch_spec(AI_SPEC_AMA);
}
app_ble_refresh_adv_state(BLE_ADVERTISING_INTERVAL);
}
#endif
#if defined(BT_USB_AUDIO_DUAL_MODE_TEST) && defined(BT_USB_AUDIO_DUAL_MODE)
extern "C" void test_btusb_switch(void);
void app_btusb_audio_dual_mode_test(APP_KEY_STATUS *status, void *param)
{
TRACE(0,"test_btusb_switch");
test_btusb_switch();
}
#endif
extern void switch_dualmic_status(void);
void app_switch_dualmic_key(APP_KEY_STATUS *status, void *param)
{
switch_dualmic_status();
}
#ifdef POWERKEY_I2C_SWITCH
extern void app_factorymode_i2c_switch(APP_KEY_STATUS *status, void *param);
#endif
#ifdef TILE_DATAPATH
extern "C" void app_tile_key_handler(APP_KEY_STATUS *status, void *param);
#endif
#ifdef __POWERKEY_CTRL_ONOFF_ONLY__
#if defined(__APP_KEY_FN_STYLE_A__)
const APP_KEY_HANDLE app_key_handle_cfg[] = {
{{APP_KEY_CODE_PWR,APP_KEY_EVENT_UP},"bt function key",app_bt_key_shutdown, NULL},
{{APP_KEY_CODE_FN1,APP_KEY_EVENT_LONGPRESS},"bt function key",app_bt_key, NULL},
{{APP_KEY_CODE_FN1,APP_KEY_EVENT_UP},"bt function key",app_bt_key, NULL},
{{APP_KEY_CODE_FN1,APP_KEY_EVENT_DOUBLECLICK},"bt function key",app_bt_key, NULL},
{{APP_KEY_CODE_FN2,APP_KEY_EVENT_UP},"bt volume up key",app_bt_key, NULL},
{{APP_KEY_CODE_FN2,APP_KEY_EVENT_LONGPRESS},"bt play backward key",app_bt_key, NULL},
{{APP_KEY_CODE_FN3,APP_KEY_EVENT_UP},"bt volume down key",app_bt_key, NULL},
{{APP_KEY_CODE_FN3,APP_KEY_EVENT_LONGPRESS},"bt play forward key",app_bt_key, NULL},
#ifdef SUPPORT_SIRI
{{APP_KEY_CODE_NONE ,APP_KEY_EVENT_NONE},"none function key",app_bt_key, NULL},
#endif
};
#else //#elif defined(__APP_KEY_FN_STYLE_B__)
const APP_KEY_HANDLE app_key_handle_cfg[] = {
{{APP_KEY_CODE_PWR,APP_KEY_EVENT_UP},"bt function key",app_bt_key_shutdown, NULL},
{{APP_KEY_CODE_FN1,APP_KEY_EVENT_LONGPRESS},"bt function key",app_bt_key, NULL},
{{APP_KEY_CODE_FN1,APP_KEY_EVENT_UP},"bt function key",app_bt_key, NULL},
{{APP_KEY_CODE_FN1,APP_KEY_EVENT_DOUBLECLICK},"bt function key",app_bt_key, NULL},
{{APP_KEY_CODE_FN2,APP_KEY_EVENT_REPEAT},"bt volume up key",app_bt_key, NULL},
{{APP_KEY_CODE_FN2,APP_KEY_EVENT_UP},"bt play backward key",app_bt_key, NULL},
{{APP_KEY_CODE_FN3,APP_KEY_EVENT_REPEAT},"bt volume down key",app_bt_key, NULL},
{{APP_KEY_CODE_FN3,APP_KEY_EVENT_UP},"bt play forward key",app_bt_key, NULL},
#ifdef SUPPORT_SIRI
{{APP_KEY_CODE_NONE ,APP_KEY_EVENT_NONE},"none function key",app_bt_key, NULL},
#endif
};
#endif
#else
#if defined(__APP_KEY_FN_STYLE_A__)
//--
const APP_KEY_HANDLE app_key_handle_cfg[] = {
{{APP_KEY_CODE_PWR,APP_KEY_EVENT_LONGLONGPRESS},"bt function key",app_bt_key_shutdown, NULL},
{{APP_KEY_CODE_PWR,APP_KEY_EVENT_LONGPRESS},"bt function key",app_bt_key, NULL},
#if defined(BT_USB_AUDIO_DUAL_MODE_TEST) && defined(BT_USB_AUDIO_DUAL_MODE)
{{APP_KEY_CODE_PWR,APP_KEY_EVENT_CLICK},"bt function key",app_bt_key, NULL},
#ifdef RB_CODEC
{{APP_KEY_CODE_PWR,APP_KEY_EVENT_CLICK},"bt function key",app_switch_player_key, NULL},
#else
//{{APP_KEY_CODE_PWR,APP_KEY_EVENT_CLICK},"btusb mode switch key.",app_btusb_audio_dual_mode_test, NULL},
#endif
#endif
{{APP_KEY_CODE_PWR,APP_KEY_EVENT_DOUBLECLICK},"bt function key",app_bt_key, NULL},
#ifdef TILE_DATAPATH
{{APP_KEY_CODE_PWR,APP_KEY_EVENT_TRIPLECLICK},"bt function key",app_tile_key_handler, NULL},
#else
{{APP_KEY_CODE_PWR,APP_KEY_EVENT_TRIPLECLICK},"bt function key",app_bt_key, NULL},
#endif
#if RAMPAGECLICK_TEST_MODE
{{APP_KEY_CODE_PWR,APP_KEY_EVENT_ULTRACLICK},"bt function key",app_bt_key_enter_nosignal_mode, NULL},
{{APP_KEY_CODE_PWR,APP_KEY_EVENT_RAMPAGECLICK},"bt function key",app_bt_key_enter_testmode, NULL},
#endif
#ifdef POWERKEY_I2C_SWITCH
{{APP_KEY_CODE_PWR,APP_KEY_EVENT_RAMPAGECLICK},"bt i2c key",app_factorymode_i2c_switch, NULL},
#endif
//{{APP_KEY_CODE_FN1,APP_KEY_EVENT_UP},"bt volume up key",app_bt_key, NULL},
//{{APP_KEY_CODE_FN1,APP_KEY_EVENT_LONGPRESS},"bt play backward key",app_bt_key, NULL},
#if defined(APP_LINEIN_A2DP_SOURCE)||defined(APP_I2S_A2DP_SOURCE)
{{APP_KEY_CODE_FN1,APP_KEY_EVENT_DOUBLECLICK},"bt mode src snk key",app_bt_key, NULL},
#endif
//{{APP_KEY_CODE_FN2,APP_KEY_EVENT_UP},"bt volume down key",app_bt_key, NULL},
//{{APP_KEY_CODE_FN2,APP_KEY_EVENT_LONGPRESS},"bt play forward key",app_bt_key, NULL},
//{{APP_KEY_CODE_FN15,APP_KEY_EVENT_UP},"bt volume down key",app_bt_key, NULL},
{{APP_KEY_CODE_PWR,APP_KEY_EVENT_CLICK},"bt function key",app_bt_key, NULL},
#ifdef SUPPORT_SIRI
{{APP_KEY_CODE_NONE ,APP_KEY_EVENT_NONE},"none function key",app_bt_key, NULL},
#endif
#if defined( __BT_ANC_KEY__)&&defined(ANC_APP)
#if defined(IBRT)
{{APP_KEY_CODE_PWR,APP_KEY_EVENT_CLICK},"bt anc key",app_anc_key, NULL},
#else
{{APP_KEY_CODE_FN2,APP_KEY_EVENT_CLICK},"bt anc key",app_anc_key, NULL},
#endif
#endif
#ifdef TILE_DATAPATH
{{APP_KEY_CODE_TILE, APP_KEY_EVENT_DOWN}, "tile function key", app_tile_key_handler, NULL},
{{APP_KEY_CODE_TILE, APP_KEY_EVENT_UP}, "tile function key", app_tile_key_handler, NULL},
#endif
#if defined(VOICE_DATAPATH) || defined(__AI_VOICE__)
{{APP_KEY_CODE_GOOGLE, APP_KEY_EVENT_FIRST_DOWN}, "google assistant key", app_voice_assistant_key, NULL},
#if defined(IS_GSOUND_BUTTION_HANDLER_WORKAROUND_ENABLED) || defined(PUSH_AND_HOLD_ENABLED) || defined(__TENCENT_VOICE__)
{{APP_KEY_CODE_GOOGLE, APP_KEY_EVENT_UP}, "google assistant key", app_voice_assistant_key, NULL},
#endif
{{APP_KEY_CODE_GOOGLE, APP_KEY_EVENT_UP_AFTER_LONGPRESS}, "google assistant key", app_voice_assistant_key, NULL},
{{APP_KEY_CODE_GOOGLE, APP_KEY_EVENT_LONGPRESS}, "google assistant key", app_voice_assistant_key, NULL},
{{APP_KEY_CODE_GOOGLE, APP_KEY_EVENT_CLICK}, "google assistant key", app_voice_assistant_key, NULL},
{{APP_KEY_CODE_GOOGLE, APP_KEY_EVENT_DOUBLECLICK}, "google assistant key", app_voice_assistant_key, NULL},
#endif
#ifdef IS_MULTI_AI_ENABLED
{{APP_KEY_CODE_FN13, APP_KEY_EVENT_CLICK}, "gva on-off key", app_voice_gva_onoff_key, NULL},
{{APP_KEY_CODE_FN14, APP_KEY_EVENT_CLICK}, "ama on-off key", app_voice_ama_onoff_key, NULL},
#endif
#if defined(BT_USB_AUDIO_DUAL_MODE_TEST) && defined(BT_USB_AUDIO_DUAL_MODE)
{{APP_KEY_CODE_FN15, APP_KEY_EVENT_CLICK}, "btusb mode switch key.", app_btusb_audio_dual_mode_test, NULL},
#endif
};
#else //#elif defined(__APP_KEY_FN_STYLE_B__)
const APP_KEY_HANDLE app_key_handle_cfg[] = {
{{APP_KEY_CODE_PWR,APP_KEY_EVENT_LONGLONGPRESS},"bt function key",app_bt_key_shutdown, NULL},
{{APP_KEY_CODE_PWR,APP_KEY_EVENT_LONGPRESS},"bt function key",app_bt_key, NULL},
{{APP_KEY_CODE_PWR,APP_KEY_EVENT_CLICK},"bt function key",app_bt_key, NULL},
{{APP_KEY_CODE_PWR,APP_KEY_EVENT_DOUBLECLICK},"bt function key",app_bt_key, NULL},
{{APP_KEY_CODE_PWR,APP_KEY_EVENT_TRIPLECLICK},"bt function key",app_bt_key, NULL},
{{APP_KEY_CODE_PWR,APP_KEY_EVENT_ULTRACLICK},"bt function key",app_bt_key_enter_nosignal_mode, NULL},
{{APP_KEY_CODE_PWR,APP_KEY_EVENT_RAMPAGECLICK},"bt function key",app_bt_key_enter_testmode, NULL},
{{APP_KEY_CODE_FN1,APP_KEY_EVENT_REPEAT},"bt volume up key",app_bt_key, NULL},
{{APP_KEY_CODE_FN1,APP_KEY_EVENT_UP},"bt play backward key",app_bt_key, NULL},
{{APP_KEY_CODE_FN2,APP_KEY_EVENT_REPEAT},"bt volume down key",app_bt_key, NULL},
{{APP_KEY_CODE_FN2,APP_KEY_EVENT_UP},"bt play forward key",app_bt_key, NULL},
#ifdef SUPPORT_SIRI
{{APP_KEY_CODE_NONE ,APP_KEY_EVENT_NONE},"none function key",app_bt_key, NULL},
#endif
{{APP_KEY_CODE_GOOGLE, APP_KEY_EVENT_FIRST_DOWN}, "google assistant key", app_voice_assistant_key, NULL},
#if defined(IS_GSOUND_BUTTION_HANDLER_WORKAROUND_ENABLED) || defined(PUSH_AND_HOLD_ENABLED)
{{APP_KEY_CODE_GOOGLE, APP_KEY_EVENT_UP}, "google assistant key", app_voice_assistant_key, NULL},
#endif
{{APP_KEY_CODE_GOOGLE, APP_KEY_EVENT_UP_AFTER_LONGPRESS}, "google assistant key", app_voice_assistant_key, NULL},
{{APP_KEY_CODE_GOOGLE, APP_KEY_EVENT_LONGPRESS}, "google assistant key", app_voice_assistant_key, NULL},
{{APP_KEY_CODE_GOOGLE, APP_KEY_EVENT_CLICK}, "google assistant key", app_voice_assistant_key, NULL},
{{APP_KEY_CODE_GOOGLE, APP_KEY_EVENT_DOUBLECLICK}, "google assistant key", app_voice_assistant_key, NULL},
};
#endif
#endif
extern struct BT_DEVICE_T app_bt_device;
extern uint8_t avrcp_get_media_status(void);
/******************************delay_report_tone_timer*********************************************************/
APP_STATUS_INDICATION_T delay_report_tone_num = APP_STATUS_INDICATION_NUM;
osTimerId delay_report_toneid = NULL;
void startdelay_report_tone(int ms,APP_STATUS_INDICATION_T status);
void stopdelay_report_tone(void);
static void delay_report_tonefun(const void *);
osTimerDef(defdelay_report_tone,delay_report_tonefun);
void delay_report_toneinit(void)
{
delay_report_toneid = osTimerCreate(osTimer(defdelay_report_tone),osTimerOnce,(void *)0);
}
static void delay_report_tonefun(const void *)
{
TRACE(3,"\n\n!!!!!!enter %s,delay_report_tone_num = %d \n\n",__func__,delay_report_tone_num);
if(MobileLinkLose_reboot){
return;
}
//static ibrt_ctrl_t *p_ibrt_ctrl = app_tws_ibrt_get_bt_ctrl_ctx();
//uint8_t default_mobileaddr[6] = {0x0,0x0,0x0,0x0,0x0,0x0};
//DUMP8("%02x ", p_ibrt_ctrl->mobile_addr.address, 6);
//app_status_indication_set(APP_STATUS_INDICATION_TWS_CONNECTED);
if(Curr_Is_Master()){
app_ibrt_sync_volume_info();
}
if(delay_report_tone_num == APP_STATUS_INDICATION_DUDU){
if(Curr_Is_Master()&&(avrcp_get_media_status() != 1)&&(app_bt_device.hfchan_call[BT_DEVICE_ID_1] == BTIF_HF_CALL_NONE)){
app_voice_report(delay_report_tone_num,0);
/*if((!memcmp(default_mobileaddr,p_ibrt_ctrl->mobile_addr.address,6))&&(p_ibrt_ctrl->access_mode == 0x3)){
TRACE(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA");
app_voice_report(APP_STATUS_INDICATION_BOTHSCAN,0);
}*/
if((nv_record_get_paired_dev_count()==1)){
app_voice_report(APP_STATUS_INDICATION_BOTHSCAN,0);
}
}
}
delay_report_tone_num = APP_STATUS_INDICATION_NUM;
}
void startdelay_report_tone(int ms,APP_STATUS_INDICATION_T status)
{
TRACE(3,"\n\n !!!!!!!!!!start %s\n\n",__func__);
delay_report_tone_num = status;
osTimerStart(delay_report_toneid,ms);
}
/********************************delay_report_tone_timer*******************************************************/
/******************************low_latlatency_delay_switch_timer*********************************************************/
uint8_t latency_mode_is_open = false;
osTimerId low_latlatency_delay_switchid = NULL;
void startlow_latlatency_delay_switch(int ms);
void stoplow_latlatency_delay_switch(void);
static void low_latlatency_delay_switchfun(const void *);
osTimerDef(deflow_latlatency_delay_switch,low_latlatency_delay_switchfun);
void low_latlatency_delay_switchinit(void)
{
low_latlatency_delay_switchid = osTimerCreate(osTimer(deflow_latlatency_delay_switch),osTimerOnce,(void *)0);
}
void app_ibrt_ui_test_mtu_change_sync_notify(void)
{
extern volatile uint8_t avdtp_playback_delay_sbc_mtu;
extern volatile uint8_t avdtp_playback_delay_aac_mtu;
TRACE(3,"SWITC GAME MODE !!!latency_mode_is_open = %d###",latency_mode_is_open);
if(!latency_mode_is_open)
{
avdtp_playback_delay_sbc_mtu = 32;
avdtp_playback_delay_aac_mtu = 3;
app_ibrt_if_force_audio_retrigger_slave_sync();
}
else
{
avdtp_playback_delay_sbc_mtu = 50;
avdtp_playback_delay_aac_mtu = 6;
app_ibrt_if_force_audio_retrigger_slave_sync();
}
latency_mode_is_open = !latency_mode_is_open;
TRACE(3,"set SBC_MTU=%d AAC_MTU=%d\n", avdtp_playback_delay_sbc_mtu, avdtp_playback_delay_aac_mtu);
}
static void low_latlatency_delay_switchfun(const void *)
{
extern volatile uint8_t avdtp_playback_delay_sbc_mtu;
extern volatile uint8_t avdtp_playback_delay_aac_mtu;
latency_mode_is_open = !latency_mode_is_open;
if(latency_mode_is_open){
avdtp_playback_delay_sbc_mtu = 32;
avdtp_playback_delay_aac_mtu = 3;
TRACE(3,"%s latency_mode_is_open!!",__func__);
}else{
avdtp_playback_delay_sbc_mtu = 50;
avdtp_playback_delay_aac_mtu = 6;
TRACE(3,"%s latency_mode_is_close!!",__func__);
}
app_ibrt_if_force_audio_retrigger();
app_ibrt_customif_test3_cmd_send(&latency_mode_is_open,1);
}
void startlow_latlatency_delay_switch(int ms)
{
osTimerStart(low_latlatency_delay_switchid,ms);
}
void stoplow_latlatency_delay_switch(void)
{
osTimerStop(low_latlatency_delay_switchid);
}
/********************************low_latlatency_delay_switch_timer*******************************************************/
void app_latency_switch_key_handler(void)
{
if((btif_me_get_activeCons() > 0)&&(app_bt_device.hfchan_call[BT_DEVICE_ID_1] == BTIF_HF_CALL_NONE)&&(app_bt_device.hfchan_callSetup[BT_DEVICE_ID_1] == BTIF_HF_CALL_SETUP_NONE))
{
if(latency_mode_is_open){
app_voice_report(APP_STATUS_INDICATION_ALEXA_STOP,0);//close latlatency mode
}else{
app_voice_report(APP_STATUS_INDICATION_ALEXA_START,0);//close latlatency mode
}
startlow_latlatency_delay_switch(1500);
}
}
Reworking touch controls Part 1 Working: Play pause Previous/Next Single or paired bud mode
2022-12-29 06:16:34 -06:00
/*
* handling of touch events when the devices are turned on
* Both pods active:
* Right Ear:
* Single tap : Play/Pause
* Double tap : Next track
* Hold : Fast-Forward
* Triple tap : Volume Up
*
* Left Ear:
* Single tap : Play/Pause
* Double tap : Previous track
* Hold : Rewind
* Triple tap : Volume Down
* Single pod active:
* Single tap : Play/Pause
* Double tap : Next track
* Hold : Previous track
* Triple tap : Volume Up
* Quad tap : Volume Down
* We use app_ibrt_if_start_user_action for handling actions, as this will apply locally if we are link master
* OR send it over the link to the other bud if we are not
*/
void send_vol_up(void){
uint8_t action[] = {IBRT_ACTION_AVRCP_VOLUP};
app_ibrt_if_start_user_action(action, sizeof(action));
}
void send_play_pause(void){
if (app_bt_device.a2dp_play_pause_flag!=0) {
uint8_t action[] = {IBRT_ACTION_PAUSE};
app_ibrt_if_start_user_action(action, sizeof(action));
}else {
uint8_t action[] = {IBRT_ACTION_PLAY};
app_ibrt_if_start_user_action(action, sizeof(action));
}
}
void send_vol_down(void){
uint8_t action[] = {IBRT_ACTION_AVRCP_VOLDN};
app_ibrt_if_start_user_action(action, sizeof(action));
}
void send_next_track(void){
uint8_t action[] = {IBRT_ACTION_FORWARD};
app_ibrt_if_start_user_action(action, sizeof(action));
}
void send_prev_track(void){
uint8_t action[] = {IBRT_ACTION_BACKWARD};
app_ibrt_if_start_user_action(action, sizeof(action));
}
void app_key_single_tap(APP_KEY_STATUS *status, void *param){
TRACE(2,"%s event %d", __func__, status->event);
if (!app_tws_ibrt_tws_link_connected()){
//No other bud paired
TRACE(0,"Handling %s in single bud mode",__func__);
send_play_pause();
}else {
//Bud's are working as a pair
if (app_tws_is_left_side()){
TRACE(0,"Handling %s as left bud",__func__);
//Lefty
send_play_pause();
}else {
TRACE(0,"Handling %s as right bud",__func__);
//Righty
send_play_pause();
}
}
}
void app_key_double_tap(APP_KEY_STATUS *status, void *param){
TRACE(2,"%s event %d", __func__, status->event);
if (!app_tws_ibrt_tws_link_connected()){
//No other bud paired
TRACE(0,"Handling %s in single bud mode",__func__);
send_next_track();
}else {
//Bud's are working as a pair
if (app_tws_is_left_side()){
TRACE(0,"Handling %s as left bud",__func__);
//Lefty
send_prev_track();
}else {
TRACE(0,"Handling %s as right bud",__func__);
//Righty
send_next_track();
}
}
}
void app_key_hold_tap(APP_KEY_STATUS *status, void *param){
TRACE(2,"%s event %d", __func__, status->event);
if (!app_tws_ibrt_tws_link_connected()){
//No other bud paired
TRACE(0,"Handling %s in single bud mode",__func__);
send_play_pause();
}else {
//Bud's are working as a pair
if (app_tws_is_left_side()){
TRACE(0,"Handling %s as left bud",__func__);
//Lefty
send_play_pause();
}else {
TRACE(0,"Handling %s as right bud",__func__);
//Righty
send_play_pause();
}
}
}
void app_key_triple_tap(APP_KEY_STATUS *status, void *param){
Add custom button actions
2022-12-25 00:32:05 -06:00
TRACE(2,"%s event %d", __func__, status->event);
Reworking touch controls Part 1 Working: Play pause Previous/Next Single or paired bud mode
2022-12-29 06:16:34 -06:00
if (!app_tws_ibrt_tws_link_connected()){
//No other bud paired
TRACE(0,"Handling %s in single bud mode",__func__);
send_vol_up();
}else {
//Bud's are working as a pair
if (app_tws_is_left_side()){
TRACE(0,"Handling %s as left bud",__func__);
//Lefty
send_vol_down();
}else {
TRACE(0,"Handling %s as right bud",__func__);
//Righty
send_vol_up();
}
}
}
void app_key_quad_tap(APP_KEY_STATUS *status, void *param){
TRACE(2,"%s event %d", __func__, status->event);
if (!app_tws_ibrt_tws_link_connected()){
//No other bud paired
TRACE(0,"Handling %s in single bud mode",__func__);
send_vol_down();
}else {
//Bud's are working as a pair
if (app_tws_is_left_side()){
TRACE(0,"Handling %s as left bud",__func__);
//Lefty
}else {
TRACE(0,"Handling %s as right bud",__func__);
//Righty
}
}
}
void app_key_reboot(APP_KEY_STATUS *status, void *param)
{
TRACE(1,"%s ",__func__);
hal_cmu_sys_reboot();
Add custom button actions
2022-12-25 00:32:05 -06:00
}
add first commit
2022-08-15 04:20:27 -05:00
void app_key_init(void)
{
uint8_t i = 0;
TRACE(1,"%s",__func__);
Add custom button actions
2022-12-25 00:32:05 -06:00
const APP_KEY_HANDLE key_cfg[] = {
Reworking touch controls Part 1 Working: Play pause Previous/Next Single or paired bud mode
2022-12-29 06:16:34 -06:00
{{APP_KEY_CODE_PWR,APP_KEY_EVENT_CLICK},"",app_key_single_tap, NULL},
{{APP_KEY_CODE_PWR,APP_KEY_EVENT_DOUBLECLICK},"",app_key_double_tap, NULL},
{{APP_KEY_CODE_PWR,APP_KEY_EVENT_TRIPLECLICK},"",app_key_triple_tap, NULL},
{{APP_KEY_CODE_PWR,APP_KEY_EVENT_ULTRACLICK},"",app_key_quad_tap, NULL},
// {{APP_KEY_CODE_PWR,APP_KEY_EVENT_CONTINUED_DOWN},"",app_key_hold_tap, NULL},
// {{APP_KEY_CODE_PWR,APP_KEY_EVENT_LONGPRESS},"",app_key_hold_tap, NULL},
// {{APP_KEY_CODE_PWR,APP_KEY_EVENT_TRIPLECLICK},"bt anc key",app_anc_key, NULL},
{{APP_KEY_CODE_PWR,APP_KEY_EVENT_LONGLONGPRESS},"long click reboot",app_key_reboot, NULL},
Add custom button actions
2022-12-25 00:32:05 -06:00
};
add first commit
2022-08-15 04:20:27 -05:00
app_key_handle_clear();
Add custom button actions
2022-12-25 00:32:05 -06:00
for (i=0; i<(sizeof(key_cfg)/sizeof(APP_KEY_HANDLE)); i++){
app_key_handle_registration(&key_cfg[i]);
add first commit
2022-08-15 04:20:27 -05:00
}
Long press in charge case to reboot
2022-12-28 03:42:06 -06:00
}
add first commit
2022-08-15 04:20:27 -05:00
void app_key_init_on_charging(void)
{
uint8_t i = 0;
const APP_KEY_HANDLE key_cfg[] = {
Long press in charge case to reboot
2022-12-28 03:42:06 -06:00
{{APP_KEY_CODE_PWR,APP_KEY_EVENT_LONGLONGPRESS},"long press reboot",app_key_reboot, NULL},
Prevent touching buds during charge putting us into DFU
2022-12-28 01:18:13 -06:00
// {{APP_KEY_CODE_PWR,APP_KEY_EVENT_CLICK},"bt function key",app_dfu_key_handler, NULL},
add first commit
2022-08-15 04:20:27 -05:00
#ifdef __USB_COMM__
{{APP_KEY_CODE_PWR,APP_KEY_EVENT_LONGPRESS},"usb cdc key",app_usb_cdc_comm_key_handler, NULL},
#endif
};
TRACE(1,"%s",__func__);
for (i=0; i<(sizeof(key_cfg)/sizeof(APP_KEY_HANDLE)); i++){
app_key_handle_registration(&key_cfg[i]);
}
}
void stopAuto_Shutdowm_Timer(void);
bool MobileLinkLose_reboot = false;
bool IsMobileLinkLossing = FALSE;
bool IsTwsLinkLossing = FALSE;
bool enterpairing_flag = false;
bool IsTwsLinkdiscon = false;
bool reconnect_fail_fail_flag= false;
static void app_enterpairing_timehandler(void const *param);
osTimerDef (APP_ENTERPAIRING_TIMER, app_enterpairing_timehandler);
static osTimerId enterpairing_timer = NULL;
static void app_enterpairing_timehandler(void const *param)
{
static ibrt_ctrl_t *p_ibrt_ctrl = app_tws_ibrt_get_bt_ctrl_ctx();
static app_ibrt_ui_t *p_ui_ctrl = app_ibrt_ui_get_ctx();
TRACE(3,"xqd log --%s\n", __func__);
TRACE(3,"MyLog: is_tws_con = %d, nv_role = 0x%x", app_tws_ibrt_tws_link_connected(), p_ibrt_ctrl->nv_role);
reconnect_fail_fail_flag = true;
enterpairing_flag = false;
if(IsMobileLinkLossing)
{
TRACE(3,"xqd---log:return evt 0!!!\n");
return;
}
if(p_ui_ctrl->box_state == IBRT_IN_BOX_CLOSED){
TRACE(3,"xqd---log:return evt 1!!!\n");
return;
}
if((app_battery_is_charging())||((app_device_bt_is_connected())&&(app_tws_ibrt_mobile_link_connected())&&(app_tws_ibrt_mobile_link_connected())))return;
if (app_tws_ibrt_mobile_link_connected() || app_tws_ibrt_slave_ibrt_link_connected()) {
TRACE(3,"xqd---log:return evt 2!!!\n");
return;
}
if (app_ibrt_ui_get_enter_pairing_mode()) {
TRACE(3,"xqd---log:return evt 3!!!\n");
if((IBRT_UNKNOW != p_ibrt_ctrl->nv_role)&&(nv_record_get_paired_dev_count()>=2)){
app_voice_report(APP_STATUS_INDICATION_BOTHSCAN,0);
}
app_status_indication_set(APP_STATUS_INDICATION_BOTHSCAN);
return;
}
if(app_tws_ibrt_tws_link_connected() && (p_ibrt_ctrl->current_role == IBRT_MASTER))
{
TRACE(3,"xqd---log:return evt 4!!!\n");
//p_ui_ctrl->config.enter_pairing_on_reconnect_mobile_failed = true;
//p_ui_ctrl->config.nv_slave_enter_pairing_on_mobile_disconnect = true;
//app_ibrt_if_enter_freeman_pairing();
//app_ibrt_if_enter_pairing_after_tws_connected();
app_ibrt_ui_set_enter_pairing_mode(IBRT_CONNECT_MOBILE_FAILED);
app_ibrt_ui_judge_scan_type(IBRT_CONNECTE_TRIGGER,MOBILE_LINK, 0);
app_voice_report(APP_STATUS_INDICATION_BOTHSCAN,0);
}
else if ((!app_tws_ibrt_tws_link_connected()) && (p_ibrt_ctrl->nv_role == IBRT_MASTER)&&(p_ibrt_ctrl->access_mode != 0x3))
{
TRACE(3,"xqd---log:return evt 5!!!\n");
app_ibrt_ui_set_enter_pairing_mode(IBRT_CONNECT_MOBILE_FAILED);
app_ibrt_ui_judge_scan_type(IBRT_CONNECTE_TRIGGER,MOBILE_LINK, 0);
app_voice_report(APP_STATUS_INDICATION_BOTHSCAN,0);
}
else if((!app_tws_ibrt_tws_link_connected()) && (p_ibrt_ctrl->nv_role == IBRT_SLAVE))
{
app_ibrt_ui_set_enter_pairing_mode(IBRT_CONNECT_MOBILE_FAILED);
app_ibrt_ui_judge_scan_type(IBRT_CONNECTE_TRIGGER, MOBILE_LINK, 0);
app_voice_report(APP_STATUS_INDICATION_BOTHSCAN,0);
}
}
void app_enterpairing_timer_start(void)
{
static ibrt_ctrl_t *p_ibrt_ctrl = app_tws_ibrt_get_bt_ctrl_ctx();
TRACE(3,"xqd log --app_enterpairing_timer_start, enterpairing_flag = %d,nv_role = %d\n", enterpairing_flag,p_ibrt_ctrl->nv_role);
if(p_ibrt_ctrl->nv_role == IBRT_UNKNOW)return;
enterpairing_flag = true;
osTimerStop(enterpairing_timer);
osTimerStart(enterpairing_timer, 11000);
}
void app_enterpairing_timer_stop(void)
{
TRACE(3,"xqd log --app_enterpairing_timer_stop\n");
if(enterpairing_flag)
osTimerStop(enterpairing_timer);
}
void app_enterpairing_timer_open(void)
{
if(NULL == enterpairing_timer)
{
enterpairing_timer = osTimerCreate (osTimer(APP_ENTERPAIRING_TIMER), osTimerOnce, (void *)0);
}
}
extern bool IsMobileLinkLossing;
extern bool IsTwsLinkLossing;
bool LINKLOSE_REBOOT_ENABLE = false;
osTimerId Auto_Shutdowm_Timerid = NULL;
void startAuto_Shutdowm_Timer(int ms);
static void Auto_Shutdowm_Timerfun(const void *);
osTimerDef(defAuto_Shutdowm_Timer,Auto_Shutdowm_Timerfun);
void Auto_Shutdowm_Timerinit(void)
{
Auto_Shutdowm_Timerid = osTimerCreate(osTimer(defAuto_Shutdowm_Timer),osTimerPeriodic,(void *)0);
startAuto_Shutdowm_Timer(5000);
}
extern struct btdevice_volume *btdevice_volume_p;
static void Auto_Shutdowm_Timerfun(const void *)
{
static uint32_t auto_shutdown_cnt = 0;
static ibrt_ctrl_t *p_ibrt_ctrl = app_tws_ibrt_get_bt_ctrl_ctx();
static app_ibrt_ui_t *p_ui_ctrl = app_ibrt_ui_get_ctx();
struct nvrecord_env_t *nvrecord_env;
nv_record_env_get(&nvrecord_env);
static uint8_t trace_cnt = 0;
APP_BATTERY_MV_T currvolt =0;
//static uint8_t charge_full_timeout_cnt = 0;
trace_cnt ++;
if(trace_cnt >= 2){
trace_cnt = 0;
/*
TRACE(0,"xqd---log:curr_role = %d,nv_role = %d,box_state = %d,access_mode = %d,channel = %d",p_ibrt_ctrl->current_role,p_ibrt_ctrl->nv_role,p_ui_ctrl->box_state,p_ibrt_ctrl->access_mode,tgt_tws_get_channel_is_right());
TRACE(0,"curr_avrcp_status = %d£¬localbat = %d,slave_bat = %d",avrcp_get_media_status(),p_ibrt_ctrl->local_battery_volt,p_ibrt_ctrl->peer_battery_volt);
TRACE(0,"a2dp vol : %d", btdevice_volume_p->a2dp_vol);
// TRACE(0,"hfp vol: %d", btdevice_volume_p->hfp_vol);
TRACE(0,"qxw---nv_ibrt_mode addr:");
DUMP8("0x%x ", nvrecord_env->ibrt_mode.record.bdAddr.address, 6);
TRACE(0,"qxw---peer addr:");
DUMP8("%02x ", p_ibrt_ctrl->peer_addr.address, 6);
TRACE(0,"qxw---local addr:");
DUMP8("%02x ", p_ibrt_ctrl->local_addr.address, 6);
TRACE(0,"qxw---nv_master addr:");
DUMP8("%02x ", nvrecord_env->master_bdaddr.address, 6);
TRACE(0,"qxw---nv_slave addr:");
DUMP8("%02x ", nvrecord_env->slave_bdaddr.address, 6);*/
//TRACE(2,"charge_gpio statu:%d,chargefull_gpio statu:%d,curr_charge status = %d!",hal_gpio_pin_get_val((enum HAL_GPIO_PIN_T)cfg_hw_charge_indication_cfg.pin),hal_gpio_pin_get_val((enum HAL_GPIO_PIN_T)cfg_hw_charge_full_indication_cfg.pin),app_battery_is_charging());
}
//TRACE(3,"GIOI25 = %d,charge sta = %d!!!!!",hal_gpio_pin_get_val((enum HAL_GPIO_PIN_T)app_battery_charger_full_indicator_cfg.pin),app_battery_is_charging());
if(app_battery_is_charging()){
if((p_ui_ctrl->box_state != IBRT_IN_BOX_CLOSED)){
app_ibrt_ui_event_entry(IBRT_CLOSE_BOX_EVENT);
}
}
app_battery_get_info(&currvolt, NULL, NULL);
if(p_ui_ctrl->box_state == IBRT_OUT_BOX){
if(app_device_bt_is_connected())
{
IsMobileLinkLossing = FALSE;
IsTwsLinkLossing = FALSE;
MobileLinkLose_reboot = FALSE;
}
if((!app_device_bt_is_connected())&& p_ibrt_ctrl->current_role != BTIF_BCR_SLAVE)
{
auto_shutdown_cnt++;
if(auto_shutdown_cnt == Auto_Shutdowm_TIME/5)
{
TRACE(0,"xqd---shutdown!!@@@@@@!!");
auto_shutdown_cnt = 0;
app_bt_power_off_customize();
}
}
else
{
auto_shutdown_cnt = 0;
}
/*if((auto_shutdown_cnt % 4 == 0)&&(MobileLinkLose_reboot)&&(!app_qxw_bt_is_connected())&&(p_ibrt_ctrl->current_role != BTIF_BCR_SLAVE)){
app_ibrt_if_event_entry(IBRT_PHONE_CONNECT_EVENT);
}*/
}else{
auto_shutdown_cnt = 0;
}
#if(QXW_TOUCH_INEAR_DET)
last_tws_con_status = app_tws_ibrt_tws_link_connected();
#endif
}
void startAuto_Shutdowm_Timer(int ms)
{
osTimerStart(Auto_Shutdowm_Timerid,ms);
}
void stopAuto_Shutdowm_Timer(void)
{
TRACE(0,"%s",__func__);
osTimerStop(Auto_Shutdowm_Timerid);
}
/********************************Auto_Shutdowm_Timer_timer*******************************************************/
extern void touch_reset(void);
/*******************************once_delay_event_Timer__timer*********************************************************/
uint8_t once_event_case = 0;
osTimerId once_delay_event_Timer_id = NULL;
void startonce_delay_event_Timer_(int ms);
void stoponce_delay_event_Timer_(void);
static void once_delay_event_Timer_fun(const void *);
osTimerDef(defonce_delay_event_Timer_,once_delay_event_Timer_fun);
void once_delay_event_Timer_init(void)
{
TRACE(3,"%s",__func__);
once_delay_event_Timer_id = osTimerCreate(osTimer(defonce_delay_event_Timer_),osTimerOnce,(void *)0);
}
static void once_delay_event_Timer_fun(const void *)
{
static ibrt_ctrl_t *p_ibrt_ctrl = app_tws_ibrt_get_bt_ctrl_ctx();
if((p_ibrt_ctrl->current_role == IBRT_SLAVE))
{
once_event_case = 0;
TRACE(3,"delay_report_tonefun RETURN!!!");
return;
}
TRACE(3,"\n\n!!!!!!enter %s,mobile_link = %d,event = %d\n\n",__func__,app_tws_ibrt_mobile_link_connected(),once_event_case);
switch(once_event_case)
{
case 1:
if(/*(avrcp_get_media_status() != 1)&&*/(app_bt_device.a2dp_state[BT_DEVICE_ID_1] == 1)&&(app_bt_device.hfchan_callSetup[BT_DEVICE_ID_1] == 0)&&
(p_ibrt_ctrl->current_role == IBRT_MASTER))
app_voice_report(APP_STATUS_INDICATION_CONNECTED,0);
break;
case 2:
if((IsMobileLinkLossing || app_device_bt_is_connected()))break;
app_voice_report(APP_STATUS_INDICATION_DISCONNECTED,0);
app_voice_report(APP_STATUS_INDICATION_BOTHSCAN,0);
app_status_indication_set(APP_STATUS_INDICATION_BOTHSCAN);
//once_event_case = 3;
// startonce_delay_event_Timer_(2000);
break;
case 3:
if(IsMobileLinkLossing)
{
return;
}
if((app_device_bt_is_connected()))return;
app_status_indication_set(APP_STATUS_INDICATION_BOTHSCAN);
app_voice_report(APP_STATUS_INDICATION_BOTHSCAN,0);
if(p_ibrt_ctrl->nv_role == IBRT_MASTER)
{
app_ibrt_if_enter_pairing_after_tws_connected();
}
else if(p_ibrt_ctrl->nv_role == IBRT_SLAVE)
{
app_ibrt_ui_set_enter_pairing_mode(IBRT_CONNECT_MOBILE_FAILED);
app_ibrt_ui_judge_scan_type(IBRT_CONNECTE_TRIGGER,MOBILE_LINK, 0);
}
else if(p_ibrt_ctrl->nv_role == IBRT_UNKNOW)
{
app_ibrt_ui_judge_scan_type(IBRT_FREEMAN_PAIR_TRIGGER,NO_LINK_TYPE, IBRT_UI_NO_ERROR);
app_ibrt_ui_set_freeman_enable();
}
break;
case 4:
if(!app_device_bt_is_connected()){
app_voice_report_generic(APP_STATUS_INDICATION_DISCONNECTED, 0,0);
}
LINKLOSE_REBOOT_ENABLE = true;
break;
case 5:
if(!app_device_bt_is_connected()&&!app_tws_ibrt_tws_link_connected()){
app_voice_report_generic(APP_STATUS_INDICATION_DISCONNECTED, 0,0);
}
LINKLOSE_REBOOT_ENABLE = true;
break;
case 8:
app_ibrt_sync_volume_info();
break;
case 9:
break;
default:
break;
}
once_event_case = 0;
}
void startonce_delay_event_Timer_(int ms)
{
TRACE(3,"\n\n !!!!!!!!!!start %s\n\n",__func__);
osTimerStart(once_delay_event_Timer_id,ms);
}
void stoponce_delay_event_Timer_(void)
{
TRACE(3,"\n\n!!!!!!!!!! stop %s\n\n",__func__);
osTimerStop(once_delay_event_Timer_id);
}
/********************************once_delay_event_Timer__timer*******************************************************/
/***********************************************************************************************/
#include "hal_gpio.h"
#include "tgt_hardware.h"
extern struct BT_DEVICE_T app_bt_device;
extern void hal_gpio_pin_set(enum HAL_GPIO_PIN_T pin);
bool Curr_Is_Master(void)
{
static ibrt_ctrl_t *p_ibrt_ctrl = app_tws_ibrt_get_bt_ctrl_ctx();
if(p_ibrt_ctrl->current_role == IBRT_MASTER)
return 1;
else
return 0;
}
bool Curr_Is_Slave(void)
{
static ibrt_ctrl_t *p_ibrt_ctrl = app_tws_ibrt_get_bt_ctrl_ctx();
if(p_ibrt_ctrl->current_role == IBRT_SLAVE)
return 1;
else
return 0;
}
uint8_t get_curr_role(void)
{
static ibrt_ctrl_t *p_ibrt_ctrl = app_tws_ibrt_get_bt_ctrl_ctx();
return p_ibrt_ctrl->current_role;
}
uint8_t get_nv_role(void)
{
static ibrt_ctrl_t *p_ibrt_ctrl = app_tws_ibrt_get_bt_ctrl_ctx();
return p_ibrt_ctrl->nv_role;
}
extern bt_status_t LinkDisconnectDirectly(bool PowerOffFlag);
void a2dp_suspend_music_force(void);
bool app_is_power_off_in_progress(void)
{
return app_poweroff_flag?TRUE:FALSE;
}
#if GFPS_ENABLED
#define APP_GFPS_BATTERY_TIMEROUT_VALUE (10000)
static void app_gfps_battery_show_timeout_timer_cb(void const *n);
osTimerDef (GFPS_BATTERY_SHOW_TIMEOUT_TIMER, app_gfps_battery_show_timeout_timer_cb);
static osTimerId app_gfps_battery_show_timer_id = NULL;
#include "app_gfps.h"
static void app_gfps_battery_show_timeout_timer_cb(void const *n)
{
TRACE(1,"%s", __func__);
app_gfps_set_battery_datatype(HIDE_UI_INDICATION);
}
void app_gfps_battery_show_timer_start()
{
if (app_gfps_battery_show_timer_id == NULL)
app_gfps_battery_show_timer_id = osTimerCreate(osTimer(GFPS_BATTERY_SHOW_TIMEOUT_TIMER), osTimerOnce, NULL);
osTimerStart(app_gfps_battery_show_timer_id, APP_GFPS_BATTERY_TIMEROUT_VALUE);
}
void app_gfps_battery_show_timer_stop()
{
if (app_gfps_battery_show_timer_id)
osTimerStop(app_gfps_battery_show_timer_id);
}
#endif
int app_deinit(int deinit_case)
{
int nRet = 0;
TRACE(2,"%s case:%d",__func__, deinit_case);
Perform TWS handoff before shutting down the bud Fixes audio pausing when you put one of them away
2022-12-29 06:17:17 -06:00
app_tws_if_trigger_role_switch();
add base work success
2022-08-15 20:30:33 -05:00
#ifdef WL_DET
app_mic_alg_audioloop(false,APP_SYSFREQ_78M);
#endif
add first commit
2022-08-15 04:20:27 -05:00
#ifdef __PC_CMD_UART__
app_cmd_close();
#endif
#if (defined(BTUSB_AUDIO_MODE) || defined(BT_USB_AUDIO_DUAL_MODE))
if(app_usbaudio_mode_on()) return 0;
#endif
if (!deinit_case){
app_poweroff_flag = 1;
#if defined(APP_LINEIN_A2DP_SOURCE)
app_audio_sendrequest(APP_A2DP_SOURCE_LINEIN_AUDIO, (uint8_t)APP_BT_SETTING_CLOSE,0);
#endif
#if defined(APP_I2S_A2DP_SOURCE)
app_audio_sendrequest(APP_A2DP_SOURCE_I2S_AUDIO, (uint8_t)APP_BT_SETTING_CLOSE,0);
#endif
app_status_indication_filter_set(APP_STATUS_INDICATION_BOTHSCAN);
app_audio_sendrequest(APP_BT_STREAM_INVALID, (uint8_t)APP_BT_SETTING_CLOSEALL, 0);
osDelay(500);
LinkDisconnectDirectly(true);
osDelay(500);
app_status_indication_set(APP_STATUS_INDICATION_POWEROFF);
#ifdef MEDIA_PLAYER_SUPPORT
app_voice_report(APP_STATUS_INDICATION_POWEROFF, 0);
#endif
#ifdef __THIRDPARTY
app_thirdparty_specific_lib_event_handle(THIRDPARTY_FUNC_NO1,THIRDPARTY_DEINIT);
#endif
#if FPGA==0
nv_record_flash_flush();
norflash_api_flush_all();
#if defined(DUMP_LOG_ENABLE)
log_dump_flush_all();
#endif
#endif
osDelay(1000);
af_close();
}
return nRet;
}
#ifdef APP_TEST_MODE
extern void app_test_init(void);
int app_init(void)
{
int nRet = 0;
//uint8_t pwron_case = APP_POWERON_CASE_INVALID;
TRACE(1,"%s",__func__);
app_poweroff_flag = 0;
app_sysfreq_req(APP_SYSFREQ_USER_APP_INIT, APP_SYSFREQ_52M);
list_init();
af_open();
app_os_init();
app_pwl_open();
app_audio_open();
app_audio_manager_open();
app_overlay_open();
if (app_key_open(true))
{
nRet = -1;
goto exit;
}
app_test_init();
exit:
app_sysfreq_req(APP_SYSFREQ_USER_APP_INIT, APP_SYSFREQ_32K);
return nRet;
}
#else /* !defined(APP_TEST_MODE) */
int app_bt_connect2tester_init(void)
{
btif_device_record_t rec;
bt_bdaddr_t tester_addr;
uint8_t i;
bool find_tester = false;
struct nvrecord_env_t *nvrecord_env;
btdevice_profile *btdevice_plf_p;
nv_record_env_get(&nvrecord_env);
if (nvrecord_env->factory_tester_status.status != NVRAM_ENV_FACTORY_TESTER_STATUS_DEFAULT)
return 0;
if (!nvrec_dev_get_dongleaddr(&tester_addr)){
nv_record_open(section_usrdata_ddbrecord);
for (i = 0; nv_record_enum_dev_records(i, &rec) == BT_STS_SUCCESS; i++) {
if (!memcmp(rec.bdAddr.address, tester_addr.address, BTIF_BD_ADDR_SIZE)){
find_tester = true;
}
}
if(i==0 && !find_tester){
memset(&rec, 0, sizeof(btif_device_record_t));
memcpy(rec.bdAddr.address, tester_addr.address, BTIF_BD_ADDR_SIZE);
nv_record_add(section_usrdata_ddbrecord, &rec);
btdevice_plf_p = (btdevice_profile *)app_bt_profile_active_store_ptr_get(rec.bdAddr.address);
nv_record_btdevicerecord_set_hfp_profile_active_state(btdevice_plf_p, true);
nv_record_btdevicerecord_set_a2dp_profile_active_state(btdevice_plf_p, true);
}
if (find_tester && i>2){
nv_record_ddbrec_delete(&tester_addr);
nvrecord_env->factory_tester_status.status = NVRAM_ENV_FACTORY_TESTER_STATUS_TEST_PASS;
nv_record_env_set(nvrecord_env);
}
}
return 0;
}
int app_nvrecord_rebuild(void)
{
struct nvrecord_env_t *nvrecord_env;
nv_record_env_get(&nvrecord_env);
nv_record_sector_clear();
nv_record_env_init();
nv_record_update_factory_tester_status(NVRAM_ENV_FACTORY_TESTER_STATUS_TEST_PASS);
nv_record_env_set(nvrecord_env);
nv_record_flash_flush();
return 0;
}
#if (defined(BTUSB_AUDIO_MODE) || defined(BT_USB_AUDIO_DUAL_MODE))
#include "app_audio.h"
#include "usb_audio_frm_defs.h"
#include "usb_audio_app.h"
static bool app_usbaudio_mode = false;
extern "C" void btusbaudio_entry(void);
void app_usbaudio_entry(void)
{
btusbaudio_entry();
app_usbaudio_mode = true ;
}
bool app_usbaudio_mode_on(void)
{
return app_usbaudio_mode;
}
void app_usb_key(APP_KEY_STATUS *status, void *param)
{
TRACE(3,"%s %d,%d",__func__, status->code, status->event);
}
const APP_KEY_HANDLE app_usb_handle_cfg[] = {
{{APP_KEY_CODE_FN1,APP_KEY_EVENT_UP},"USB HID FN1 UP key",app_usb_key, NULL},
{{APP_KEY_CODE_FN2,APP_KEY_EVENT_UP},"USB HID FN2 UP key",app_usb_key, NULL},
{{APP_KEY_CODE_PWR,APP_KEY_EVENT_UP},"USB HID PWR UP key",app_usb_key, NULL},
};
void app_usb_key_init(void)
{
uint8_t i = 0;
TRACE(1,"%s",__func__);
for (i=0; i<(sizeof(app_usb_handle_cfg)/sizeof(APP_KEY_HANDLE)); i++){
app_key_handle_registration(&app_usb_handle_cfg[i]);
}
}
#endif /* (defined(BTUSB_AUDIO_MODE) || defined(BT_USB_AUDIO_DUAL_MODE)) */
//#define OS_HAS_CPU_STAT 1
#if OS_HAS_CPU_STAT
extern "C" void rtx_show_all_threads_usage(void);
#define _CPU_STATISTICS_PEROID_ 6000
#define CPU_USAGE_TIMER_TMO_VALUE (_CPU_STATISTICS_PEROID_/3)
static void cpu_usage_timer_handler(void const *param);
osTimerDef(cpu_usage_timer, cpu_usage_timer_handler);
static osTimerId cpu_usage_timer_id = NULL;
static void cpu_usage_timer_handler(void const *param)
{
rtx_show_all_threads_usage();
}
#endif
#ifdef USER_REBOOT_PLAY_MUSIC_AUTO
bool a2dp_need_to_play = false;
#endif
extern void btif_me_write_bt_sleep_enable(uint8_t sleep_en);
int btdrv_tportopen(void);
void app_ibrt_init(void)
{
app_bt_global_handle_init();
#if defined(IBRT)
ibrt_config_t config;
app_tws_ibrt_init();
app_ibrt_ui_init();
app_ibrt_ui_test_init();
app_ibrt_if_config_load(&config);
app_ibrt_customif_ui_start();
#ifdef IBRT_SEARCH_UI
app_tws_ibrt_start(&config, true);
app_ibrt_search_ui_init(false,IBRT_NONE_EVENT);
#else
app_tws_ibrt_start(&config, false);
#endif
#ifdef POWER_ON_ENTER_TWS_PAIRING_ENABLED
app_ibrt_ui_event_entry(IBRT_TWS_PAIRING_EVENT);
#endif
#endif
}
#ifdef GFPS_ENABLED
static void app_tell_battery_info_handler(uint8_t *batteryValueCount,
uint8_t *batteryValue)
{
GFPS_BATTERY_STATUS_E status;
if (app_battery_is_charging())
{
status = BATTERY_CHARGING;
}
else
{
status = BATTERY_NOT_CHARGING;
}
// TODO: add the charger case's battery level
#ifdef IBRT
if (app_tws_ibrt_tws_link_connected())
{
*batteryValueCount = 2;
}
else
{
*batteryValueCount = 1;
}
#else
*batteryValueCount = 1;
#endif
TRACE(2,"%s,*batteryValueCount is %d",__func__,*batteryValueCount);
if (1 == *batteryValueCount)
{
batteryValue[0] = ((app_battery_current_level()+1) * 10) | (status << 7);
}
else
{
batteryValue[0] = ((app_battery_current_level()+1) * 10) | (status << 7);
batteryValue[1] = ((app_battery_current_level()+1) * 10) | (status << 7);
}
}
#endif
/*
#define regaddr0 0x40
#define regaddr1 0x41
#define regaddr2 0x42
#define regaddr3 0x43
#define regaddr4 0xc8
#define decice_firstreg 0x00
*/
void touch_evt_handler(enum HAL_GPIO_PIN_T pin)
{
TRACE(3,"SCL_TOUCH !!!!");
/*
unsigned char keyEventBUff0 ;
unsigned char keyEventBUff1 ;
unsigned char keyEventBUff2 ;
unsigned char keyEventBUff3 ;
unsigned char temp = 0;
//hal_gpio_i2c_simple_recv((unsigned char)0x60, 0x40, 1,&keyEventBUff,4);
I2C_ReadByte(regaddr0,&keyEventBUff0);
I2C_ReadByte(regaddr1,&keyEventBUff1);
I2C_ReadByte(regaddr2,&keyEventBUff2);
I2C_ReadByte(regaddr3,&keyEventBUff3);
unsigned char firstaddr;
I2C_ReadByte(decice_firstreg,&firstaddr);
TRACE(3,"0X00 REG = 0x%x",firstaddr);
unsigned char keyEventBUff4byte[4] ;
I2C_Read4Byte(regaddr0,keyEventBUff4byte);
I2C_ReadByte(0xC8,&temp);
temp |= 0x01;
I2C_WriteByte(0xC8,temp);
TRACE(3,"REG0X40 = 0x%x, REG0X41 = 0x%x, REG0X42 = 0x%x, REG0X43 = 0x%x",keyEventBUff0,keyEventBUff1,keyEventBUff2,keyEventBUff3);
TRACE(3,"keyEventBUff4BYTE :");
DUMP8("0x%02x ",keyEventBUff4byte,4);
uint8_t keyEventBUff0[4];
uint8_t keyEventBUff4[1];
touch_key_i2c_read(regaddr0,&keyEventBUff0[0],1);
touch_key_i2c_read(regaddr1,&keyEventBUff0[1],1);
touch_key_i2c_read(regaddr2,&keyEventBUff0[2],1);
touch_key_i2c_read(regaddr3,&keyEventBUff0[3],1);
touch_key_i2c_read(regaddr4,keyEventBUff4,1);
TRACE(3,"keyEventBUff0 :");
DUMP8("0x%02x ",keyEventBUff0,4);
TRACE(3,"keyEventBUff1 :");
DUMP8("0x%02x ",keyEventBUff4,1);
keyEventBUff4[0] |= 0x1;
touch_key_i2c_write(0,regaddr4,1,keyEventBUff4);
*/
}
/******************************LED_status_timer*********************************************************/
osTimerId LED_statusid = NULL;
void startLED_status(int ms);
void stopLED_status(void);
static void LED_statusfun(const void *);
osTimerDef(defLED_status,LED_statusfun);
void LED_statusinit(void)
{
LED_statusid = osTimerCreate(osTimer(defLED_status),osTimerOnce,(void *)0);
}
static void LED_statusfun(const void *)
{
//TRACE("\n\n!!!!!!enter %s\n\n",__func__);
if((Curr_Is_Slave()||app_device_bt_is_connected())&&(!app_battery_is_charging())){
app_status_indication_set(APP_STATUS_INDICATION_CONNECTED);
}else if(!app_device_bt_is_connected()&&(!app_battery_is_charging())){
app_status_indication_set(APP_STATUS_INDICATION_BOTHSCAN);
}else if(app_battery_is_charging()){
app_status_indication_set(APP_STATUS_INDICATION_CHARGING);
}
//unsigned char firstaddr;
//I2C_ReadByte(decice_firstreg,&firstaddr);
//TRACE(3,"0X00 REG = 0x%x",firstaddr);
startLED_status(1000);
}
void startLED_status(int ms)
{
//TRACE("\n\n !!!!!!!!!!start %s\n\n",__func__);
osTimerStart(LED_statusid,ms);
}
void stopLED_status(void)
{
//TRACE("\n\n!!!!!!!!!! stop %s\n\n",__func__);
osTimerStop(LED_statusid);
}
/********************************LED_status_timer*******************************************************/
/********************************TOUCH_INT_TEST_timer*******************************************************/
void user_io_timer_init(void)
{
//app_mute_ctrl_init();
LED_statusinit();
add ui on it
2022-09-03 08:17:07 -05:00
//pwrkey_detinit();
Enable auto shutdown
2022-12-25 00:00:33 -06:00
Auto_Shutdowm_Timerinit();
add first commit
2022-08-15 04:20:27 -05:00
delay_report_toneinit();
once_delay_event_Timer_init();
//app_i2c_demo_init();
//tou_io_init();
}
extern uint32_t __coredump_section_start[];
extern uint32_t __ota_upgrade_log_start[];
extern uint32_t __log_dump_start[];
extern uint32_t __crash_dump_start[];
extern uint32_t __custom_parameter_start[];
extern uint32_t __lhdc_license_start[];
extern uint32_t __aud_start[];
extern uint32_t __userdata_start[];
extern uint32_t __factory_start[];
#if defined(A2DP_LHDC_ON)
extern "C"
{
typedef struct bes_bt_local_info_t
{
uint8_t bt_addr[BTIF_BD_ADDR_SIZE];
const char *bt_name;
uint8_t bt_len;
uint8_t ble_addr[BTIF_BD_ADDR_SIZE];
const char *ble_name;
uint8_t ble_len;
} bes_bt_local_info;
typedef int (*LHDC_GET_BT_INFO)(bes_bt_local_info *bt_info);
extern bool lhdcSetLicenseKeyTable(uint8_t * licTable, LHDC_GET_BT_INFO pFunc);
}
extern int bes_bt_local_info_get(bes_bt_local_info *local_info);
void lhdc_license_check()
{
uint8_t lhdc_license_key = 0;
uint8_t *lhdc_license_data=(uint8_t * )__lhdc_license_start + 0x98;
TRACE(5,"lhdc_license_data:%p, lhdc license %02x %02x %02x %02x",lhdc_license_data,
lhdc_license_data[0],lhdc_license_data[1],lhdc_license_data[2],lhdc_license_data[3]);
app_overlay_select(APP_OVERLAY_A2DP_LHDC);
TRACE(1, "current_overlay = %d", app_get_current_overlay());
lhdc_license_key = lhdcSetLicenseKeyTable(lhdc_license_data, bes_bt_local_info_get);
TRACE(0, "lhdc_license_key:%d", lhdc_license_key);
if(lhdc_license_key)
{
TRACE(0, "LHDC OK");
}
else
{
TRACE(0, "LHDC ERROR");
}
}
#endif
int app_init(void)
{
int nRet = 0;
struct nvrecord_env_t *nvrecord_env;
#ifdef POWER_ON_ENTER_TWS_PAIRING_ENABLED
bool need_check_key = false;
#else
add base work success
2022-08-15 20:30:33 -05:00
bool need_check_key = false;
add first commit
2022-08-15 04:20:27 -05:00
#endif
uint8_t pwron_case = APP_POWERON_CASE_INVALID;
#ifdef BT_USB_AUDIO_DUAL_MODE
uint8_t usb_plugin = 0;
#endif
#ifdef IBRT_SEARCH_UI
bool is_charging_poweron=false;
#endif
TRACE(0,"please check all sections sizes and heads is correct ........");
TRACE(2,"__coredump_section_start: %p length: 0x%x", __coredump_section_start, CORE_DUMP_SECTION_SIZE);
TRACE(2,"__ota_upgrade_log_start: %p length: 0x%x", __ota_upgrade_log_start, OTA_UPGRADE_LOG_SIZE);
TRACE(2,"__log_dump_start: %p length: 0x%x", __log_dump_start, LOG_DUMP_SECTION_SIZE);
TRACE(2,"__crash_dump_start: %p length: 0x%x", __crash_dump_start, CRASH_DUMP_SECTION_SIZE);
TRACE(2,"__custom_parameter_start: %p length: 0x%x", __custom_parameter_start, CUSTOM_PARAMETER_SECTION_SIZE);
TRACE(2,"__lhdc_license_start: %p length: 0x%x", __lhdc_license_start, LHDC_LICENSE_SECTION_SIZE);
TRACE(2,"__userdata_start: %p length: 0x%x", __userdata_start, USERDATA_SECTION_SIZE*2);
TRACE(2,"__aud_start: %p length: 0x%x", __aud_start, AUD_SECTION_SIZE);
TRACE(2,"__factory_start: %p length: 0x%x", __factory_start, FACTORY_SECTION_SIZE);
TRACE(0,"app_init\n");
Update side at boot
2022-12-28 04:22:31 -06:00
app_tws_set_side_from_gpio();
add first commit
2022-08-15 04:20:27 -05:00
#ifdef __RPC_ENABLE__
extern int rpc_service_setup(void);
rpc_service_setup();
#endif
#ifdef IBRT
// init tws interface
app_tws_if_init();
#endif // #ifdef IBRT
nv_record_init();
factory_section_init();
#ifdef ANC_APP
app_anc_ios_init();
#endif
app_sysfreq_req(APP_SYSFREQ_USER_APP_INIT, APP_SYSFREQ_104M);
#if defined(MCU_HIGH_PERFORMANCE_MODE)
TRACE(1,"sys freq calc : %d\n", hal_sys_timer_calc_cpu_freq(5, 0));
#endif
list_init();
nRet = app_os_init();
if (nRet) {
goto exit;
}
#if OS_HAS_CPU_STAT
cpu_usage_timer_id = osTimerCreate(osTimer(cpu_usage_timer), osTimerPeriodic, NULL);
if (cpu_usage_timer_id != NULL) {
osTimerStart(cpu_usage_timer_id, CPU_USAGE_TIMER_TMO_VALUE);
}
#endif
//app_status_indication_init();
#ifdef BTADDR_FOR_DEBUG
gen_bt_addr_for_debug();
#endif
#ifdef FORCE_SIGNALINGMODE
hal_sw_bootmode_clear(HAL_SW_BOOTMODE_TEST_NOSIGNALINGMODE);
hal_sw_bootmode_set(HAL_SW_BOOTMODE_TEST_MODE | HAL_SW_BOOTMODE_TEST_SIGNALINGMODE);
#elif defined FORCE_NOSIGNALINGMODE
hal_sw_bootmode_clear(HAL_SW_BOOTMODE_TEST_SIGNALINGMODE);
hal_sw_bootmode_set(HAL_SW_BOOTMODE_TEST_MODE | HAL_SW_BOOTMODE_TEST_NOSIGNALINGMODE);
#endif
if (hal_sw_bootmode_get() & HAL_SW_BOOTMODE_REBOOT_FROM_CRASH){
hal_sw_bootmode_clear(HAL_SW_BOOTMODE_REBOOT_FROM_CRASH);
TRACE(0,"Crash happened!!!");
#ifdef VOICE_DATAPATH
gsound_dump_set_flag(true);
#endif
}
if (hal_sw_bootmode_get() & HAL_SW_BOOTMODE_REBOOT){
hal_sw_bootmode_clear(HAL_SW_BOOTMODE_REBOOT);
pwron_case = APP_POWERON_CASE_REBOOT;
need_check_key = false;
TRACE(0,"Initiative REBOOT happens!!!");
#ifdef USER_REBOOT_PLAY_MUSIC_AUTO
if(hal_sw_bootmode_get() & HAL_SW_BOOTMODE_LOCAL_PLAYER)
{
hal_sw_bootmode_clear(HAL_SW_BOOTMODE_LOCAL_PLAYER);
a2dp_need_to_play = true;
TRACE(0,"a2dp_need_to_play = true");
}
#endif
}
if (hal_sw_bootmode_get() & HAL_SW_BOOTMODE_TEST_MODE){
hal_sw_bootmode_clear(HAL_SW_BOOTMODE_TEST_MODE);
pwron_case = APP_POWERON_CASE_TEST;
need_check_key = false;
TRACE(0,"To enter test mode!!!");
}
#ifdef BT_USB_AUDIO_DUAL_MODE
usb_os_init();
#endif
nRet = app_battery_open();
upstream
2022-12-26 17:27:11 -06:00
TRACE(1,"Yin BATTERY %d",nRet);
add first commit
2022-08-15 04:20:27 -05:00
if (pwron_case != APP_POWERON_CASE_TEST){
#ifdef USER_REBOOT_PLAY_MUSIC_AUTO
TRACE(0,"hal_sw_bootmode_clear HAL_SW_BOOTMODE_LOCAL_PLAYER!!!!!!");
hal_sw_bootmode_clear(HAL_SW_BOOTMODE_LOCAL_PLAYER);
#endif
switch (nRet) {
case APP_BATTERY_OPEN_MODE_NORMAL:
nRet = 0;
break;
case APP_BATTERY_OPEN_MODE_CHARGING:
app_status_indication_set(APP_STATUS_INDICATION_CHARGING);
TRACE(0,"CHARGING!");
app_battery_start();
app_key_open(false);
app_key_init_on_charging();
nRet = 0;
#if defined(BT_USB_AUDIO_DUAL_MODE)
usb_plugin = 1;
#elif defined(BTUSB_AUDIO_MODE)
goto exit;
#endif
upstream
2022-12-26 17:27:11 -06:00
goto exit;
add first commit
2022-08-15 04:20:27 -05:00
break;
case APP_BATTERY_OPEN_MODE_CHARGING_PWRON:
TRACE(0,"CHARGING PWRON!");
#ifdef IBRT_SEARCH_UI
is_charging_poweron=true;
#endif
app_status_indication_set(APP_STATUS_INDICATION_CHARGING);
need_check_key = false;
nRet = 0;
break;
case APP_BATTERY_OPEN_MODE_INVALID:
default:
nRet = -1;
goto exit;
break;
}
}
if (app_key_open(need_check_key)){
TRACE(0,"PWR KEY DITHER!");
nRet = -1;
goto exit;
}
hal_sw_bootmode_set(HAL_SW_BOOTMODE_REBOOT);
app_poweron_key_init();
#if defined(_AUTO_TEST_)
AUTO_TEST_SEND("Power on.");
#endif
app_bt_init();
af_open();
app_audio_open();
app_audio_manager_open();
app_overlay_open();
nv_record_env_init();
nvrec_dev_data_open();
factory_section_open();
add base 2300_open source on it
2022-09-02 22:23:40 -05:00
add first commit
2022-08-15 04:20:27 -05:00
/*****************************************************************************/
// app_bt_connect2tester_init();
nv_record_env_get(&nvrecord_env);
add base work success
2022-08-15 20:30:33 -05:00
#ifdef AUDIO_LOOPBACK
add base 2300_open source on it
2022-09-02 22:23:40 -05:00
add base work success
2022-08-15 20:30:33 -05:00
#ifdef WL_DET
app_mic_alg_audioloop(true,APP_SYSFREQ_78M);
#endif
while(1);
#endif
add first commit
2022-08-15 04:20:27 -05:00
#ifdef BISTO_ENABLED
nv_record_gsound_rec_init();
#endif
#ifdef BLE_ENABLE
app_ble_mode_init();
app_ble_customif_init();
#ifdef IBRT
app_ble_force_switch_adv(BLE_SWITCH_USER_IBRT, false);
#endif // #ifdef IBRT
#endif
audio_process_init();
#ifdef __PC_CMD_UART__
app_cmd_open();
#endif
#ifdef AUDIO_DEBUG_V0_1_0
speech_tuning_init();
#endif
#ifdef ANC_APP
app_anc_open_module();
#endif
#ifdef MEDIA_PLAYER_SUPPORT
app_play_audio_set_lang(nvrecord_env->media_language.language);
#endif
app_bt_stream_volume_ptr_update(NULL);
#ifdef __THIRDPARTY
app_thirdparty_init();
app_thirdparty_specific_lib_event_handle(THIRDPARTY_FUNC_NO2,THIRDPARTY_INIT);
#endif
// TODO: freddie->unify all of the OTA modules
#if defined(IBRT_OTA)
ota_flash_init();
#endif
#ifdef OTA_ENABLED
/// init OTA common module
ota_common_init_handler();
#endif // OTA_ENABLED
#ifdef IBRT
// for TWS side decision, the last bit is 1:right, 0:left
if (app_tws_is_unknown_side())
{
//app_tws_set_side_from_addr(factory_section_get_bt_address());
app_tws_set_side_from_gpio();
}
#endif
btdrv_start_bt();
#if defined (__GMA_VOICE__) && defined(IBRT_SEARCH_UI)
app_ibrt_reconfig_btAddr_from_nv();
#endif
if (pwron_case != APP_POWERON_CASE_TEST) {
BesbtInit();
app_wait_stack_ready();
bt_drv_extra_config_after_init();
bt_generate_ecdh_key_pair();
app_bt_start_custom_function_in_bt_thread((uint32_t)0,
0, (uint32_t)app_ibrt_init);
}
#if defined(BLE_ENABLE) && defined(IBRT)
app_ble_force_switch_adv(BLE_SWITCH_USER_IBRT, true);
#endif
app_sysfreq_req(APP_SYSFREQ_USER_APP_INIT, APP_SYSFREQ_52M);
TRACE(1,"\n\n\nbt_stack_init_done:%d\n\n\n", pwron_case);
if (pwron_case == APP_POWERON_CASE_REBOOT){
app_status_indication_init();
Enable auto shutdown
2022-12-25 00:00:33 -06:00
user_io_timer_init();
add first commit
2022-08-15 04:20:27 -05:00
app_status_indication_set(APP_STATUS_INDICATION_POWERON);
#ifdef MEDIA_PLAYER_SUPPORT
app_voice_report(APP_STATUS_INDICATION_POWERON, 0);
#endif
app_bt_start_custom_function_in_bt_thread((uint32_t)1,
0, (uint32_t)btif_me_write_bt_sleep_enable);
btdrv_set_lpo_times();
#if defined(IBRT_OTA)
bes_ota_init();
#endif
//app_bt_accessmode_set(BTIF_BAM_NOT_ACCESSIBLE);
#if defined(IBRT)
#ifdef IBRT_SEARCH_UI
if(is_charging_poweron==false)
{
if(IBRT_UNKNOW == nvrecord_env->ibrt_mode.mode)
{
TRACE(0,"ibrt_ui_log:power on unknow mode");
app_ibrt_enter_limited_mode();
add ui on it
2022-09-03 08:17:07 -05:00
//if(app_tws_is_right_side())
if(1)
{
add first commit
2022-08-15 04:20:27 -05:00
TRACE(0,"app_start_tws_serching_direactly");
app_start_tws_serching_direactly();
add ui on it
2022-09-03 08:17:07 -05:00
}
add first commit
2022-08-15 04:20:27 -05:00
}
else
{
TRACE(1,"ibrt_ui_log:power on %d fetch out", nvrecord_env->ibrt_mode.mode);
app_ibrt_ui_event_entry(IBRT_FETCH_OUT_EVENT);
}
add base 2300_open source on it
2022-09-02 22:23:40 -05:00
//startLED_status(1000);
add first commit
2022-08-15 04:20:27 -05:00
once_event_case = 9;
startonce_delay_event_Timer_(1000);
add base 2300_open source on it
2022-09-02 22:23:40 -05:00
//startpwrkey_det(200);
add first commit
2022-08-15 04:20:27 -05:00
}
#elif defined(IS_MULTI_AI_ENABLED)
//when ama and bisto switch, earphone need reconnect with peer, master need reconnect with phone
uint8_t box_action = app_ai_tws_reboot_get_box_action();
if (box_action != 0xFF)
{
TRACE(2, "%s box_actionstate %d", __func__, box_action);
app_ibrt_ui_event_entry(box_action|IBRT_SKIP_FALSE_TRIGGER_MASK);
}
#endif
#else
app_bt_accessmode_set(BTIF_BAM_NOT_ACCESSIBLE);
#endif
app_key_init();
app_battery_start();
#if defined(__BTIF_EARPHONE__) && defined(__BTIF_AUTOPOWEROFF__)
app_start_10_second_timer(APP_POWEROFF_TIMER_ID);
#endif
#if defined(__IAG_BLE_INCLUDE__) && defined(BTIF_BLE_APP_DATAPATH_SERVER)
BLE_custom_command_init();
#endif
#ifdef __THIRDPARTY
app_thirdparty_specific_lib_event_handle(THIRDPARTY_FUNC_NO1,THIRDPARTY_INIT);
app_thirdparty_specific_lib_event_handle(THIRDPARTY_FUNC_NO1,THIRDPARTY_START);
app_thirdparty_specific_lib_event_handle(THIRDPARTY_FUNC_NO2,THIRDPARTY_BT_CONNECTABLE);
app_thirdparty_specific_lib_event_handle(THIRDPARTY_FUNC_NO3,THIRDPARTY_START);
#endif
#if defined( __BTIF_EARPHONE__) && defined(__BTIF_BT_RECONNECT__)
#if !defined(IBRT)
app_bt_profile_connect_manager_opening_reconnect();
#endif
#endif
}
#ifdef __ENGINEER_MODE_SUPPORT__
else if(pwron_case == APP_POWERON_CASE_TEST){
app_status_indication_init();
app_factorymode_set(true);
app_status_indication_set(APP_STATUS_INDICATION_POWERON);
#ifdef MEDIA_PLAYER_SUPPORT
app_voice_report(APP_STATUS_INDICATION_POWERON, 0);
#endif
#ifdef __WATCHER_DOG_RESET__
app_wdt_close();
#endif
TRACE(0,"!!!!!ENGINEER_MODE!!!!!\n");
nRet = 0;
app_nvrecord_rebuild();
app_factorymode_key_init();
if (hal_sw_bootmode_get() & HAL_SW_BOOTMODE_TEST_SIGNALINGMODE){
hal_sw_bootmode_clear(HAL_SW_BOOTMODE_TEST_MASK);
app_factorymode_bt_signalingtest(NULL, NULL);
}
if (hal_sw_bootmode_get() & HAL_SW_BOOTMODE_TEST_NOSIGNALINGMODE){
hal_sw_bootmode_clear(HAL_SW_BOOTMODE_TEST_MASK);
app_factorymode_bt_nosignalingtest(NULL, NULL);
}
}
#endif
else{
Enable auto shutdown
2022-12-25 00:00:33 -06:00
user_io_timer_init();
app_status_indication_init();
add first commit
2022-08-15 04:20:27 -05:00
app_status_indication_set(APP_STATUS_INDICATION_POWERON);
#ifdef MEDIA_PLAYER_SUPPORT
app_voice_report(APP_STATUS_INDICATION_POWERON, 0);
#endif
if (need_check_key){
pwron_case = app_poweron_wait_case();
}
else
{
pwron_case = APP_POWERON_CASE_NORMAL;
}
if (need_check_key)
{
#ifndef __POWERKEY_CTRL_ONOFF_ONLY__
app_poweron_wait_finished();
#endif
}
if (pwron_case != APP_POWERON_CASE_INVALID && pwron_case != APP_POWERON_CASE_DITHERING){
TRACE(1,"power on case:%d\n", pwron_case);
nRet = 0;
#ifndef __POWERKEY_CTRL_ONOFF_ONLY__
//app_status_indication_set(APP_STATUS_INDICATION_INITIAL);
#endif
app_bt_start_custom_function_in_bt_thread((uint32_t)1,
0, (uint32_t)btif_me_write_bt_sleep_enable);
btdrv_set_lpo_times();
#ifdef IBRT_OTA
bes_ota_init();
#endif
#ifdef __INTERCONNECTION__
app_interconnection_init();
#endif
#ifdef __INTERACTION__
app_interaction_init();
#endif
#if defined(__IAG_BLE_INCLUDE__) && defined(BTIF_BLE_APP_DATAPATH_SERVER)
BLE_custom_command_init();
#endif
#ifdef GFPS_ENABLED
app_gfps_set_battery_info_acquire_handler(app_tell_battery_info_handler);
app_gfps_set_battery_datatype(SHOW_UI_INDICATION);
#endif
osDelay(500);
switch (pwron_case) {
case APP_POWERON_CASE_CALIB:
break;
case APP_POWERON_CASE_BOTHSCAN:
app_status_indication_set(APP_STATUS_INDICATION_BOTHSCAN);
#ifdef MEDIA_PLAYER_SUPPORT
app_voice_report(APP_STATUS_INDICATION_BOTHSCAN,0);
#endif
#if defined( __BTIF_EARPHONE__)
#if defined(IBRT)
#ifdef IBRT_SEARCH_UI
if(false==is_charging_poweron)
app_ibrt_enter_limited_mode();
#endif
#else
app_bt_accessmode_set(BTIF_BT_DEFAULT_ACCESS_MODE_PAIR);
#endif
#ifdef GFPS_ENABLED
app_enter_fastpairing_mode();
#endif
#if defined(__BTIF_AUTOPOWEROFF__)
app_start_10_second_timer(APP_PAIR_TIMER_ID);
#endif
#endif
#ifdef __THIRDPARTY
app_thirdparty_specific_lib_event_handle(THIRDPARTY_FUNC_NO2,THIRDPARTY_BT_DISCOVERABLE);
#endif
break;
case APP_POWERON_CASE_NORMAL:
#if defined( __BTIF_EARPHONE__ ) && !defined(__EARPHONE_STAY_BOTH_SCAN__)
#if defined(IBRT)
#ifdef IBRT_SEARCH_UI
app_status_indication_set(APP_STATUS_INDICATION_BOTHSCAN);
if(is_charging_poweron==false)
{
startLED_status(1000);
once_event_case = 9;
startonce_delay_event_Timer_(1000);
if(IBRT_UNKNOW == nvrecord_env->ibrt_mode.mode)
{
TRACE(0,"ibrt_ui_log:power on unknow mode");
app_ibrt_enter_limited_mode();
if(app_tws_is_right_side()){
app_start_tws_serching_direactly();
}
}
else
{
TRACE(1,"ibrt_ui_log:power on %d fetch out", nvrecord_env->ibrt_mode.mode);
app_ibrt_ui_event_entry(IBRT_FETCH_OUT_EVENT);
// app_status_indication_set(APP_STATUS_INDICATION_CHARGING);
//break;
}
add base 2300_open source on it
2022-09-02 22:23:40 -05:00
//startpwrkey_det(200);
add first commit
2022-08-15 04:20:27 -05:00
}
#elif defined(IS_MULTI_AI_ENABLED)
//when ama and bisto switch, earphone need reconnect with peer, master need reconnect with phone
//app_ibrt_ui_event_entry(IBRT_OPEN_BOX_EVENT);
//TRACE(1,"ibrt_ui_log:power on %d fetch out", nvrecord_env->ibrt_mode.mode);
//app_ibrt_ui_event_entry(IBRT_FETCH_OUT_EVENT);
#endif
#else
app_bt_accessmode_set(BTIF_BAM_NOT_ACCESSIBLE);
#endif
#endif
case APP_POWERON_CASE_REBOOT:
case APP_POWERON_CASE_ALARM:
default:
//app_status_indication_set(APP_STATUS_INDICATION_PAGESCAN);
#if defined( __BTIF_EARPHONE__) && defined(__BTIF_BT_RECONNECT__) && !defined(IBRT)
app_bt_profile_connect_manager_opening_reconnect();
#endif
#ifdef __THIRDPARTY
app_thirdparty_specific_lib_event_handle(THIRDPARTY_FUNC_NO2,THIRDPARTY_BT_CONNECTABLE);
#endif
break;
}
app_key_init();
app_battery_start();
#if defined(A2DP_LHDC_ON)
lhdc_license_check();
#endif
#if defined(__BTIF_EARPHONE__) && defined(__BTIF_AUTOPOWEROFF__)
app_start_10_second_timer(APP_POWEROFF_TIMER_ID);
#endif
#ifdef __THIRDPARTY
app_thirdparty_specific_lib_event_handle(THIRDPARTY_FUNC_NO1,THIRDPARTY_INIT);
app_thirdparty_specific_lib_event_handle(THIRDPARTY_FUNC_NO1,THIRDPARTY_START);
app_thirdparty_specific_lib_event_handle(THIRDPARTY_FUNC_NO3,THIRDPARTY_START);
#endif
#ifdef RB_CODEC
rb_ctl_init();
#endif
}else{
af_close();
app_key_close();
nRet = -1;
}
}
exit:
#ifdef IS_MULTI_AI_ENABLED
app_ai_tws_clear_reboot_box_state();
#endif
#ifdef __BT_DEBUG_TPORTS__
{
extern void bt_enable_tports(void);
bt_enable_tports();
//hal_iomux_tportopen();
}
#endif
#ifdef ANC_APP
app_anc_set_init_done();
#endif
#ifdef BT_USB_AUDIO_DUAL_MODE
if(usb_plugin)
{
btusb_switch(BTUSB_MODE_USB);
}
else
{
btusb_switch(BTUSB_MODE_BT);
}
#else //BT_USB_AUDIO_DUAL_MODE
#if defined(BTUSB_AUDIO_MODE)
if(pwron_case == APP_POWERON_CASE_CHARGING) {
#ifdef __WATCHER_DOG_RESET__
app_wdt_close();
#endif
af_open();
app_key_handle_clear();
app_usb_key_init();
app_usbaudio_entry();
}
#endif // BTUSB_AUDIO_MODE
#endif // BT_USB_AUDIO_DUAL_MODE
app_sysfreq_req(APP_SYSFREQ_USER_APP_INIT, APP_SYSFREQ_32K);
return nRet;
}
#endif /* APP_TEST_MODE */