/*******************************************************************************
**
** Function btif_associate_evt
**
** Description Event indicating btif_task is up
** Attach btif_task to JVM
**
** Returns void
**
*******************************************************************************/
bt_status_t btif_associate_evt(void)
{
ALOGI("[btif_associate_evt]: notify ASSOCIATE_JVM!\n");
HAL_CBACK(bt_hal_cbacks, thread_evt_cb, ASSOCIATE_JVM);
return BT_STATUS_SUCCESS;
}
/*******************************************************************************
**
** Function btif_disable_bluetooth
**
** Description Inititates shutdown of Bluetooth system.
** Any active links will be dropped and device entering
** non connectable/discoverable mode
**
** Returns void
**
*******************************************************************************/
bt_status_t btif_disable_bluetooth(void)
{
tBTA_STATUS status;
if (!btif_is_enabled())
{
BTIF_TRACE_ERROR0("btif_disable_bluetooth : not yet enabled");
return BT_STATUS_NOT_READY;
}
bte_main_disable();
GKI_destroy_task(BTIF_TASK);
bte_main_shutdown();
BTIF_TRACE_DEBUG0("BTIF DISABLE BLUETOOTH");
btif_core_state = BTIF_CORE_STATE_DISABLED;
HAL_CBACK(bt_hal_cbacks, adapter_state_changed_cb, BT_STATE_OFF);
return BT_STATUS_SUCCESS;
}
static bt_status_t btif_associate_evt(void)
{
BTIF_TRACE_DEBUG1("%s: notify ASSOCIATE_JVM", __FUNCTION__);
HAL_CBACK(bt_hal_cbacks, thread_evt_cb, ASSOCIATE_JVM);
return BT_STATUS_SUCCESS;
}
/*******************************************************************************
**
** Function btif_disassociate_evt
**
** Description Event indicating btif_task is going down
** Detach btif_task to JVM
**
** Returns void
**
*******************************************************************************/
bt_status_t btif_disassociate_evt(void)
{
ALOGI("btif_disassociate_evt: notify DISASSOCIATE_JVM");
HAL_CBACK(bt_hal_cbacks, thread_evt_cb, DISASSOCIATE_JVM);
/* shutdown complete, all events notified and we reset HAL callbacks */
bt_hal_cbacks = NULL;
return BT_STATUS_SUCCESS;
}
static void process_ind_evt(tBTA_HF_CLIENT_IND *ind)
{
switch (ind->type)
{
case BTA_HF_CLIENT_IND_CALL:
HAL_CBACK(bt_hf_client_callbacks, call_cb, ind->value);
break;
case BTA_HF_CLIENT_IND_CALLSETUP:
HAL_CBACK(bt_hf_client_callbacks, callsetup_cb, ind->value);
break;
case BTA_HF_CLIENT_IND_CALLHELD:
HAL_CBACK(bt_hf_client_callbacks, callheld_cb, ind->value);
break;
case BTA_HF_CLIENT_IND_SERVICE:
HAL_CBACK(bt_hf_client_callbacks, network_state_cb, ind->value);
break;
case BTA_HF_CLIENT_IND_SIGNAL:
HAL_CBACK(bt_hf_client_callbacks, network_signal_cb, ind->value);
break;
case BTA_HF_CLIENT_IND_ROAM:
HAL_CBACK(bt_hf_client_callbacks, network_roaming_cb, ind->value);
break;
case BTA_HF_CLIENT_IND_BATTCH:
HAL_CBACK(bt_hf_client_callbacks, battery_level_cb, ind->value);
break;
default:
break;
}
}
void btif_enable_bluetooth_evt(tBTA_STATUS status)
{
if(status == BT_STATE_ON)
btif_core_state = BTIF_CORE_STATE_ENABLED;
else
btif_core_state = BTIF_CORE_STATE_DISABLED;
HAL_CBACK(bt_hal_cbacks, adapter_state_changed_cb, status);
}
static bt_status_t btif_disassociate_evt(void)
{
BTIF_TRACE_DEBUG1("%s: notify DISASSOCIATE_JVM", __FUNCTION__);
HAL_CBACK(bt_hal_cbacks, thread_evt_cb, DISASSOCIATE_JVM);
/* shutdown complete, all events notified and we reset HAL callbacks */
bt_hal_cbacks = NULL;
return BT_STATUS_SUCCESS;
}
void btif_enable_bluetooth_evt(uint8_t status)
{
ALOGI("+++[btif_enable_bluetooth_evt]+++!\n");
if(status == BT_STATUS_SUCCESS)
{
//init profile
/* init rfcomm & l2cap api */
btif_sock_init();
btif_core_state = BTIF_CORE_STATE_ENABLED;
HAL_CBACK(bt_hal_cbacks, adapter_state_changed_cb, BT_STATE_ON);
}
else
{
//clean profile
/* cleanup rfcomm & l2cap api */
btif_sock_cleanup();
btif_core_state = BTIF_CORE_STATE_DISABLED;
HAL_CBACK(bt_hal_cbacks, adapter_state_changed_cb, BT_STATE_OFF);
}
ALOGI("---[btif_enable_bluetooth_evt]---!\n");
}
/*******************************************************************************
**
** Function btif_in_hf_generic_evt
**
** Description Processes generic events to be sent to JNI that are not triggered from the BTA.
** Always runs in BTIF context
**
** Returns void
**
*******************************************************************************/
static void btif_in_hf_generic_evt(UINT16 event, char *p_param)
{
BTIF_TRACE_EVENT2("%s: event=%d", __FUNCTION__, event);
switch (event) {
case BTIF_HFP_CB_AUDIO_CONNECTING:
{
HAL_CBACK(bt_hf_callbacks, audio_state_cb, BTHF_AUDIO_STATE_CONNECTING,
&btif_hf_cb.connected_bda);
} break;
default:
{
BTIF_TRACE_WARNING2("%s : Unknown event 0x%x", __FUNCTION__, event);
}
break;
}
}
void btif_disable_bluetooth_evt(void)
{
ilm_struct ilm;
int result;
ALOGI("+++[btif_disable_bluetooth_evt]+++!\n");
/* update local state */
btif_core_state = BTIF_CORE_STATE_DISABLED;
/* callback to HAL */
HAL_CBACK(bt_hal_cbacks, adapter_state_changed_cb, BT_STATE_OFF);
if (btif_shutdown_pending)
{
ALOGI("[btif_disable_bluetooth_evt]:btif_shutdown_bluetooth!\n");
btif_shutdown_bluetooth();
}
ALOGI("---[btif_disable_bluetooth_evt]---!\n");
}
static bt_status_t btif_mp_notify_evt(void* msg)
{
BT_HDR *p_msg = (BT_HDR *)msg;
char *p = (char *)(p_msg + 1);
UINT8 mp_op_code;
UINT8 mp_op_paraLen;
STREAM_TO_UINT8 (mp_op_code, p);
STREAM_TO_UINT8 (mp_op_paraLen, p);
BTIF_TRACE_DEBUG2("%s: notify1 :%s", __FUNCTION__, p);
p[mp_op_paraLen] = NULL;
BTIF_TRACE_DEBUG2("%s: notify2 :%s", __FUNCTION__, p);
HAL_CBACK(bt_hal_cbacks, dut_mode_recv_cb, mp_op_code, p);
return BT_STATUS_SUCCESS;
}
static void btif_mce_mas_discovery_comp_evt(UINT16 event, char *p_param)
{
tBTA_MCE_MAS_DISCOVERY_COMP *evt_data = (tBTA_MCE_MAS_DISCOVERY_COMP*) p_param;
btmce_mas_instance_t insts[BTA_MCE_MAX_MAS_INSTANCES];
bt_bdaddr_t addr;
int i;
BTIF_TRACE_EVENT("%s: event = %d", __FUNCTION__, event);
if (event != BTA_MCE_MAS_DISCOVERY_COMP_EVT)
return;
for (i = 0; i < evt_data->num_mas; i++)
{
insts[i].id = evt_data->mas[i].instance_id;
insts[i].scn = evt_data->mas[i].scn;
insts[i].msg_types = evt_data->mas[i].msg_type;
insts[i].p_name = evt_data->mas[i].p_srv_name;
}
bdcpy(addr.address, evt_data->remote_addr);
HAL_CBACK(bt_mce_callbacks, remote_mas_instances_cb, evt_data->status, &addr, evt_data->num_mas, insts);
}
static void btif_task(UINT32 params)
{
UINT16 event;
BT_HDR *p_msg;
BTIF_TRACE_DEBUG0("btif task starting");
btif_associate_evt();
for(;;)
{
/* wait for specified events */
event = GKI_wait(0xFFFF, 0);
/*
* Wait for the trigger to init chip and stack. This trigger will
* be received by btu_task once the UART is opened and ready
*/
if (event == BT_EVT_TRIGGER_STACK_INIT)
{
BTIF_TRACE_DEBUG0("btif_task: received trigger stack init event");
btif_enable_bluetooth_evt(BT_STATE_ON);
}
/*
* Failed to initialize controller hardware, reset state and bring
* down all threads
*/
if (event == BT_EVT_HARDWARE_INIT_FAIL)
{
BTIF_TRACE_DEBUG0("btif_task: hardware init failed");
bte_main_disable();
GKI_task_self_cleanup(BTIF_TASK);
bte_main_shutdown();
btif_dut_mode = 0;
btif_core_state = BTIF_CORE_STATE_DISABLED;
HAL_CBACK(bt_hal_cbacks,adapter_state_changed_cb,BT_STATE_OFF);
break;
}
if (event & EVENT_MASK(GKI_SHUTDOWN_EVT))
break;
if(event & TASK_MBOX_1_EVT_MASK)
{
while((p_msg = GKI_read_mbox(BTU_BTIF_MBOX)) != NULL)
{
BTIF_TRACE_VERBOSE1("btif task fetched event %x", p_msg->event);
switch (p_msg->event)
{
case BT_EVT_CONTEXT_SWITCH_EVT:
btif_context_switched(p_msg);
break;
case BT_EVT_RX:
btif_mp_test_evt(p_msg);
break;
case BT_EVT_MP_NOTIFY_BTIF:
btif_mp_notify_evt(p_msg);
break;
default:
BTIF_TRACE_ERROR1("unhandled btif event (%d)", p_msg->event & BT_EVT_MASK);
break;
}
GKI_freebuf(p_msg);
}
}
}
btif_disassociate_evt();
BTIF_TRACE_DEBUG0("btif task exiting");
}
/* This function is used for handling message send from internal */
void btmtk_a2dp_ext_msg_handler(void *pContext, ilm_struct *ilm)
{
U8 iResult = A2DP_STATUS_NO_CHANGE;
bt_addr_struct addr;
iResult = btmtk_a2dp_handle_message(ilm);
bt_ext_log("a2dp ext hdl result: %d", iResult);
btmtk_a2dp_get_bdaddr(&addr);
btmtk_util_convert_bdaddr2array(&(btif_av_cb.peer_bda), &addr);
switch(iResult)
{
case A2DP_STATUS_CHANGE_DISCONNECTED:
{
//Notify Profile Manager A2DP connection status been changed
notifyProfileStateChanged(&addr,PROFILE_A2DP,PROFILE_STATE_DISCONNECTED);
//Callback status change to framework
HAL_CBACK(bt_av_callbacks, connection_state_cb,
BTAV_CONNECTION_STATE_DISCONNECTED, &(btif_av_cb.peer_bda));
break;
}
case A2DP_STATUS_CHANGE_CONNECTING:
{
HAL_CBACK(bt_av_callbacks, connection_state_cb,
BTAV_CONNECTION_STATE_CONNECTING, &(btif_av_cb.peer_bda));
break;
}
case A2DP_STATUS_CHANGE_CONNECTED:
{
notifyProfileStateChanged(&addr,PROFILE_A2DP,PROFILE_STATE_CONNECTED);
HAL_CBACK(bt_av_callbacks, connection_state_cb,
BTAV_CONNECTION_STATE_CONNECTED, &(btif_av_cb.peer_bda));
break;
}
case A2DP_STATUS_CHANGE_PLAYING:
{
HAL_CBACK(bt_av_callbacks, audio_state_cb,
BTAV_AUDIO_STATE_STARTED, &(btif_av_cb.peer_bda));
break;
}
#ifdef __BTMTK__
#ifdef MTK_BT_FM_OVER_BT_VIA_CONTROLLER
case A2DP_STATUS_FM_PLAYING_FAILED:
{
HAL_CBACK(bt_av_callbacks, audio_state_cb,
BTAV_AUDIO_STATE_REMOTE_SUSPEND, &(btif_av_cb.peer_bda));
break;
}
#endif
#endif
}
}
/*******************************************************************************
**
** Function btif_hd_upstreams_evt
**
** Description Executes events in btif context
**
** Returns void
**
*******************************************************************************/
static void btif_hd_upstreams_evt(UINT16 event, char* p_param)
{
tBTA_HD *p_data = (tBTA_HD *)p_param;
BTIF_TRACE_API("%s: event=%s", __FUNCTION__, dump_hd_event(event));
switch (event)
{
case BTA_HD_ENABLE_EVT:
BTIF_TRACE_DEBUG("%s: status=%d", __FUNCTION__, p_data->status);
if (p_data->status == BTA_HD_OK)
{
btif_storage_load_hidd();
btif_hd_cb.status = BTIF_HD_ENABLED;
}
else
{
btif_hd_cb.status = BTIF_HD_DISABLED;
BTIF_TRACE_WARNING("Failed to enable BT-HD, status=%d", p_data->status);
}
break;
case BTA_HD_DISABLE_EVT:
BTIF_TRACE_DEBUG("%s: status=%d", __FUNCTION__, p_data->status);
btif_hd_cb.status = BTIF_HD_DISABLED;
if (p_data->status == BTA_HD_OK)
memset(&btif_hd_cb, 0, sizeof(btif_hd_cb));
else
BTIF_TRACE_WARNING("Failed to disable BT-HD, status=%d", p_data->status);
break;
case BTA_HD_REGISTER_APP_EVT:
{
bt_bdaddr_t *addr = (bt_bdaddr_t*) &p_data->reg_status.bda;
if (!p_data->reg_status.in_use)
{
addr = NULL;
}
btif_hd_cb.app_registered = TRUE;
HAL_CBACK(bt_hd_callbacks, application_state_cb, addr, BTHD_APP_STATE_REGISTERED);
}
break;
case BTA_HD_UNREGISTER_APP_EVT:
btif_hd_cb.app_registered = FALSE;
HAL_CBACK(bt_hd_callbacks, application_state_cb, NULL, BTHD_APP_STATE_NOT_REGISTERED);
break;
case BTA_HD_OPEN_EVT:
btif_storage_set_hidd((bt_bdaddr_t*) &p_data->conn.bda);
HAL_CBACK(bt_hd_callbacks, connection_state_cb, (bt_bdaddr_t*) &p_data->conn.bda,
BTHD_CONN_STATE_CONNECTED);
break;
case BTA_HD_CLOSE_EVT:
HAL_CBACK(bt_hd_callbacks, connection_state_cb, (bt_bdaddr_t*) &p_data->conn.bda,
BTHD_CONN_STATE_DISCONNECTED);
break;
case BTA_HD_GET_REPORT_EVT:
HAL_CBACK(bt_hd_callbacks, get_report_cb,
p_data->get_report.report_type, p_data->get_report.report_id,
p_data->get_report.buffer_size);
break;
case BTA_HD_SET_REPORT_EVT:
HAL_CBACK(bt_hd_callbacks, set_report_cb, p_data->set_report.report_type,
p_data->set_report.report_id, p_data->set_report.len,
p_data->set_report.p_data);
break;
case BTA_HD_SET_PROTOCOL_EVT:
HAL_CBACK(bt_hd_callbacks, set_protocol_cb, p_data->set_protocol);
break;
case BTA_HD_INTR_DATA_EVT:
HAL_CBACK(bt_hd_callbacks, intr_data_cb, p_data->intr_data.report_id,
p_data->intr_data.len, p_data->intr_data.p_data);
break;
case BTA_HD_VC_UNPLUG_EVT:
HAL_CBACK(bt_hd_callbacks, connection_state_cb, (bt_bdaddr_t*) &p_data->conn.bda,
BTHD_CONN_STATE_DISCONNECTED);
if (bta_dm_check_if_only_hd_connected(p_data->conn.bda)) {
BTIF_TRACE_DEBUG("%s: Removing bonding as only HID profile connected",
__FUNCTION__);
BTA_DmRemoveDevice((UINT8 *) &p_data->conn.bda);
} else {
bt_bdaddr_t *bd_addr = (bt_bdaddr_t*)&p_data->conn.bda;
BTIF_TRACE_DEBUG("%s: Only removing HID data as some other profiles "
"connected", __FUNCTION__);
btif_hd_remove_device(*bd_addr);
}
HAL_CBACK(bt_hd_callbacks, vc_unplug_cb);
break;
default:
BTIF_TRACE_WARNING("%s: unknown event (%d)", __FUNCTION__, event);
break;
}
}
/*******************************************************************************
**
** Function btif_hf_client_upstreams_evt
**
** Description Executes HF CLIENT UPSTREAMS events in btif context
**
** Returns void
**
*******************************************************************************/
static void btif_hf_client_upstreams_evt(UINT16 event, char* p_param)
{
tBTA_HF_CLIENT *p_data = (tBTA_HF_CLIENT *)p_param;
bdstr_t bdstr;
BTIF_TRACE_DEBUG("%s: event=%s (%u)", __FUNCTION__, dump_hf_client_event(event), event);
switch (event)
{
case BTA_HF_CLIENT_ENABLE_EVT:
case BTA_HF_CLIENT_DISABLE_EVT:
break;
case BTA_HF_CLIENT_REGISTER_EVT:
btif_hf_client_cb.handle = p_data->reg.handle;
break;
case BTA_HF_CLIENT_OPEN_EVT:
if (p_data->open.status == BTA_HF_CLIENT_SUCCESS)
{
bdcpy(btif_hf_client_cb.connected_bda.address, p_data->open.bd_addr);
btif_hf_client_cb.state = BTHF_CLIENT_CONNECTION_STATE_CONNECTED;
btif_hf_client_cb.peer_feat = 0;
btif_hf_client_cb.chld_feat = 0;
//clear_phone_state();
}
else if (btif_hf_client_cb.state == BTHF_CLIENT_CONNECTION_STATE_CONNECTING)
{
btif_hf_client_cb.state = BTHF_CLIENT_CONNECTION_STATE_DISCONNECTED;
}
else
{
BTIF_TRACE_WARNING("%s: HF CLient open failed, but another device connected. status=%d state=%d connected device=%s",
__FUNCTION__, p_data->open.status, btif_hf_client_cb.state, bdaddr_to_string(&btif_hf_client_cb.connected_bda, bdstr, sizeof(bdstr)));
break;
}
HAL_CBACK(bt_hf_client_callbacks, connection_state_cb, btif_hf_client_cb.state,
0, 0, &btif_hf_client_cb.connected_bda);
if (btif_hf_client_cb.state == BTHF_CLIENT_CONNECTION_STATE_DISCONNECTED)
bdsetany(btif_hf_client_cb.connected_bda.address);
if (p_data->open.status != BTA_HF_CLIENT_SUCCESS)
btif_queue_advance();
break;
case BTA_HF_CLIENT_CONN_EVT:
btif_hf_client_cb.peer_feat = p_data->conn.peer_feat;
btif_hf_client_cb.chld_feat = p_data->conn.chld_feat;
btif_hf_client_cb.state = BTHF_CLIENT_CONNECTION_STATE_SLC_CONNECTED;
HAL_CBACK(bt_hf_client_callbacks, connection_state_cb, btif_hf_client_cb.state,
btif_hf_client_cb.peer_feat, btif_hf_client_cb.chld_feat,
&btif_hf_client_cb.connected_bda);
/* Inform the application about in-band ringtone */
if (btif_hf_client_cb.peer_feat & BTA_HF_CLIENT_PEER_INBAND)
{
HAL_CBACK(bt_hf_client_callbacks, in_band_ring_tone_cb, BTHF_CLIENT_IN_BAND_RINGTONE_PROVIDED);
}
btif_queue_advance();
break;
case BTA_HF_CLIENT_CLOSE_EVT:
btif_hf_client_cb.state = BTHF_CLIENT_CONNECTION_STATE_DISCONNECTED;
HAL_CBACK(bt_hf_client_callbacks, connection_state_cb, btif_hf_client_cb.state,
0, 0, &btif_hf_client_cb.connected_bda);
bdsetany(btif_hf_client_cb.connected_bda.address);
btif_hf_client_cb.peer_feat = 0;
btif_hf_client_cb.chld_feat = 0;
btif_queue_advance();
break;
case BTA_HF_CLIENT_IND_EVT:
process_ind_evt(&p_data->ind);
break;
case BTA_HF_CLIENT_MIC_EVT:
HAL_CBACK(bt_hf_client_callbacks, volume_change_cb, BTHF_CLIENT_VOLUME_TYPE_MIC, p_data->val.value);
break;
case BTA_HF_CLIENT_SPK_EVT:
HAL_CBACK(bt_hf_client_callbacks, volume_change_cb, BTHF_CLIENT_VOLUME_TYPE_SPK, p_data->val.value);
break;
case BTA_HF_CLIENT_VOICE_REC_EVT:
HAL_CBACK(bt_hf_client_callbacks, vr_cmd_cb, p_data->val.value);
break;
case BTA_HF_CLIENT_OPERATOR_NAME_EVT:
HAL_CBACK(bt_hf_client_callbacks, current_operator_cb, p_data->operator.name);
break;
case BTA_HF_CLIENT_CLIP_EVT:
HAL_CBACK(bt_hf_client_callbacks, clip_cb, p_data->number.number);
break;
case BTA_HF_CLIENT_BINP_EVT:
HAL_CBACK(bt_hf_client_callbacks, last_voice_tag_number_callback, p_data->number.number);
break;
case BTA_HF_CLIENT_CCWA_EVT:
HAL_CBACK(bt_hf_client_callbacks, call_waiting_cb, p_data->number.number);
break;
case BTA_HF_CLIENT_AT_RESULT_EVT:
HAL_CBACK(bt_hf_client_callbacks, cmd_complete_cb, p_data->result.type, p_data->result.cme);
break;
case BTA_HF_CLIENT_CLCC_EVT:
HAL_CBACK(bt_hf_client_callbacks, current_calls_cb, p_data->clcc.idx,
p_data->clcc.inc ? BTHF_CLIENT_CALL_DIRECTION_INCOMING : BTHF_CLIENT_CALL_DIRECTION_OUTGOING,
p_data->clcc.status,
p_data->clcc.mpty ? BTHF_CLIENT_CALL_MPTY_TYPE_MULTI : BTHF_CLIENT_CALL_MPTY_TYPE_SINGLE,
p_data->clcc.number_present ? p_data->clcc.number : NULL);
break;
case BTA_HF_CLIENT_CNUM_EVT:
if (p_data->cnum.service == 4)
{
HAL_CBACK(bt_hf_client_callbacks, subscriber_info_cb, p_data->cnum.number, BTHF_CLIENT_SERVICE_VOICE);
}
else if (p_data->cnum.service == 5)
{
HAL_CBACK(bt_hf_client_callbacks, subscriber_info_cb, p_data->cnum.number, BTHF_CLIENT_SERVICE_FAX);
}
else
{
HAL_CBACK(bt_hf_client_callbacks, subscriber_info_cb, p_data->cnum.number, BTHF_CLIENT_SERVICE_UNKNOWN);
}
break;
case BTA_HF_CLIENT_BTRH_EVT:
if (p_data->val.value <= BTRH_CLIENT_RESP_AND_HOLD_REJECT)
{
HAL_CBACK(bt_hf_client_callbacks, resp_and_hold_cb, p_data->val.value);
}
break;
case BTA_HF_CLIENT_BSIR_EVT:
if (p_data->val.value != 0)
{
HAL_CBACK(bt_hf_client_callbacks, in_band_ring_tone_cb, BTHF_CLIENT_IN_BAND_RINGTONE_PROVIDED);
}
else
{
HAL_CBACK(bt_hf_client_callbacks, in_band_ring_tone_cb, BTHF_CLIENT_IN_BAND_RINGTONE_NOT_PROVIDED);
}
break;
case BTA_HF_CLIENT_AUDIO_OPEN_EVT:
HAL_CBACK(bt_hf_client_callbacks, audio_state_cb, BTHF_CLIENT_AUDIO_STATE_CONNECTED, &btif_hf_client_cb.connected_bda);
break;
case BTA_HF_CLIENT_AUDIO_MSBC_OPEN_EVT:
HAL_CBACK(bt_hf_client_callbacks, audio_state_cb, BTHF_CLIENT_AUDIO_STATE_CONNECTED_MSBC, &btif_hf_client_cb.connected_bda);
break;
case BTA_HF_CLIENT_AUDIO_CLOSE_EVT:
HAL_CBACK(bt_hf_client_callbacks, audio_state_cb, BTHF_CLIENT_AUDIO_STATE_DISCONNECTED, &btif_hf_client_cb.connected_bda);
break;
case BTA_HF_CLIENT_RING_INDICATION:
HAL_CBACK(bt_hf_client_callbacks, ring_indication_cb);
break;
default:
BTIF_TRACE_WARNING("%s: Unhandled event: %d", __FUNCTION__, event);
break;
}
}
/*******************************************************************************
**
** Function btif_hf_upstreams_evt
**
** Description Executes HF UPSTREAMS events in btif context
**
** Returns void
**
*******************************************************************************/
static void btif_hf_upstreams_evt(UINT16 event, char* p_param)
{
tBTA_AG *p_data = (tBTA_AG *)p_param;
bdstr_t bdstr;
BTIF_TRACE_DEBUG2("%s: event=%s", __FUNCTION__, dump_hf_event(event));
switch (event)
{
case BTA_AG_ENABLE_EVT:
case BTA_AG_DISABLE_EVT:
break;
case BTA_AG_REGISTER_EVT:
btif_hf_cb.handle = p_data->reg.hdr.handle;
break;
case BTA_AG_OPEN_EVT:
if (p_data->open.status == BTA_AG_SUCCESS)
{
bdcpy(btif_hf_cb.connected_bda.address, p_data->open.bd_addr);
btif_hf_cb.state = BTHF_CONNECTION_STATE_CONNECTED;
btif_hf_cb.peer_feat = 0;
clear_phone_state();
}
else if (btif_hf_cb.state == BTHF_CONNECTION_STATE_CONNECTING)
{
btif_hf_cb.state = BTHF_CONNECTION_STATE_DISCONNECTED;
}
else
{
BTIF_TRACE_WARNING4("%s: AG open failed, but another device connected. status=%d state=%d connected device=%s",
__FUNCTION__, p_data->open.status, btif_hf_cb.state, bd2str(&btif_hf_cb.connected_bda, &bdstr));
break;
}
HAL_CBACK(bt_hf_callbacks, connection_state_cb, btif_hf_cb.state, &btif_hf_cb.connected_bda);
if (btif_hf_cb.state == BTHF_CONNECTION_STATE_DISCONNECTED)
bdsetany(btif_hf_cb.connected_bda.address);
if (p_data->open.status != BTA_AG_SUCCESS)
btif_queue_advance();
break;
case BTA_AG_CLOSE_EVT:
btif_hf_cb.state = BTHF_CONNECTION_STATE_DISCONNECTED;
HAL_CBACK(bt_hf_callbacks, connection_state_cb, btif_hf_cb.state, &btif_hf_cb.connected_bda);
bdsetany(btif_hf_cb.connected_bda.address);
btif_hf_cb.peer_feat = 0;
clear_phone_state();
/* If AG_OPEN was received but SLC was not setup in a specified time (10 seconds),
** then AG_CLOSE may be received. We need to advance the queue here
*/
btif_queue_advance();
break;
case BTA_AG_CONN_EVT:
btif_hf_cb.peer_feat = p_data->conn.peer_feat;
btif_hf_cb.state = BTHF_CONNECTION_STATE_SLC_CONNECTED;
HAL_CBACK(bt_hf_callbacks, connection_state_cb, btif_hf_cb.state,
&btif_hf_cb.connected_bda);
btif_queue_advance();
break;
case BTA_AG_AUDIO_OPEN_EVT:
HAL_CBACK(bt_hf_callbacks, audio_state_cb, BTHF_AUDIO_STATE_CONNECTED, &btif_hf_cb.connected_bda);
break;
case BTA_AG_AUDIO_CLOSE_EVT:
HAL_CBACK(bt_hf_callbacks, audio_state_cb, BTHF_AUDIO_STATE_DISCONNECTED, &btif_hf_cb.connected_bda);
break;
/* BTA auto-responds, silently discard */
case BTA_AG_SPK_EVT:
case BTA_AG_MIC_EVT:
HAL_CBACK(bt_hf_callbacks, volume_cmd_cb,
(event == BTA_AG_SPK_EVT) ? BTHF_VOLUME_TYPE_SPK : BTHF_VOLUME_TYPE_MIC, p_data->val.num);
break;
case BTA_AG_AT_A_EVT:
HAL_CBACK(bt_hf_callbacks, answer_call_cmd_cb);
break;
/* Java needs to send OK/ERROR for these commands */
case BTA_AG_AT_BLDN_EVT:
case BTA_AG_AT_D_EVT:
HAL_CBACK(bt_hf_callbacks, dial_call_cmd_cb,
(event == BTA_AG_AT_D_EVT) ? p_data->val.str : NULL);
break;
case BTA_AG_AT_CHUP_EVT:
HAL_CBACK(bt_hf_callbacks, hangup_call_cmd_cb);
break;
case BTA_AG_AT_CIND_EVT:
HAL_CBACK(bt_hf_callbacks, cind_cmd_cb);
break;
case BTA_AG_AT_VTS_EVT:
HAL_CBACK(bt_hf_callbacks, dtmf_cmd_cb, p_data->val.str[0]);
break;
case BTA_AG_AT_BVRA_EVT:
HAL_CBACK(bt_hf_callbacks, vr_cmd_cb,
(p_data->val.num == 1) ? BTHF_VR_STATE_STARTED : BTHF_VR_STATE_STOPPED);
break;
case BTA_AG_AT_NREC_EVT:
HAL_CBACK(bt_hf_callbacks, nrec_cmd_cb,
(p_data->val.num == 1) ? BTHF_NREC_START : BTHF_NREC_STOP);
break;
/* TODO: Add a callback for CBC */
case BTA_AG_AT_CBC_EVT:
break;
case BTA_AG_AT_CKPD_EVT:
HAL_CBACK(bt_hf_callbacks, key_pressed_cmd_cb);
break;
/* Java needs to send OK/ERROR for these commands */
case BTA_AG_AT_CHLD_EVT:
HAL_CBACK(bt_hf_callbacks, chld_cmd_cb, atoi(p_data->val.str));
break;
case BTA_AG_AT_CLCC_EVT:
HAL_CBACK(bt_hf_callbacks, clcc_cmd_cb, p_data->val.num);
break;
case BTA_AG_AT_COPS_EVT:
HAL_CBACK(bt_hf_callbacks, cops_cmd_cb);
break;
case BTA_AG_AT_UNAT_EVT:
HAL_CBACK(bt_hf_callbacks, unknown_at_cmd_cb,
p_data->val.str);
break;
case BTA_AG_AT_CNUM_EVT:
HAL_CBACK(bt_hf_callbacks, cnum_cmd_cb);
break;
/* TODO: Some of these commands may need to be sent to app. For now respond with error */
case BTA_AG_AT_BINP_EVT:
case BTA_AG_AT_BTRH_EVT:
send_at_result(BTA_AG_OK_ERROR, BTA_AG_ERR_OP_NOT_SUPPORTED);
break;
default:
BTIF_TRACE_WARNING2("%s: Unhandled event: %d", __FUNCTION__, event);
break;
}
}
