?? main.c
字號:
{
case headsetReady:
case headsetConnected:
case headsetIncomingCallEstablish:
case headsetOutgoingCallEstablish:
case headsetActiveCall:
hfpHeadsetHandleAudioDisconnectInd(&app);
break;
case headsetConnecting:
case headsetInitialising:
default:
unhandledHfpState(current_hfp_state, id);
}
break;
case HFP_MICROPHONE_VOLUME_CFM:
case HFP_MICROPHONE_VOLUME_IND:
case HFP_HS_BUTTON_PRESS_CFM:
case HFP_CALLER_ID_IND:
case HFP_LAST_NUMBER_REDIAL_CFM:
case HFP_DIAL_NUMBER_CFM:
case HFP_DIAL_MEMORY_CFM:
case HFP_SERVICE_IND:
case HFP_DISABLE_NREC_CFM:
case HFP_CALLER_ID_ENABLE_CFM:
case HFP_CALL_WAITING_ENABLE_CFM:
case HFP_DTMF_CFM:
case HFP_SINK_CFM:
case HFP_CALL_WAITING_IND:
case HFP_RELEASE_HELD_REJECT_WAITING_CALL_CFM:
case HFP_RELEASE_ACTIVE_ACCEPT_OTHER_CALL_CFM:
case HFP_HOLD_ACTIVE_ACCEPT_OTHER_CALL_CFM:
case HFP_ADD_HELD_CALL_CFM:
case HFP_EXPLICIT_CALL_TRANSFER_CFM:
case HFP_VOICE_TAG_NUMBER_CFM:
case HFP_ANSWER_CALL_CFM:
case HFP_REJECT_CALL_CFM:
case HFP_TERMINATE_CALL_CFM:
case HFP_EXTRA_INDICATOR_INDEX_IND:
case HFP_EXTRA_INDICATOR_UPDATE_IND:
case HFP_SPEAKER_VOLUME_CFM:
break;
default:
MAIN_DEBUG(("AV Headset - Unhandled hfp msg 0x%x\n",id));
break;
}
}
/**************************************************************************/
static void cl_msg_handler(MessageId id, Message message)
{
switch (id)
{
case CL_INIT_CFM:
MAIN_DEBUG(("CL_INIT_CFM\n"));
if(((CL_INIT_CFM_T*)message)->status == success)
{
/* Connection Library initialisation was a success, initailise the
A2DP library */
a2dp_init_params a2dp_config;
a2dp_config.role = a2dp_sink;
a2dp_config.priority = 512;
a2dp_config.size_service_record = 0;
a2dp_config.service_record = 0;
A2dpInit(getAppTask(), &a2dp_config);
}
else
{
Panic();
}
break;
case CL_SM_PIN_CODE_IND:
MAIN_DEBUG(("CL_SM_PIN_IND\n"));
headsetHandlePinCodeInd(&app, (CL_SM_PIN_CODE_IND_T*) message);
break;
case CL_SM_AUTHORISE_IND:
/*Only authorise if switched on*/
if ((app.headset_power_state != power_state_off) & (app.headset_power_state != power_state_off_charging))
{
MAIN_DEBUG(("CL_SM_AUTHORISE_IND\n"));
headsetHandleAuthoriseInd((CL_SM_AUTHORISE_IND_T*) message);
}
break;
case CL_SM_AUTHENTICATE_CFM:
MAIN_DEBUG(("CL_SM_AUTHENTICATE_CFM\n"));
headsetHandleAuthenticateCfm((CL_SM_AUTHENTICATE_CFM_T*) message);
break;
case CL_DM_REMOTE_FEATURES_CFM:
MAIN_DEBUG(("CL_DM_REMOTE_FEATURES_CFM\n"));
headsetHandleRemoteSuppFeatures(&app, (CL_DM_REMOTE_FEATURES_CFM_T *) message);
break;
case CL_SM_ENCRYPTION_CHANGE_IND:
case CL_DM_ROLE_CFM:
case CL_DM_INQUIRE_RESULT:
case CL_DM_REMOTE_NAME_COMPLETE:
case CL_DM_CLASS_OF_DEVICE_CFM:
case CL_DM_LOCAL_BD_ADDR_CFM:
case CL_DM_LINK_QUALITY_CFM:
case CL_DM_RSSI_CFM:
case CL_DM_CLOCK_OFFSET_CFM:
case CL_DM_ACL_OPENED_IND:
case CL_DM_ACL_CLOSED_IND:
case CL_SM_SECURITY_LEVEL_CFM:
case CL_SDP_UNREGISTER_CFM:
case CL_SDP_OPEN_SEARCH_CFM:
case CL_SDP_CLOSE_SEARCH_CFM:
case CL_SDP_SERVICE_SEARCH_CFM:
case CL_SDP_ATTRIBUTE_SEARCH_CFM:
case CL_SDP_SERVICE_SEARCH_ATTRIBUTE_CFM:
case CL_L2CAP_REGISTER_CFM:
case CL_L2CAP_UNREGISTER_CFM:
case CL_L2CAP_CONNECT_CFM:
case CL_L2CAP_CONNECT_IND:
case CL_L2CAP_DISCONNECT_IND:
case CL_RFCOMM_REGISTER_CFM:
case CL_RFCOMM_CONNECT_CFM:
case CL_RFCOMM_CONNECT_IND:
case CL_RFCOMM_DISCONNECT_IND:
case CL_RFCOMM_CONTROL_IND:
case CL_DM_LINK_POLICY_IND:
break;
default:
MAIN_DEBUG(("AV Headset - Unhandled CL msg 0x%x\n",id));
break;
}
}
static void app_msg_handler (MessageId id, Message message)
{
/* Get the current Headset states */
headsetAvrcpState current_avrcp_state = app.avrcp_state;
headsetHfpState current_hfp_state = app.hfp_state;
bool playErrorTone = FALSE ;
bool playButtonTone = FALSE;
switch ( id )
{
case APP_HEADSET_INIT_CFM:
MAIN_DEBUG(("APP_HEADSET_INIT_CFM\n"));
switch(current_hfp_state)
{
case headsetInitialising:
/* Headset initialisation complete */
headsetInitReset(&app);
break;
case headsetReady:
case headsetConnecting:
case headsetConnected:
case headsetOutgoingCallEstablish:
case headsetIncomingCallEstablish:
case headsetActiveCall:
default:
unhandledHfpState(current_hfp_state, id);
break;
}
break;
case APP_BATTERY_DEAD_IND:
MAIN_DEBUG(("APP_BATTERY_DEAD_IND\n"));
headsetPowerOff(&app);
break;
case APP_BATTERY_LOW_IND:
MAIN_DEBUG(("APP_BATTERY_LOW_IND\n"));
ledsPlay (RED_TWO_FLASHES_FAST);
headsetPlayTone(&app, tone_type_battery_low);
break;
case APP_BATTERY_FULL_IND:
MAIN_DEBUG(("APP_BATTERY_FULL_IND\n"));
/*This is only called if there is no built-in charger (BC3-MM)*/
app.battery_full = 1;
headsetIndicateState(&app);
break;
case APP_MUSIC_RESTART_IND:
MAIN_DEBUG(("APP_MUSIC_RESTART_IND\n"));
if (app.a2dp_state != avHeadsetA2dpStreaming)
{
MAIN_DEBUG(("Av not streaming\n"));
if(app.sent_suspend && app.av_stream_stopped)
avHeadsetAvStreamStart(&app);
}
else
{
avHeadsetAvStreamStart(&app);
}
break;
case APP_CHARGER_CONNECTED_IND:
MAIN_DEBUG(("APP_CHARGER_CONNECTED_IND\n"));
/*This is only called if there is no built-in charger (BC3-MM)*/
app.charger_connected = 1;
headsetIndicateState(&app);
break;
case APP_CHARGER_DISCONNECTED_IND:
MAIN_DEBUG(("APP_CHARGER_DISCONNECTED_IND\n"));
/*This is only called if there is no built-in charger (BC3-MM)*/
app.charger_connected = 0;
app.battery_full = 0;
headsetIndicateState(&app);
if ((app.headset_power_state != power_state_on) && (app.headset_power_state != power_state_on_charging))
{
MessageSendLater(&app.task, APP_POWER_OFF_IND, 0, 1000);
}
break;
case APP_DISCONNECT_HFP_SLC_IND:
MAIN_DEBUG(("APP_DISCONNECT_HFP_SLC_IND\n"));
/* The remote end disabled encryption so close down the SLC */
hfpHeadsetDisconnectSlc(&app);
break;
case APP_HFP_SLC_REQ:
MAIN_DEBUG(("APP_HFP_SLC_REQ\n"));
switch(current_hfp_state)
{
case headsetReady:
hfpHeadsetHandleSlcConnectRequest(&app, hfp_handsfree_profile);
break;
case headsetConnecting:
app.headset_connecting_hfp = 1;
break;
case headsetConnected:
case headsetIncomingCallEstablish:
case headsetActiveCall:
case headsetOutgoingCallEstablish:
case headsetInitialising:
default:
app.headset_connecting_hfp = 0;
}
break;
case APP_HFP_SLC_TIMEOUT_IND:
MAIN_DEBUG(("APP_HFP_SLC_TIMEOUT_IND\n"));
switch(current_hfp_state)
{
case headsetConnecting:
/* Now connect timeout has occured, don't try another reconnect attempt */
app.headset_connecting_hfp = 1;
break;
case headsetReady:
case headsetConnected:
case headsetIncomingCallEstablish:
case headsetActiveCall:
case headsetOutgoingCallEstablish:
case headsetInitialising:
default:
app.headset_connecting_hfp = 0;
}
break;
case APP_PAIR_MODE_END_IND:
MAIN_DEBUG(("APP_PAIR_MODE_END_IND\n"));
/* Pairing mode has timed out */
headsetExitPairingMode(&app);
break;
case APP_POWER_OFF_IND:
MAIN_DEBUG(("APP_POWER_OFF_IND\n"));
headsetPowerOff(&app);
break;
case APP_AMP_IDLE_IND:
MAIN_DEBUG(("APP_AMP_IDLE_IND\n"));
if ( app.media_sink || app.sco_sink)
{
MessageSendLater(getAppTask(), APP_AMP_IDLE_IND, 0, AMP_IDLE_TIMER);
}
else
{
headsetPowerAmp(&app, FALSE);
}
break;
case APP_POWER_ON_EVENT_SEEN:
MAIN_DEBUG(("APP_CHECK_POWER_ON_EVENT_SEEN\n"));
/*If there has been no power on event and the headset is not charging switch off*/
headsetPowerOff(&app);
break;
case APP_UNMUTE_MIC:
MAIN_DEBUG(("APP_UNMUTE_MIC\n"));
headsetVolumeCompleteUnmuteMicrophone(&app);
break;
case APP_MUTE_REMINDER:
MAIN_DEBUG(("APP_MUTE_REMINDER\n"));
if (app.hfp_state == headsetActiveCall)
{
headsetPlayTone(&app, tone_type_mute_remind);
VolumeMuteRemind(&app);
}
break;
case APP_PREVENT_POWER_ON:
MAIN_DEBUG(("APP_PREVENT_POWER_ON\n"));
break;
case APP_VOICE_DIAL:
MAIN_DEBUG(("APP_VOICE_DIAL\n"));
if (app.voice_recognition_enabled)
{
app.voice_recognition_enabled = FALSE;
}
else
{
app.voice_recognition_enabled = TRUE;
}
hfpHeadsetVoiceRecognitionEnable(&app, app.voice_recognition_enabled);
break;
case APP_RING_TIMEOUT_IND:
MAIN_DEBUG(("APP_RING_TIMEOUT_IND\n"));
if ((app.profile_connected == hfp_headset_profile) &&
!app.sco_sink &&
(app.hfp_state == headsetIncomingCallEstablish))
{
headsetRestartAV(&app);
}
break;
case APP_TONE_TO_PLAY_IND:
MAIN_DEBUG(("APP_TONE_TO_PLAY_IND\n"));
headsetPlayTone(&app, ((APP_TONE_TO_PLAY_IND_T *)message)->id);
break;
case APP_AVRCP_CONNECT_REQ:
MAIN_DEBUG(("APP_AVRCP_CONNECT_REQ\n"));
avHeadsetHandleAvrcpConnectReq(&app, ((APP_AVRCP_CONNECT_REQ_T *)message)->addr);
break;
case APP_AUTO_SWITCH_OFF_IND:
MAIN_DEBUG(("APP_AUTO_SWITCH_OFF_IND\n"));
headsetPowerOff(&app);
break;
case APP_BACKWARD_SHORT:
BUTTON_DEBUG(("APP_BACKWARD_SHORT\n"));
MessageCancelAll(&app.task, APP_BACKWARD_SHORT);
switch (app.headset_power_state)
{
case power_state_on:
case power_state_on_charging:
switch(current_avrcp_state)
{
case avHeadsetAvrcpConnected:
avHeadsetBackwardPress(&app);
avHeadsetBackwardRelease(&app);
headsetPlayTone(&app, tone_type_button_press);
break;
case avHeadsetAvrcpReady:
case avHeadsetAvrcpInitialising:
case avHeadsetAvrcpConnecting:
default:
unhandledAvrcpState(current_avrcp_state, id);
break;
}
break;
case power_state_off:
case power_state_off_charging:
default:
break;
}
break;
case APP_PLAY_PAUSE_SHORT:
BUTTON_DEBUG(("APP_PLAY_PAUSE_SHORT\n"));
MessageCancelAll(&app.task, APP_PLAY_PAUSE_SHORT);
switch (app.headset_power_state)
{
case power_state_off:
case power_state_off_charging:
break;
case power_state_on:
case power_state_on_charging:
if (isHeadsetPairing(&app))
{
headsetPlayTone(&app, tone_type_error);
}
else if (isHeadsetIdle(&app))
{
/* Connect the AV. */
headsetPlayTone(&app, tone_type_button_press);
avHeadsetHandleAvConnectRequest(&app);
}
else
{
if (current_hfp_state == headsetActiveCall)
{
/* Mute or un-mute the microphone */
headsetMicrophoneMuteToggle(&app);
}
else if ((current_hfp_state == headsetIncomingCallEstablish) ||
(current_hfp_state == headsetOutgoingCallEstablish) ||
(app.voice_recognition_enabled))
{
headsetPlayTone(&app, tone_type_button_press);
break;
?? 快捷鍵說明
復制代碼
Ctrl + C
搜索代碼
Ctrl + F
全屏模式
F11
切換主題
Ctrl + Shift + D
顯示快捷鍵
?
增大字號
Ctrl + =
減小字號
Ctrl + -