main.c

针对bluelab3.42的handsfree车载蓝牙的参考

            case headsetInitialising:
            case headsetReady:
            default:
                unhandledHfpState(current_hfp_state, id);
            }
            break;

        case HFP_VOICE_RECOGNITION_ENABLE_CFM:
            MAIN_DEBUG(("HFP_VOICE_RECOGNITION_ENABLE_CFM %d\n",((HFP_VOICE_RECOGNITION_ENABLE_CFM_T *) message)->status));
            switch(current_hfp_state)
            {
            case headsetConnected:
                hfpHeadsetHandleVoiceRecognitionCfm(&app, (HFP_VOICE_RECOGNITION_ENABLE_CFM_T *) message);
                break;

            case headsetActiveCall:
            case headsetOutgoingCallEstablish:
            case headsetIncomingCallEstablish:
            case headsetConnecting:
            case headsetInitialising:
            case headsetReady:
            default:
                unhandledHfpState(current_hfp_state, id);
            }
            break;        
            
        case HFP_ENCRYPTION_CHANGE_IND:
            MAIN_DEBUG(("HFP_ENCRYPTION_CHANGE_IND %d\n",((HFP_ENCRYPTION_CHANGE_IND_T *)message)->encrypted));
            
            switch(current_hfp_state)
            {
            case headsetConnecting:
            case headsetConnected:
            case headsetIncomingCallEstablish:
            case headsetOutgoingCallEstablish:
            case headsetActiveCall:
                if (((HFP_ENCRYPTION_CHANGE_IND_T *)message)->encrypted == FALSE)
                    MessageSendLater(getAppTask(), APP_DISCONNECT_HFP_SLC_IND, 0, (uint32) 5000);
                else
                    (void) MessageCancelAll(getAppTask(), APP_DISCONNECT_HFP_SLC_IND);
                break;

            case headsetReady:
            case headsetInitialising:
            default:
                unhandledHfpState(current_hfp_state, id);
            }
                
            break;

        case HFP_SPEAKER_VOLUME_IND:
            MAIN_DEBUG(("HFP_SPEAKER_VOLUME_IND\n"));
            /* Update the local valume and the actual gain setting */
            app.speaker_volume.hfp_volume = (uint8)((HFP_SPEAKER_VOLUME_IND_T *) message)->volume_gain;           
            /* Update the local volume */
            if (app.sco_sink)
            {
#ifdef INCLUDE_CVC
			CvcHeadsetVolume(&app);
#else
            headsetUpdateVolume(app.codec_task, app.speaker_volume.hfp_volume);
#endif
            }
            break;

		case HFP_UNRECOGNISED_AT_CMD_IND:
            {
                uint16 i;
                HFP_UNRECOGNISED_AT_CMD_IND_T *ind = (HFP_UNRECOGNISED_AT_CMD_IND_T *) message;
    
				MAIN_DEBUG(("HFP_UNRECOGNISED_AT_CMD_IND len %d\n", ind->size_data));
                for (i=0; i<ind->size_data; i++)
                {
                    MAIN_DEBUG(("%c", ind->data[i]));
                }
                MAIN_DEBUG(("\n"));

            }
            break;        

        case HFP_AUDIO_CONNECT_IND:
            MAIN_DEBUG(("HFP_AUDIO_CONNECT_IND\n"));
            hfpHeadsetHandleAudioConnectInd(&app, (HFP_AUDIO_CONNECT_IND_T *)message);
            break;

        case HFP_AUDIO_CONNECT_CFM:
            MAIN_DEBUG(("HFP_AUDIO_CONNECT_CFM\n"));
            switch(current_hfp_state)
            {
            case headsetConnecting:
				/* 
					If we have received a SCO indication before the SLC is up assume 
					phone has performed call transfer early and cancel the queued 
					button press event. 
				*/
                (void) MessageCancelAll(&app.task, BUTTON_MFB_SHORT);
				(void) MessageCancelAll(&app.task, BUTTON_MFB_LONG_RELEASE);

				/* Still handle the SCO indication as normal */
				hfpHeadsetHandleAudioConnectCfm(&app, (HFP_AUDIO_CONNECT_CFM_T *) message);
				break;

            case headsetConnected:
            case headsetIncomingCallEstablish:
            case headsetOutgoingCallEstablish:
            case headsetActiveCall:
                hfpHeadsetHandleAudioConnectCfm(&app, (HFP_AUDIO_CONNECT_CFM_T *) message);
                break;

            case headsetInitialising:
            case headsetReady:
            default:
                unhandledHfpState(current_hfp_state, id);
            }
            break;

        case HFP_AUDIO_DISCONNECT_IND:
            MAIN_DEBUG(("HFP_AUDIO_DISCONNECT_IND\n"));
            switch(current_hfp_state)
            {
            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;
    }
}


