/*************************************************************************** * * 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 #ifdef WL_DET #include "app_mic_alg.h" #endif #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 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); } #if 1//!defined(BLE_ONLY_ENABLED) 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) { uint32_t stime = 0, etime = 0; #ifdef __POWERKEY_CTRL_ONOFF_ONLY__ g_pwron_case = APP_POWERON_CASE_NORMAL; #else 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); } } void app_key_init(void) { #if defined(IBRT) app_ibrt_ui_test_key_init(); #else uint8_t i = 0; TRACE(1,"%s",__func__); app_key_handle_clear(); for (i=0; i<(sizeof(app_key_handle_cfg)/sizeof(APP_KEY_HANDLE)); i++){ app_key_handle_registration(&app_key_handle_cfg[i]); } #endif } void app_key_init_on_charging(void) { uint8_t i = 0; const APP_KEY_HANDLE key_cfg[] = { {{APP_KEY_CODE_PWR,APP_KEY_EVENT_REPEAT},"ota function key",app_ota_key_handler, NULL}, {{APP_KEY_CODE_PWR,APP_KEY_EVENT_CLICK},"bt function key",app_dfu_key_handler, NULL}, #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: touch_reset(); 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); osTimerId app_mute_timer = NULL; static void app_mute_timehandler(void const *n); osTimerDef (APP_MUTE_TIMER, app_mute_timehandler); /* static void app_mute_ctrl_init(void) { hal_iomux_init((struct HAL_IOMUX_PIN_FUNCTION_MAP *)&MuteOutPwl, 1); hal_gpio_pin_set_dir((enum HAL_GPIO_PIN_T)MuteOutPwl.pin, HAL_GPIO_DIR_OUT, 0); app_mute_timer = osTimerCreate (osTimer(APP_MUTE_TIMER), osTimerOnce, NULL); } */ void app_mute_ctrl(bool Status) { if(Status == true) { hal_gpio_pin_set((enum HAL_GPIO_PIN_T)MuteOutPwl.pin); } else { hal_gpio_pin_clr((enum HAL_GPIO_PIN_T)MuteOutPwl.pin); } } void app_mutetimer_start() { osTimerStart(app_mute_timer, 190); } static void app_mute_timehandler(void const *n) { app_mute_ctrl(true); } 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); #ifdef WL_DET app_mic_alg_audioloop(false,APP_SYSFREQ_78M); #endif #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); */ } void touch_evt_handler_sda(enum HAL_GPIO_PIN_T pin) { TRACE(3,"SDA_TOUCH!!!"); } void tou_io_init(void) { TRACE(3,"%s!!!",__func__); hal_iomux_init((struct HAL_IOMUX_PIN_FUNCTION_MAP *)&TOUCH_I2C_SCL, 1); hal_gpio_pin_set_dir((enum HAL_GPIO_PIN_T)TOUCH_I2C_SCL.pin, HAL_GPIO_DIR_IN, 1); hal_iomux_init((struct HAL_IOMUX_PIN_FUNCTION_MAP *)&TOUCH_I2C_SDA, 1); hal_gpio_pin_set_dir((enum HAL_GPIO_PIN_T)TOUCH_I2C_SDA.pin, HAL_GPIO_DIR_IN, 1); struct HAL_GPIO_IRQ_CFG_T gpiocfg_sda; gpiocfg_sda.irq_enable = true; gpiocfg_sda.irq_debounce = true; gpiocfg_sda.irq_type = HAL_GPIO_IRQ_TYPE_EDGE_SENSITIVE; gpiocfg_sda.irq_polarity=HAL_GPIO_IRQ_POLARITY_LOW_FALLING ; gpiocfg_sda.irq_handler = touch_evt_handler; hal_gpio_setup_irq((enum HAL_GPIO_PIN_T)TOUCH_I2C_SCL.pin, &gpiocfg_sda); struct HAL_GPIO_IRQ_CFG_T gpiocfg; gpiocfg.irq_enable = true; gpiocfg.irq_debounce = true; gpiocfg.irq_type = HAL_GPIO_IRQ_TYPE_EDGE_SENSITIVE; gpiocfg.irq_polarity=HAL_GPIO_IRQ_POLARITY_LOW_FALLING ; gpiocfg.irq_handler = touch_evt_handler_sda; hal_gpio_setup_irq((enum HAL_GPIO_PIN_T)TOUCH_I2C_SDA.pin, &gpiocfg); } /******************************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 touch_reset(void); osTimerId TOUCH_INT_TESTid = NULL; void startTOUCH_INT_TEST(int ms); void stopTOUCH_INT_TEST(void); static void TOUCH_INT_TESTfun(const void *); osTimerDef(defTOUCH_INT_TEST,TOUCH_INT_TESTfun); void TOUCH_INT_TESTinit(void) { TOUCH_INT_TESTid = osTimerCreate(osTimer(defTOUCH_INT_TEST),osTimerOnce,(void *)0); //startTOUCH_INT_TEST(100); //touch_reset(); } static void TOUCH_INT_TESTfun(const void *) { TRACE(3,"\n!!!!!!enter %s\n",__func__); //app_i2c_demo_init(); //hal_iomux_init((struct HAL_IOMUX_PIN_FUNCTION_MAP *)&TOUCH_INT, 1); //hal_gpio_pin_set_dir((enum HAL_GPIO_PIN_T)TOUCH_INT.pin, HAL_GPIO_DIR_IN, 0); tou_io_init(); } void startTOUCH_INT_TEST(int ms) { TRACE(3,"\n !!!!!!!!!!start %s\n",__func__); hal_iomux_init((struct HAL_IOMUX_PIN_FUNCTION_MAP *)&TOUCH_I2C_SCL, 1); hal_gpio_pin_set_dir((enum HAL_GPIO_PIN_T)TOUCH_I2C_SCL.pin, HAL_GPIO_DIR_OUT, 0); hal_iomux_init((struct HAL_IOMUX_PIN_FUNCTION_MAP *)&TOUCH_I2C_SDA, 1); hal_gpio_pin_set_dir((enum HAL_GPIO_PIN_T)TOUCH_I2C_SDA.pin, HAL_GPIO_DIR_OUT, 0); //hal_iomux_init((struct HAL_IOMUX_PIN_FUNCTION_MAP *)&TOUCH_INT, 1); //hal_gpio_pin_set_dir((enum HAL_GPIO_PIN_T)TOUCH_INT.pin, HAL_GPIO_DIR_OUT, 0); osTimerStart(TOUCH_INT_TESTid,ms); } void stopTOUCH_INT_TEST(void) { osTimerStop(TOUCH_INT_TESTid); } void touch_reset(void) { startTOUCH_INT_TEST(50); } /********************************TOUCH_INT_TEST_timer*******************************************************/ void user_io_timer_init(void) { //app_mute_ctrl_init(); LED_statusinit(); pwrkey_detinit(); Auto_Shutdowm_Timerinit(); delay_report_toneinit(); once_delay_event_Timer_init(); TOUCH_INT_TESTinit(); //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 bool need_check_key = false; #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"); #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(); TRACE(1,"BATTERY %d",nRet); 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 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(); /******************************************************************************/ hal_iomux_init((struct HAL_IOMUX_PIN_FUNCTION_MAP *)&TOUCH_I2C_SCL, 1); hal_gpio_pin_set_dir((enum HAL_GPIO_PIN_T)TOUCH_I2C_SCL.pin, HAL_GPIO_DIR_OUT, 1); hal_iomux_init((struct HAL_IOMUX_PIN_FUNCTION_MAP *)&TOUCH_I2C_SDA, 1); hal_gpio_pin_set_dir((enum HAL_GPIO_PIN_T)TOUCH_I2C_SDA.pin, HAL_GPIO_DIR_OUT, 1); /*****************************************************************************/ // app_bt_connect2tester_init(); nv_record_env_get(&nvrecord_env); #ifdef AUDIO_LOOPBACK #ifdef WL_DET app_mic_alg_audioloop(true,APP_SYSFREQ_78M); #endif while(1); #endif #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(); user_io_timer_init(); 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(); if(app_tws_is_right_side()){ TRACE(0,"app_start_tws_serching_direactly"); 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); } startLED_status(1000); once_event_case = 9; startonce_delay_event_Timer_(1000); startpwrkey_det(200); } #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{ user_io_timer_init(); app_status_indication_init(); 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; } startpwrkey_det(200); } #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 */