callmanagementincoming.c

MTK手机平台的MMI部分的源代码

    }
    if (isInCall())
    {
		cm_p->history_info.IsClamCloseEndCall = MMI_TRUE;
    }
    DeInitCM();
}
#endif /* __MMI_CLAMSHELL__ */ 


/*****************************************************************************
 * FUNCTION
 *  HangupAllCalls
 * DESCRIPTION
 *  Hangs Up All Calls
 * PARAMETERS
 *  void
 * RETURNS
 *  void
 *****************************************************************************/
void HangupAllCalls(void)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    CM_CALL_HANDLE handle;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    MMI_TRACE((MMI_TRACE_G5_CM, MMI_CM_FUNC_HangupAllCalls));

#ifdef WAP_SUPPORT
    if (GetWapCallPresent() && wap_bearer_csd_is_disc())
    {
        return;
    }
#endif /* WAP_SUPPORT */ 
    /* Start by Julia: Drop call refinement */
    if (GetDisconnectingCallHandle() != -1)
    {
        ReleaseCall();
        return;
    }
    SetNotifySSFlag(FALSE);

    /* End by Julia */
    if (GetCurrentState() == CM_OUTGOING_STATE && GetTotalCallCount() == 1)
    {
        handle = GetOutgoingCallHandle();
        SetDropRequestFlag(TRUE);
        if ((GetCallflag(handle, TRUE) & CM_HANGUP_REQUESTED) == 0)
        {
            OutgoingProcessCMEvent(CM_KB_HANGUPREQ, &handle);
        }
    }
    /* hangup single MT call should use reject instead of rel all */
    else if (GetCurrentState() == CM_INCOMING_STATE && GetTotalCallCount() == 1
    	       && gAttempToAnswer == FALSE)
    {
        KbCBackCallIncomingRejected();
    }
    else
    {
        U8 flag;

        /* swapping can't decide which call is active and held, 
           issue rel all req instead */
        flag = GetAllCallFlags();
        if ((GetTotalActiveCallCount() > 0) && (GetTotalHoldCallCount() > 0) &&
            (((flag & CM_SWAP_REQUESTED) != 0) || ((flag & CM_CONF_REQUESTED) != 0) ||
             ((flag & CM_ECT_REQUESTED) != 0)))
        {
            SetAllCallsHangupFlag();
            ProcessIncomingEvents(CM_KB_HANG_ALL_CALLS, NULL);
        }

    #ifdef __MMI_CLAMSHELL__
        /* attemp to answer waiting call and press END key 
           should rel all calls because we can't be sure of 
           current call state and rel active or rel held */
        else if (GetCurrentState() == CM_INCOMING_STATE && GetTotalCallCount() > 1
                 && IsClamClose() == FALSE && gAttempToAnswer == FALSE)
        {
            KbCBackCallIncomingRejected();
        }
    #endif /* __MMI_CLAMSHELL__ */ 
        else if (GetChldReqSent() == 0)
        {
            if ((GetTotalActiveCallCount() > 0) && (GetTotalHoldCallCount() > 0) &&
                (((flag & CM_SWAP_REQUESTED) == 0) || ((flag & CM_CONF_REQUESTED) == 0))
        #ifdef __MMI_CLAMSHELL__
                && IsClamClose() == FALSE
        #endif 
                )
            {
                /* clam open */
                /* rel active and accept */
                ProcessIncomingEvents(CM_KB_END_ALL_ACTIVE_RETRIEVE_HELD, NULL);
                return;
            }
        }
            SetAllCallsHangupFlag();
            ProcessIncomingEvents(CM_KB_HANG_ALL_CALLS, NULL);
    }
}


/*****************************************************************************
 * FUNCTION
 *  KbCBackCallIncomingAccepted
 * DESCRIPTION
 *  This function is called back by the keyboard handler
 *  when the user selects accepts incoming call
 * PARAMETERS
 *  void
 * RETURNS
 *  void
 *****************************************************************************/
