headset_statemanager.c

bluelab的一个很好的例程

/****************************************************************************
Copyright (C) Cambridge Silicon Radio Ltd. 2004

FILE NAME
    headset_statemanager.h
    
DESCRIPTION
    state machine helper functions used for state changes etc - provide single 
    state change points etc for the headset app
*/

#include "headset_statemanager.h"
#include "headset_LEDmanager.h"
#include "headset_soundmanager.h"
#include "headset_buttonmanager.h"
#include "headset_dut.h"

#include "headset_scan.h"
#include "headset_slc.h"



#ifdef DEBUG_STATES
#define SM_DEBUG(x) DEBUG(x)

const char * const gHSStateStrings [ 12 ] = {
                               "headsetLimbo",
                               "headsetConnectable",
                               "headsetConnDiscoverable",
                               "headsetConnected",
                               "headsetOutgoingCallEstablish",
                               "headsetIncomingCallEstablish",
                               "headsetActiveCall",
                               "headsetTESTMODE",
                               "headsetThreeWayCallWaiting",
                               "headsetThreeWayCallOnHold",
                               "headsetThreeWayMulticall",
                               "headsetIncomingCallOnHold"} ;
                               
#else
#define SM_DEBUG(x) 
#endif

#define SM_LIMBO_TIMEOUT_SECS 5

/****************************************************************************
VARIABLES
*/

    /*the headset state variable - accessed only from below fns*/
static headsetState gTheHeadsetState ;

static bool  gSMAutoEnterDiscoverableState = FALSE ;

#define CM_HEADSET_PAIR_INDEFINETELY 0xFFFF

static uint16 gPairModeTimeoutTime_s = CM_HEADSET_PAIR_INDEFINETELY ;


static void stateManagerResetPIOs ( hsTaskData * pApp ) ;

/****************************************************************************
FUNCTIONS
*/

static void stateManagerSetState ( hsTaskData * pApp , headsetState pNewState ) ;

/****************************************************************************
NAME	
	stateManagerSetState

DESCRIPTION
	helper function to Set the current headset state
    provides a single state change point and passes the information
    on to the managers requiring state based responses
    
RETURNS
	
    
*/
static void stateManagerSetState ( hsTaskData * pApp , headsetState pNewState )
{
    SM_DEBUG(("SM: Ch[%s]->[%s] [%d]\n",gHSStateStrings[stateManagerGetState()] , gHSStateStrings[pNewState] , pNewState ));
    
    if ( pNewState < HEADSET_NUM_STATES )
    {

        if (pNewState != gTheHeadsetState )
        {
                /*inform the LED manager of the current state to be displayed*/
            LEDManagerIndicateState ( &pApp->theLEDTask , pNewState ) ;
        }
        else
        {
            /*we are already indicating this state no need to re*/
        }
   
        gTheHeadsetState = pNewState ;
   
    }
    else
    {
        SM_DEBUG(("SM: ? [%s] [%x]\n",gHSStateStrings[ pNewState] , pNewState)) ;
    }
    

    
    /*if we are in chargererror then reset the leds and reset the error*/

    if (pApp->power->charger.state == charge_error )
    {
           /* Cancel current LED indication */
	   MessageSend(getAppTask(), EventCancelLedIndication, 0);	
	       /* Indicate charger error */
	   MessageSend(getAppTask(), EventChargeError, 0);
    }

}


/****************************************************************************
NAME	
	stateManagerGetState

DESCRIPTION
	helper function to get the current headset state

RETURNS
	the Headset State information
    
*/
headsetState stateManagerGetState ( void )
{
    headsetState lHeadsetState = gTheHeadsetState ;
    return lHeadsetState ;
}



/****************************************************************************
NAME	
	stateManagerConfigureConnDiscoState

DESCRIPTION
	function to configure the connectableDiscoverable state action
    if pAutoEnterPairMode == TRUE, then the device enters connectable / 
    Discoverable mode automatically after power on. In this case, the timeout is not 
    used. Otherwise, the device will only enter D/C mode after a user event. in this case, it will
    enter D/C mode for the timout (ms) specified

RETURNS
	void
    
*/
void stateManagerConfigureConnDiscoState ( uint16 pPairModeTimeout_s , bool pAutoEnterPairMode) 
{
    /*it is only logical for the pair mode to be auto entering with no timeout*/
    if (pAutoEnterPairMode )
    {
     
        gSMAutoEnterDiscoverableState = TRUE ;
        gPairModeTimeoutTime_s       = CM_HEADSET_PAIR_INDEFINETELY ;
    }
    else
    {
        gSMAutoEnterDiscoverableState = FALSE ;
        gPairModeTimeoutTime_s       = pPairModeTimeout_s ;
    }

}


