main.c

bluelab的一个很好的例程

                MAIN_DEBUG(("HS: RejectHeldCall [%d]\n" , stateManagerGetState() )) ;
                HfpRejectHeldIncomingCall(theHeadset.hfp);
            }    
        break;

		

/******************************************************************/
/******************************************************************/

        default :
            MAIN_DEBUG (( "HS : UE !! [%x]\n", id ));     
            break ;
            

/******************************************************************/
/******************************************************************/

        
    }       
    

    /* Inform theevent indications that we have received a user event*/
    /* For all events except the end event notification as this will just end up here again calling itself...*/
    if ( lIndicateEvent == TRUE )
    {
        if ( id != EventLEDEventComplete )
        {
            LEDManagerIndicateEvent ( &theHeadset.theLEDTask , id ) ;
        }           
        soundManagerIndicateEvent ( &theHeadset , id ) ;
    }
    
}





/*************************************************************************
NAME    
    handleHFPMessage

DESCRIPTION
    handles the messages from the user events

RETURNS

*/

static void handleHFPMessage  ( Task task, MessageId id, Message message )
{
    headsetState current_headset_state = stateManagerGetState();   
   uint16 i = 0;
    
    switch(id)
    {
  /* -- Handsfree Profile Library Messages -- */
  case HFP_INIT_CFM:
            MAIN_DEBUG(("HFP_INIT_CFM\n"));
            switch(current_headset_state)
            {
            case headsetPoweringOn:
                {
                    HFP_INIT_CFM_T *msg = (HFP_INIT_CFM_T *) message;
                    if (msg->status == hfp_success)
                        headsetInitComplete(&theHeadset, msg);
                    else
                        Panic();
                }
                break;

            case headsetConnectable:
            case headsetConnDiscoverable:
            case headsetConnected:
            case headsetOutgoingCallEstablish:
            case headsetIncomingCallEstablish:
            case headsetActiveCall:
            default:
                unhandledHeadsetState(current_headset_state, id);
            }
            break;
  
  case HFP_SLC_CONNECT_IND:
            MAIN_DEBUG(("HFP_SLC_CONNECT_IND\n"));
            switch(current_headset_state)
            {
            case headsetConnectable:
            case headsetConnDiscoverable:
            case headsetConnected:
            case headsetOutgoingCallEstablish:
            case headsetIncomingCallEstablish:
            case headsetActiveCall:
                headsetHandleSlcConnectInd(&theHeadset, (HFP_SLC_CONNECT_IND_T *) message);
                break;

            case headsetPoweringOn:           
            default:
                unhandledHeadsetState(current_headset_state, id);
            
            }
            break;

        case HFP_SLC_CONNECT_CFM:
            MAIN_DEBUG(("HFP_SLC_CONNECT_CFM [%x]\n", ((HFP_SLC_CONNECT_CFM_T *) message)->status ));
            switch(current_headset_state)
            {
            case headsetConnectable:
            case headsetConnDiscoverable:
            case headsetConnected:
            case headsetOutgoingCallEstablish:
            case headsetIncomingCallEstablish:
            case headsetActiveCall:            
            case headsetThreeWayCallWaiting:
            case headsetThreeWayCallOnHold:
            case headsetThreeWayMulticall:
                headsetHandleSlcConnectCfm(&theHeadset, (HFP_SLC_CONNECT_CFM_T *) message);
                break;
            case headsetPoweringOn:    
                if ( ((HFP_SLC_CONNECT_CFM_T *) message)->status == hfp_success )
                {
                    /*A connection has been made and we are now logically off*/
                    headsetDisconnectSlc( &theHeadset );   
                }
            break;
            default:
                unhandledHeadsetState(current_headset_state, id);
            }
            break;

        case HFP_SLC_DISCONNECT_IND:
            MAIN_DEBUG(("HFP_SLC_DISCONNECT_IND\n"));
            switch(current_headset_state)
            {
            case headsetConnDiscoverable:         
            case headsetConnected:
            case headsetOutgoingCallEstablish:
            case headsetIncomingCallEstablish:
            case headsetActiveCall:
            case headsetPoweringOn:   
            case headsetThreeWayCallWaiting:
            case headsetThreeWayCallOnHold:
            case headsetThreeWayMulticall:
                headsetHandleSlcDisconnectInd(&theHeadset, (HFP_SLC_DISCONNECT_IND_T *) message);
                break;

            case headsetTestMode:
            case headsetConnectable:        
            default:
                unhandledHeadsetState(current_headset_state, id);
            }
            break;
   
   
        case HFP_IN_BAND_RING_IND:
                /*store the in band ring Information*/
            theHeadset.RingInfo.InBandRingEnabled = ((HFP_IN_BAND_RING_IND_T*)message)->ring_enabled ;
            
            MAIN_DEBUG(("HFP_IN_BAND_RING_IND [%c]\n" ,theHeadset.RingInfo.InBandRingEnabled ? 'T' : 'F'));

            break ;

        case HFP_SERVICE_IND:
            MAIN_DEBUG(("HFP_SERVICE_IND [%x]\n" , ((HFP_SERVICE_IND_T*)message)->service  ));
            {  
                 headsetHandleServiceIndicator ( &theHeadset , ((HFP_SERVICE_IND_T*)message) ) ;
            }
            break;

        case HFP_CALL_IND:
            MAIN_DEBUG(("HFP_CALL_IND [%d]\n",((HFP_CALL_IND_T *)message)->call   )); /* 0  no call active -  1 call active*/
            switch(current_headset_state)
            {
            case headsetIncomingCallEstablish:
            case headsetOutgoingCallEstablish:
            case headsetActiveCall:             
                /* Some phones send this message before the SLC connect cfm on a call transfer*/
            case headsetConnDiscoverable:
            case headsetConnectable:
            case headsetConnected:                
                headsetHandleCallInd ( &theHeadset , (HFP_CALL_IND_T *)message ) ;
                break ;
            case headsetThreeWayCallWaiting:
            case headsetThreeWayCallOnHold:
            case headsetThreeWayMulticall:
                headsetHandleThreeCallInd ( &theHeadset , (HFP_CALL_IND_T * )message ) ;
            break ;
            case headsetPoweringOn:
            default:
                unhandledHeadsetState(current_headset_state, id);
            }
            break;

        case HFP_CALL_SETUP_IND:
            MAIN_DEBUG(("HFP_CALL_SETUP_IND [%d]\n", ((HFP_CALL_SETUP_IND_T * )message)->call_setup ));
            switch(current_headset_state)
            {
            case headsetConnDiscoverable:
            case headsetConnected:
            case headsetConnectable:
            case headsetIncomingCallEstablish:
            case headsetOutgoingCallEstablish:
               
                headsetHandleCallSetupInd ( &theHeadset , (HFP_CALL_SETUP_IND_T * )message ) ;
            break ;
            
            case headsetThreeWayCallWaiting:
            case headsetThreeWayCallOnHold:
            case headsetThreeWayMulticall:
                headsetHandleThreeCallSetupInd ( &theHeadset , (HFP_CALL_SETUP_IND_T * )message ) ;            
            break;
            case headsetPoweringOn:
            default:
                unhandledHeadsetState(current_headset_state, id);
            }
            break;

        case HFP_RING_IND:
            MAIN_DEBUG(("HFP_RING_IND\n"));
            switch(current_headset_state)
            {
            case headsetConnected:
            case headsetIncomingCallEstablish:
            case headsetActiveCall:
            case headsetThreeWayCallWaiting:
            case headsetThreeWayCallOnHold:
            case headsetThreeWayMulticall:
                headsetHandleRingInd(&theHeadset,(HFP_RING_IND_T *)(message)) ;
            break ;
                
            case headsetConnDiscoverable:
            case headsetOutgoingCallEstablish:
            case headsetPoweringOn:
            case headsetConnectable:
            default:
                unhandledHeadsetState(current_headset_state, id);
            }
            break;

        case HFP_LAST_NUMBER_REDIAL_CFM:
            MAIN_DEBUG(("HFP_LAST_NUMBER_REDIAL_CFM\n"));
            
            handleHFPStatusCFM (&theHeadset , ((HFP_LAST_NUMBER_REDIAL_CFM_T*)message)->status ) ;
            break;
            
        case HFP_DIAL_NUMBER_CFM:
            MAIN_DEBUG(("HFP_DIAL_NUMBER_CFM %d %d\n", current_headset_state, ((HFP_DIAL_NUMBER_CFM_T *) message)->status));
            break;
        case HFP_DIAL_MEMORY_CFM:
            MAIN_DEBUG(("HFP_DIAL_MEMORY_CFM %d %d\n", current_headset_state, ((HFP_DIAL_MEMORY_CFM_T *) message)->status));
            break ;
            
        case HFP_ANSWER_CALL_CFM:
            MAIN_DEBUG(("HFP_ANSWER_CALL_CFM\n"));
            break;

        case HFP_REJECT_CALL_CFM:
            MAIN_DEBUG(("HFP_REJECT_CALL_CFM\n"));
            break;

        case HFP_TERMINATE_CALL_CFM:
            MAIN_DEBUG(("HFP_TERMINATE_CALL_CFM %d\n", current_headset_state));
            switch(current_headset_state)
            {
            case headsetOutgoingCallEstablish:
            case headsetIncomingCallEstablish:
            case headsetActiveCall: 
                stateManagerEnterConnectedState ( &theHeadset ) ; 
            break ;
            case headsetConnected:
            case headsetConnDiscoverable:
            case headsetPoweringOn:
            case headsetConnectable:
            default:
                unhandledHeadsetState(current_headset_state, id);
                break ;
            }
            break;

        case HFP_VOICE_RECOGNITION_IND:
            MAIN_DEBUG(("HS: HFP_VOICE_RECOGNITION_IND_T [%c]\n" ,TRUE_OR_FALSE( ((HFP_VOICE_RECOGNITION_IND_T* )message)->enable) )) ;    
            
                /*update the state of the voice dialling on the back of the indication*/
            theHeadset.VoiceRecognitionIsActive = ((HFP_VOICE_RECOGNITION_IND_T* ) message)->enable ;
            
            break;

        case HFP_VOICE_RECOGNITION_ENABLE_CFM:
            MAIN_DEBUG(("HFP_VOICE_RECOGNITION_ENABLE_CFM s[%d] w[%d]i", (((HFP_VOICE_RECOGNITION_ENABLE_CFM_T *)message)->status ) , theHeadset.VoiceRecognitionIsActive));
 
                /*if the cfm is in error then we did not succeed - toggle */
            if  ( (((HFP_VOICE_RECOGNITION_ENABLE_CFM_T *)message)->status ) )
                theHeadset.VoiceRecognitionIsActive ^= 1 ;
                
            MAIN_DEBUG(("[%d]\n", theHeadset.VoiceRecognitionIsActive));
            
            handleHFPStatusCFM (&theHeadset , ((HFP_VOICE_RECOGNITION_ENABLE_CFM_T *)message)->status ) ;
            
            break;

        case HFP_SINK_CFM:
            MAIN_DEBUG(("HFP_SINK_CFM\n"));
            switch(current_headset_state)
            {
            case headsetConnected:
            case headsetOutgoingCallEstablish:
            case headsetIncomingCallEstablish:
            case headsetActiveCall:
                MAIN_DEBUG(("Main: Handle Sink\n")) ;                
                
                /*headsetHandleSinkCfm ( (const HFP_SINK_CFM_T *) ( message ) ) ;*/
                break ;
            case headsetPoweringOn:
            case headsetConnectable:
            case headsetConnDiscoverable: 
            default:
                unhandledHeadsetState(current_headset_state, id);
            }
            break;
  
        case HFP_CALLER_ID_ENABLE_CFM:
            MAIN_DEBUG(("HFP_CALLER_ID_ENABLE_CFM\n"));
            break;
   
        case HFP_SPEAKER_VOLUME_CFM:
            MAIN_DEBUG(("HFP_SPEAKER_VOLUME_CFM\n"));
            break;

        case HFP_SPEAKER_VOLUME_IND:
            MAIN_DEBUG(("HFP_SPEAKER_VOLUME_IND %d\n", ((HFP_SPEAKER_VOLUME_IND_T *) message)->volume_gain));
            
            soundManagerHandleVolumeInd ( &theHeadset , ((HFP_SPEAKER_VOLUME_IND_T *) message)->volume_gain ) ;
            
            break;

        case HFP_MICROPHONE_VOLUME_CFM:
            MAIN_DEBUG(("HFP_MICROPHONE_VOLUME_CFM\n"));
            break;

        case HFP_MICROPHONE_VOLUME_IND:
            MAIN_DEBUG(("HFP_MICROPHONE_VOLUME_IND %d\n", ((HFP_MICROPHONE_VOLUME_IND_T *) message)->mic_gain));
            
            soundManagerHandleMicInd ( &theHeadset ,((HFP_MICROPHONE_VOLUME_IND_T *) message)->mic_gain ) ;
            
            break;
        
        case HFP_CALLER_ID_IND:
            MAIN_DEBUG(("HFP_CALLER_ID_IND\n"));
            {
                uint16 i;
                HFP_CALLER_ID_IND_T *ind = (HFP_CALLER_ID_IND_T *) message;
                MAIN_DEBUG(("HFP_CALLER_ID_IND len %d\n", ind->size_caller_number));
    
                for (i=0; i < ind->size_caller_number; i++)
                {
                    MAIN_DEBUG(("%c", ind->caller_number[i]));
                }
                MAIN_DEBUG(("\n")); 
            }
            break;
            
        case HFP_UNRECOGNISED_AT_CMD_IND:
            {   
                MAIN_DEBUG(("HFP_UNRECOGNISED_AT_CMD_IND_T " )) ;
                for (i=0 ; i< ((HFP_UNRECOGNISED_AT_CMD_IND_T *)message)->size_data ; i++)
                {

                    MAIN_DEBUG(("[%c]" ,((HFP_UNRECOGNISED_AT_CMD_IND_T *)message)->data[i] )) ;
                }
            }
            break ;
        case HFP_HS_BUTTON_PRESS_CFM:
            {
                MAIN_DEBUG(("HFP_HS_BUTTON_PRESS_CFM\n")) ;
            }
            break ;
         /*****************************************************************/
    case HFP_CALL_WAITING_ENABLE_CFM :
         MAIN_DEBUG(("HS3 : HFP_CALL_WAITING_ENABLE_CFM_T [%c]\n", (((HFP_CALL_WAITING_ENABLE_CFM_T * )message)->status == hfp_success) ?'T':'F' )) ;
         headsetHandleThreeCallWaitingCfm (&theHeadset , (HFP_CALL_WAITING_ENABLE_CFM_T * )message ) ;
    break ;    
    case HFP_CALL_WAITING_IND:
         {
            uint16 i;
             
            HFP_CALL_WAITING_IND_T * ind = (HFP_CALL_WAITING_IND_T *) message;
             
            MAIN_DEBUG(("HS3 : HFP_CALL_WAITING_IND len %d\n", ind->size_caller_number));
    
            for (i=0; i < ind->size_caller_number; i++)
            {
                MAIN_DEBUG(("%c", ind->caller_number[i]));
            }
            MAIN_DEBUG(("\n")); 
            /*at this point - we know that we have a second incoming call*/
            
           headsetHandleThreeCallWaitingInd (&theHeadset , ind ) ;
        }
    break;
    

    case HFP_RELEASE_HELD_REJECT_WAITING_CALL_CFM :
         MAIN_DEBUG(("HS3 : HFP_RELEASE_HELD_REJECT_WAITING_CALL_CFM_T [%c]\n", (((HFP_RELEASE_HELD_REJECT_WAITING_CALL_CFM_T * )message)->status == hfp_success) ? 'T':'F' )) ;
         headsetHandleThreeReleaseHeldRejectWaitingCfm (&theHeadset ,(HFP_RELEASE_HELD_REJECT_WAITING_CALL_CFM_T * )message) ;