void KbCBackCallIncomingAccepted(void)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    CM_CALL_HANDLE handle;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    if (g_charbat_context.LowBatteryTxProhibitFlag == 1)
    {
        SET_LOW_BATTERY_ALARM_THRESHOLD(LBAT_TALK_DURCNT_PROHIBIT);
    }
    else
    {
        SET_LOW_BATTERY_ALARM_THRESHOLD(LBAT_TALK_DURCNT_NORMAL);
    }
    g_charbat_context.LowBatteryCutOffCallCnt = 0;

    if ((GetTotalActiveCallCount() > 0 && GetTotalHoldCallCount() > 0) || 
    	CheckAllCallflag() == TRUE ||
    	GetIncomingCallType() != CSMCC_VOICE_CALL)
    {
        ShowCallManagementErrorMessage(NO_ACTIVE_CALL);
        return;
    }

    /* preempt auto answer by manual answer before timeout */
    if (GetAutoAnswerFlag() == TRUE)
    {
        StopTimer(CM_AUTOANSWER_NOTIFYDURATION_TIMER);
        SetAutoAnswerFlag(FALSE);
    }

    if (GetWapCallPresent() || GetActiveCallType() == CM_DATA_CALL
#ifdef __CTM_SUPPORT__
        || IsScreenPresent(SCR_CTM_TALKING)
#endif 
        )
    {
        KbCBackEndActiveAcceptIncomingCall();
        ClearKeyHandler(KEY_VOL_DOWN, KEY_EVENT_DOWN);
        ClearKeyHandler(KEY_VOL_DOWN, KEY_EVENT_UP);
        ClearKeyHandler(KEY_VOL_UP, KEY_EVENT_DOWN);
        ClearKeyHandler(KEY_VOL_UP, KEY_EVENT_UP);
        return;
    }

    handle = GetIncomingCallHandle();
    if ((GetCallflag(handle, TRUE) & CM_HANGUP_REQUESTED))
    {
        MMI_TRACE((MMI_TRACE_G5_CM, MMI_CM_INFO_KbCBackCallIncomingAccepted));
        return;
    }

#ifdef __MMI_BT_HP_SUPPORT__
    if (mmi_bt_get_sco_state() != MMIBT_SCO_CON)
    {
        mmi_bt_set_answer_by_ag_flag(MMI_TRUE);
    }
#endif /* __MMI_BT_HP_SUPPORT__ */ 

    UnSilencethePhone();
    StopIncomingCallIndication();
    ProcessIncomingEvents(CM_KB_INCOMING_CALL_ACCEPT, NULL);
    ClearKeyHandler(KEY_VOL_DOWN, KEY_EVENT_DOWN);
    ClearKeyHandler(KEY_VOL_DOWN, KEY_EVENT_UP);
    ClearKeyHandler(KEY_VOL_UP, KEY_EVENT_DOWN);
    ClearKeyHandler(KEY_VOL_UP, KEY_EVENT_UP);

}


/*****************************************************************************
 * FUNCTION
 *  KbCBackCallIncomingRejected
 * DESCRIPTION
 *  This function is called back by the keyboard handler
 *  when the user selects rejects incoming call
 * PARAMETERS
 *  void
 * RETURNS
 *  void
 *****************************************************************************/
void KbCBackCallIncomingRejected(void)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    gAttempToReject = TRUE;
    UnSilencethePhone();
    StopIncomingCallIndication();
    ProcessIncomingEvents(CM_KB_INCOMING_CALL_REJECT, NULL);
    ClearKeyHandler(KEY_VOL_DOWN, KEY_EVENT_DOWN);
    ClearKeyHandler(KEY_VOL_DOWN, KEY_EVENT_UP);
    ClearKeyHandler(KEY_VOL_UP, KEY_EVENT_DOWN);
    ClearKeyHandler(KEY_VOL_UP, KEY_EVENT_UP);

    /* if (GetExitScrnID() ==  ITEMSCR_INCOMING_CALL)
       {
       #ifdef __MMI_INCOMING_CALL_VIDEO__
       CM_CALL_HANDLE handle;
       U16 imgId;
       
       handle = GetIncomingCallHandle();
       imgId = GetCallImgId(handle);
       
       // pause video 
       if ((imgId & 0x8000) || ((imgId & 0x3fff) >= VDO_ID_PHB_MTCALL_1))
       StopCategory17Video();
       else
       #endif
       MOMTHideAnimation();
       } */
}

#ifdef __MMI_SIDEKEY_SUPPRESS_RING__