/*************************************************************************
NAME    
    app_handler
    
DESCRIPTION
    This is the main message handler for the AV Headset Application.  All
    messages pass through this handler.

RETURNS

*/
static void app_handler(Task task, MessageId id, Message message)
{
	
	
    /* Get the current Headset states */
    headsetA2dpState current_a2dp_state = app.a2dp_state;
    headsetAvrcpState current_avrcp_state = app.avrcp_state;
    headsetHfpState current_hfp_state = app.hfp_state;
    
    bool playButtonTone = FALSE;
    bool playErrorTone = FALSE;
	uint16 prevent_power_on = 0;
    
	APP_ON_EVENT_LED_UPDATE_IND_T* m;
	APP_VOICE_DIAL_T* v, *voice_recog;
	task = task;
	
    
	/*DEBUG(("In App_handler\n"));*/
    /* Handle incoming message identified by its message ID */
    if ((AVRCP_MESSAGE_BASE <= id) && (id <= AVRCP_MESSAGE_TOP))
    {
        avrcp_msg_handler(id, message);
    }
    else if ((A2DP_MESSAGE_BASE <= id) && (id <= A2DP_MESSAGE_TOP))
    {
        a2dp_msg_handler(id, message);
    }
    else if ((HFP_MESSAGE_BASE <= id) && (id <= HFP_MESSAGE_TOP))
    {
        hfp_msg_handler(id, message);
    }
    else if ((CL_MESSAGE_BASE <= id) && (id <= CL_MESSAGE_TOP))
    {
        cl_msg_handler(id, message);
    }
    else
    {
    switch(id)
    {
         case CODEC_INIT_CFM:
            MAIN_DEBUG(("CODEC_INIT_CFM\n"));
            if(((CODEC_INIT_CFM_T*)message)->status == codec_success)
            {  
                app.codec_task = ((CODEC_INIT_CFM_T*)message)->codecTask;
                /* Initialise the headset volume */
                initialiseVolume(&app);
                /* Initialise the Connection Library */
                ConnectionInit(&app.task);
            }
            else
                Panic();
            break;

        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_INIT_LED_UPDATE_IND:
			m = (APP_ON_EVENT_LED_UPDATE_IND_T *) message;
			MAIN_DEBUG(("APP_LED_INIT_UPDATE_IND\n"));
			MAIN_DEBUG(("INIT count %x\n",m->count));
            if ((m->count)==1)
                headsetPlayTone(&app, tone_type_power_on);   
			if ((m->count)<4)
			{
				app.led_state = updateBlueLedOnEvent(&app, app.led_state, m); 
			}
			else
			{;
				MessageSendLater(getAppTask(), APP_INIT_END, 0, 0); 
				/*app.led_state = updateLed(&app, app.led_state);*/ 
				MessageSendLater(getAppTask(), APP_LED_UPDATE_IND, 0,0);
				if (app.pairing_enabled)
    				app.led_state |= LED_PAIRING;
			}
			break;
            
		case APP_POWER_DOWN_LED_UPDATE_IND:
			m = (APP_ON_EVENT_LED_UPDATE_IND_T *) message;
			MAIN_DEBUG(("APP_POWER_DOWN_LED_UPDATE_IND\n"));
			MAIN_DEBUG(("POWER_DOWN count %x\n",m->count));
			if ((m->count)<4)
			{
				app.led_state = updateBlueLedOnEvent(&app, app.led_state, m); 
			}