{
                        	if (app->profile_connected == hfp_handsfree_profile)
                        	{
                                hfpHeadsetHangUpCall(app);
                            }
                            else
                            {
                                /* Send an HSP button press */
                                HfpSendHsButtonPress(app->hsp);
							}
                            playButtonTone = TRUE;
                        }
                        break;

                        case headsetActiveCall:
                        {
                            if (app->profile_connected == hfp_handsfree_profile)
                            {
                                hfpHeadsetHangUpCall(app);
                            }
                            else
                            {    /* Send an HSP button press */
                                HfpSendHsButtonPress(app->hsp);
							}
                            playButtonTone = TRUE;
                    	}
						break;


                        case headsetConnecting:
						case headsetInitialising:
                        default:
                        break ;
					}
                    
					if (!playButtonTone && (current_hfp_state != headsetReady))
                            playErrorTone = TRUE;
                }
            }
   		}         
        break;

        default:
        break;                
    }
    
    if (playErrorTone)
       headsetPlayTone(app, tone_type_error); 
    if (playButtonTone)
        headsetPlayTone(app, tone_type_button_press);         

}

/****************************************************************************
*/
void button_handle_mfb_long_held(  headsetTaskData *app  ) 
{   

	switch (app->headset_power_state)
	{
		case power_state_off:
		case power_state_off_charging:
		    headsetPowerOn(app);
		break;
			
		case power_state_on:
		case power_state_on_charging:
		default:
		    /* We act on the button release - play tone to indicate button has been 
		        held for required time.*/
			headsetPlayTone(app, tone_type_button_press);  
	    break;
	}
}