/*****************************************************************************
 * FUNCTION
 *  KbCBackCallIncomingRejectedNoTone
 * DESCRIPTION
 *  Reject MT call and stop ring tone when long press
 *  or double press side down key
 * PARAMETERS
 *  void
 * RETURNS
 *  void
 *****************************************************************************/
void KbCBackCallIncomingRejectedNoTone(void)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    gAttempToReject = TRUE;
    UnSilencethePhone();
    //ClearKeyHandler(KEY_VOL_DOWN, KEY_EVENT_UP);
    ClearKeyHandler(KEY_RSK, KEY_EVENT_UP);  //jerson modify 20070622
    ProcessIncomingEvents(CM_KB_INCOMING_CALL_REJECT, NULL);
}


/*****************************************************************************
 * FUNCTION
 *  KbCBackCallIncomingSuppressTone
 * DESCRIPTION
 *  Set key handler for side down key in its first press
 * PARAMETERS
 *  void
 * RETURNS
 *  void
 *****************************************************************************/
void KbCBackCallIncomingSuppressTone(void)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    //SetKeyHandler(KbCBackCallIncomingRejectedNoTone, KEY_VOL_DOWN, KEY_EVENT_UP);
    SetKeyHandler(KbCBackCallIncomingRejectedNoTone, KEY_RSK, KEY_EVENT_UP);  //jerson modify 20070622
}
#endif /* __MMI_SIDEKEY_SUPPRESS_RING__ */ 


/*****************************************************************************
 * FUNCTION
 *  KbCBackEndActiveAcceptIncomingCall
 * DESCRIPTION
 *  End active and accept waiting call
 * PARAMETERS
 *  void
 * RETURNS
 *  void
 *****************************************************************************/
void KbCBackEndActiveAcceptIncomingCall(void)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    StopIncomingCallIndication();
    ProcessIncomingEvents(CM_KB_END_ACTIVE_ACCEPT_INCOMING, NULL);
}

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

   FUNCTION NAME     : KbCBackEndSelectiveActiveCall(void)

   PURPOSE           : This function is called back by the keyboard handler
                         when the user selects option to End an active call

   INPUT PARAMETERS  : nil

   OUTPUT PARAMETERS : nil

   RETURNS           : void

   REMARKS           : nil

**************************************************************/
/* void KbCBackEndSelectiveActiveCall(void)
   {
   if (gCallToEnd!=-1)
   MakePsEndSelectiveCall ((void*)PsCBackselectedCallEnded, gCallToEnd);
   else
   PRINT_INFORMATION(("CM_TEST File: [%s]  Line: [%d] <<No Call To End>>\n",__FILE__,__LINE__));
   } */


/*****************************************************************************
 * FUNCTION
 *  KbCBackEndAllCallsExceptIncoming
 * DESCRIPTION
 *  This function is called back by the keyboard handler
 *  when the user selects rejects incoming call
 * PARAMETERS
 *  void
 * RETURNS
 *  void
 *****************************************************************************/
void KbCBackEndAllCallsExceptIncoming(void)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    UnSilencethePhone();
    OutgoingProcessCMEvent(CM_KB_HANGUPALLREQ, (void*)NULL);
}


/*****************************************************************************
 * FUNCTION
 *  IgnoreCCBS
 * DESCRIPTION
 *  To invoke the function that ignore the CCBS invoke
 *  
 *  yet to  implement
 * PARAMETERS
 *  void
 * RETURNS
 *  void
 *****************************************************************************/
void IgnoreCCBS(void)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    MMI_TRACE((MMI_TRACE_G5_CM, MMI_CM_FUNC_IgnoreCCBS));
    SetDialIndication(FALSE);
    SetActivatedCcbsFlag(FALSE);
    DropRequest();
}


/*****************************************************************************
 * FUNCTION
 *  ActivateCCBS
 * DESCRIPTION
 *  To invoke the function that activates the CCBS
 *  
 *  yet to  implement
 * PARAMETERS
 *  void
 * RETURNS
 *  void
 *****************************************************************************/
void ActivateCCBS(void)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    MMI_TRACE((MMI_TRACE_G5_CM, MMI_CM_FUNC_ActivateCCBS));
    SetActivatedCcbsFlag(TRUE);
    MakePsActivateCCBS((void*)PsCBackActivatedCCBS);
}