/****************************************************************************
NAME	
	stateManagerEnterConnectableState

DESCRIPTION
	single point of entry for the connectable state - enters discoverable state 
    if configured to do so

RETURNS
	void
    
*/
void stateManagerEnterConnectableState ( hsTaskData *pApp, bool req_disc )
{
    if ( stateManagerIsConnected() && req_disc == TRUE)
    {
            /*then we have an SLC active*/
       headsetDisconnectSlc( pApp );
    }  
        /*determine if we have got here after a DiscoverableTimeoutEvent*/
    if ( stateManagerGetState() == headsetConnDiscoverable )
    {
        SM_DEBUG(("SM : det PFail\n")) ;
        
            /*disable the discoverable mode*/
        if (!pApp->features.RemainDiscoverableAtAllTimes)
        {
            headsetDisableDiscoverable ( pApp) ;
        }
        MessageCancelAll ( &pApp->task , EventPairingFail ) ;
    }
    
    /* Make the headset connectable */
    headsetEnableConnectable(pApp);
    stateManagerSetState ( pApp ,headsetConnectable ) ;
    
        /*disable the ring PIOs if enabled*/
    stateManagerResetPIOs ( pApp ) ;
    
    if ( gSMAutoEnterDiscoverableState == TRUE )
    {    
        stateManagerEnterConnDiscoverableState( pApp ) ;
    }  
}



/****************************************************************************
NAME	
	stateManagerEnterConnDiscoverableState|

DESCRIPTION
	single point of entry for the connectable / discoverable state 
    uses timeout if configured
RETURNS
	void
    
*/
void stateManagerEnterConnDiscoverableState ( hsTaskData *pApp )
{
    if ( stateManagerIsConnected() )
    {
            /*then we have an SLC active*/
       headsetDisconnectSlc( pApp );
    }  

    if ( stateManagerGetState() != headsetConnectable)
    {
        SM_DEBUG(("SM : ?St CD\n")) ;
    }
  
    /* Make the headset connectable */
    headsetEnableConnectable(pApp);

    /* Make the headset discoverable */  
    headsetEnableDiscoverable(pApp);    
    
    /* If there is a timeout - send a user message*/
    if (gPairModeTimeoutTime_s != CM_HEADSET_PAIR_INDEFINETELY )
    {
        SM_DEBUG(("SM : Pair [%x]\n" , gPairModeTimeoutTime_s )) ;
        
        MessageSendLater ( &pApp->task , EventPairingFail , 0 , D_SEC(gPairModeTimeoutTime_s) ) ;
    }
    else
    {
        SM_DEBUG(("SM : Pair Indefinetely\n")) ;
    }

    /* Disable the ring PIOs if enabled*/
    stateManagerResetPIOs ( pApp ) ;
   
	/* The headset is now in the connectable/discoverable state */
    stateManagerSetState (pApp , headsetConnDiscoverable ) ;
}


/****************************************************************************
NAME	
	stateManagerEnterConnectedState

DESCRIPTION
	single point of entry for the connected state - disables disco / connectable modes
RETURNS
	void
    
*/
void stateManagerEnterConnectedState ( hsTaskData *pApp )
{
    if (stateManagerGetState () != headsetConnected )
    {
            /*make sure we are now neither connectable or discoverable*/
        SM_DEBUG(("SM:Remain in Disco Mode [%c]\n", (pApp->features.RemainDiscoverableAtAllTimes?'T':'F') )) ;
        
        if (!pApp->features.RemainDiscoverableAtAllTimes)
        {
            headsetDisableDiscoverable ( pApp ) ;    
        }
        headsetDisableConnectable  ( pApp ) ;        
    
        switch ( stateManagerGetState() )
        {    
            case headsetActiveCall:
            case headsetThreeWayCallWaiting:
            case headsetThreeWayCallOnHold:
            case headsetThreeWayMulticall:
            case headsetOutgoingCallEstablish:
            case headsetIncomingCallEstablish:
                    /*then we have just ended a call*/
                MessageSend ( &pApp->task , EventEndOfCall , 0 ) ;
            break ;
            default:
            break ;
        }
    
            /*send the request for the hold information*/
        if ( pApp->HFP_1_5_supp_features.HFP_1_5_Is_Enabled )
        {
            HfpGetResponseHoldStatus(pApp->hfp) ;
            HfpGetCurrentCalls ( pApp->hfp) ;
        }
        MessageCancelAll ( &pApp->task , EventPairingFail ) ;
        
            /*disable the ring PIOs if enabled*/
        stateManagerResetPIOs ( pApp ) ;
    

        stateManagerSetState ( pApp , headsetConnected ) ;
   }     
}
/****************************************************************************
NAME	
	stateManagerEnterIncomingCallEstablishState

DESCRIPTION