/****************************************************************************
*/
void button_handle_mfb_long_release(  headsetTaskData *app  ) 
{
    bool playErrorTone = FALSE ;
    bool playButtonTone = FALSE ;
    
    headsetHfpState current_hfp_state = app->hfp_state;   
    
            switch (app->headset_power_state)
            {
            case power_state_off:
                /* Update the local state to show we're now powered on */
                headsetSetPowerState(app, power_state_on);
                /* Check to see if page scanning should be enabled */
  				updateHeadsetScanning(app);
                /* Auto connect to the last used devices if functionality is enabled */
                headsetConnectToLastDevices(app);
                break;
            case power_state_off_charging:
                /* Update the local state to show we're now powered on */
                headsetSetPowerState(app, power_state_on_charging);
                /* Check to see if page scanning should be enabled */
  				updateHeadsetScanning(app);
                /* Auto connect to the last used devices if functionality is enabled */
                headsetConnectToLastDevices(app);
                break;

            case power_state_on:
            case power_state_on_charging:
                if (!app->headset_connecting_hfp)
                {
                    if (isHeadsetPairing(app))
                    {
                        playErrorTone = TRUE;
                    }
                    else
                    {
                        /* Headset not idle, must have some connection active */
                        switch(current_hfp_state)
                        {
                            case headsetReady:
                                /* If we're already streaming music pause it. */
                                if (app->a2dp_state == avHeadsetA2dpStreaming)
                                {
                                    avHeadsetAvStreamStop(app, TRUE);
                                    (void) MessageCancelAll(getAppTask(), APP_MUSIC_RESTART_IND);
                                }

                                /* Headset is idle initiate Last number redial */
                                app->headset_connecting_hfp = 1;
                        
                                /* Requeue the message so we can act on it on SLC connect */
                                MessageSendConditionally(&app->task, BUTTON_MFB_LONG_RELEASE, 0, &app->headset_connecting_hfp);
                        
                                /* Initiate the HFP SLC */
                                hfpHeadsetHandleSlcConnectRequest(app, hfp_handsfree_profile);
                                break;

                            case headsetConnecting:
                                break;

                            case headsetConnected:
                                if (app->profile_connected == hfp_handsfree_profile) 
                                {
                                    hfpHeadsetLastNumberRedial(app);
                                }
                                else
                                {
                                    playErrorTone = TRUE;
                                }
                                break;
                
                            case headsetIncomingCallEstablish:
                                if (app->profile_connected == hfp_handsfree_profile)
                                {
                                    hfpHeadsetRejectCall(app);
                                }
                                else
                                {
                                    playErrorTone = TRUE;
                                }
                                break;

                            case headsetOutgoingCallEstablish:
                                if (app->profile_connected == hfp_handsfree_profile)
                                {
                                    /* Transfer the audio */
                                    if (!app->sco_sink)
                                        hfpHeadsetTransferAudio(app, hfp_audio_to_hfp);
                                    else
                                        hfpHeadsetTransferAudio(app, hfp_audio_to_ag);
                                }
                                else
                                {
                                    playErrorTone = TRUE;
                                }
                                break;

                            case headsetActiveCall:
                                if (app->profile_connected == hfp_handsfree_profile)
                                {
                                    /* Transfer the audio */
                                    if (!app->sco_sink)
                                        hfpHeadsetTransferAudio(app, hfp_audio_to_hfp);
                                    else
                                        hfpHeadsetTransferAudio(app, hfp_audio_to_ag);
                                }              
                                else
                                {
                                    playErrorTone = TRUE;
                                }
                                break;

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

    if (playErrorTone)
       headsetPlayTone(app, tone_type_error); 
    if (playButtonTone)
        headsetPlayTone(app, tone_type_button_press);  
}

/****************************************************************************
*/
void button_handle_mfb_very_long(  headsetTaskData *app  ) 
{
	uint16 prevent_power_on = 0;
                
	if ((app->headset_power_state == power_state_off) ||
        (app->headset_power_state == power_state_off_charging )) 
	{
		prevent_power_on = MessageCancelAll(getAppTask(), APP_PREVENT_POWER_ON);
        
		if (prevent_power_on==0)
		{
            	/* Update the loacl state to show we're now powered on */
			if (app->headset_power_state == power_state_off)
            {
	        	headsetSetPowerState(app, power_state_on);
			}
			else
			{
				headsetSetPowerState(app, power_state_on_charging);
			}
            	/*Check to see if page scanning should be enabled*/
			updateHeadsetScanning(app);
            	/* Go into pairing mode. */
            headsetEnterPairingMode(app);
        }
	}
    else 
    {
    	headsetPowerOff(app);
    }
}

/****************************************************************************
*/
void button_handle_play_pause_press(  headsetTaskData *app  ) 
{
	headsetPowerAmp (app , TRUE);
}

/****************************************************************************
*/
void button_handle_play_pause_short(  headsetTaskData *app  ) 
{
	MessageSendLater(&app->task, APP_PLAY_PAUSE_SHORT, 0, 200);
}

/****************************************************************************
*/
void button_handle_play_pause_long(  headsetTaskData *app  ) 
{
    bool playErrorTone = FALSE ;
    bool playButtonTone = FALSE ;

    headsetAvrcpState current_avrcp_state = app->avrcp_state;
    headsetHfpState current_hfp_state = app->hfp_state;  
    
	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))
        	{
            	playErrorTone = TRUE;
				break;
       	 	}
        	if (isHeadsetIdle(app))
        	{
            		/* Connect the AV. */                    
				playButtonTone = TRUE;
            	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))
				{
					playErrorTone = TRUE;
				}
            	else if (current_avrcp_state == avHeadsetAvrcpConnected)
            	{
                	avHeadsetSendStop(app);                     
					playButtonTone = TRUE;
            	}
            	else if (app->active_profile == av_active)
            	{
                	avHeadsetAvStreamStop(app, TRUE);
                	playButtonTone = TRUE;
            	}
            	else
            	{                    
					playButtonTone = TRUE;
                	avHeadsetHandleAvConnectRequest(app);
            	}                        
        	}
        	break;
    	}
    
    	default:
    	break ;
	}
        
    if (playErrorTone)
       headsetPlayTone(app, tone_type_error); 
    if (playButtonTone)
        headsetPlayTone(app, tone_type_button_press);  
}

/****************************************************************************
*/
void button_handle_forward_backward_held(  headsetTaskData *app  ) 
{
	if ( (app->headset_power_state == power_state_on) ||
	     (app->headset_power_state == power_state_on_charging))
	{
		headsetPlayTone(app, tone_type_pairing);
		ledsPlay(BLUE_FOUR_FLASHES_FAST);				
		headsetClearPairedDevices(app);
	}	
}