pscallhelper.c

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

    FuncPtr fptrKeyEnd, fptrKeyRsk;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    /* ATA_REQ */
    Message.oslSrcId = MOD_MMI;
    Message.oslDestId = MOD_L4C;
    Message.oslMsgId = PRT_INCOMINGCALL_ACCEPT_EVENT;
    Message.oslDataPtr = NULL;
    Message.oslPeerBuffPtr = NULL;

    /* preserve END and RSK key handler */
    fptrKeyEnd = GetKeyHandler(KEY_END, KEY_EVENT_DOWN);
    fptrKeyRsk = GetKeyHandler(KEY_RSK, KEY_EVENT_UP);
    ClearInputEventHandler(MMI_DEVICE_ALL);
#ifdef __MMI_TOUCH_SCREEN__
    wgui_clear_pen_handlers();
#endif 

    SetKeyHandler(fptrKeyEnd, KEY_END, KEY_EVENT_DOWN);
    SetKeyHandler(fptrKeyRsk, KEY_RSK, KEY_EVENT_UP);

    SetProtocolEventHandler((PsFuncPtr) callBack, PRT_INCOMINGCALL_ACCEPT_SUCCESS);
    OslMsgSendExtQueue(&Message);
    return;
}


/*****************************************************************************
 * FUNCTION
 *  MakePsAthRequest
 * DESCRIPTION
 *  Sends ECT request to Protocol stack
 * PARAMETERS
 *  callBack        [?]         
 *  callback(?)     [IN]        To register with response
 * RETURNS
 *  void
 *****************************************************************************/
void MakePsAthRequest(void *callBack)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    MYQUEUE Message;
    MMI_ATH_REQ *athReq;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    /* if auto-rejected, the flag will be false and it should not clear key handler */
    if (GetClearKeyFlag() == TRUE)
    {
        ClearInputEventHandler(MMI_DEVICE_ALL);
    #ifdef __MMI_TOUCH_SCREEN__
        wgui_clear_pen_handlers();
    #endif 

    }
    else
    {
        SetClearKeyFlag(TRUE);
    }

    /* ATH_REQ */
    Message.oslSrcId = MOD_MMI;
    Message.oslDestId = MOD_L4C;
    Message.oslMsgId = PRT_ATH_REQ;
    Message.oslPeerBuffPtr = NULL;
    athReq = (MMI_ATH_REQ*) OslConstructDataPtr(sizeof(MMI_ATH_REQ));
    Message.oslDataPtr = (oslParaType*) athReq;

    if (GetCallAbortReqSentFlag())
    {
        /* set abort MO flag */
        athReq->op_code = L4C_DISCONNECT_MO;
    }
    else
    {
        athReq->op_code = L4C_DISCONNECT_NONE;
    }

    if (GetCurrentState() == CM_INCOMING_STATE)
    {
        SetAllCallsHangupFlag();
    }
    SetProtocolEventHandler((PsFuncPtr) callBack, PRT_ATH_REQ_SUCCESS);
    OslMsgSendExtQueue(&Message);
    return;
}

/* Start by Julia: Drop call refinement */


/*****************************************************************************
 * FUNCTION
 *  MakePsReleaseCompleteRequest
 * DESCRIPTION
 *  Send relese complete message to L4C to strictly releasae the disconnecting call
 *  
 *  It is for drop call refinement
 * PARAMETERS
 *  handle      [IN]        
 * RETURNS
 *  void
 *****************************************************************************/
void MakePsReleaseCompleteRequest(CM_CALL_HANDLE handle)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    MYQUEUE Message;
    MMI_RELCOMP_REQ *relcompReq;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    ClearInputEventHandler(MMI_DEVICE_ALL);
#ifdef __MMI_TOUCH_SCREEN__
    wgui_clear_pen_handlers();
#endif 

    Message.oslSrcId = MOD_MMI;
    Message.oslDestId = MOD_L4C;
    Message.oslMsgId = PRT_RELCOMP_EVENT;
    relcompReq = (MMI_RELCOMP_REQ*) OslConstructDataPtr(sizeof(MMI_RELCOMP_REQ));
    Message.oslDataPtr = (oslParaType*) relcompReq;
    relcompReq->call_id = (U8) handle;
    Message.oslPeerBuffPtr = NULL;
    OslMsgSendExtQueue(&Message);
    return;
}

/* End by Julia */


/*****************************************************************************
 * FUNCTION
 *  MakePsSendUDUB
 * DESCRIPTION
 *  Makes call to Protcol Stack to Send User Determined User Busy
 *  
 *  The call back registers a handler with the event dynamically
 * PARAMETERS
 *  callBack        [?]     
 * RETURNS
 *  void
 *****************************************************************************/
void MakePsSendUDUB(void *callBack)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    MYQUEUE Message;
    MMI_CC_CHLD_REQ *udubReq;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    MMI_TRACE((MMI_TRACE_G5_CM, MMI_CM_FUNC_MakePsSendUDUB));
    /* if auto-rejected, the flag will be false and it should not clear key handler */
    if (GetClearKeyFlag() == TRUE)
    {
        ClearInputEventHandler(MMI_DEVICE_ALL);
    #ifdef __MMI_TOUCH_SCREEN__
        wgui_clear_pen_handlers();
    #endif 
    }
    else
    {
        SetClearKeyFlag(TRUE);
    }
    
    SetChldReqSent(CM_UDUB_REQ_SENT);

    Message.oslSrcId = MOD_MMI;
    Message.oslDestId = MOD_L4C;
    Message.oslMsgId = PRT_UDUB_REQ;

    udubReq = (MMI_CC_CHLD_REQ*) OslConstructDataPtr(sizeof(MMI_CC_CHLD_REQ));
    udubReq->opcode = CSMCC_REL_HELD_OR_UDUB;

    Message.oslDataPtr = (oslParaType*) udubReq;
    Message.oslPeerBuffPtr = NULL;

    SetProtocolEventHandler((PsFuncPtr) callBack, PRT_UDUB_RES_SUCCESS);
    SetProtocolEventHandler((PsFuncPtr) CheckFailureChld, PRT_END_CHLD_RSP);
    OslMsgSendExtQueue(&Message);
    return;
}


/*****************************************************************************
 * FUNCTION
 *  MakePsHangupallActiveAcceptOtherRequest
 * DESCRIPTION
 *  Helper function to Invoke Stack function or pass
 *  the msg structure that can be understandable to Protocol stack.
 *  This is the stack function call to request the Hangup of all Active calls
 *  
 *  We are currently assuming our own msg structure and passing to NSW Task Queue.
 * PARAMETERS
 *  callBack        [?]         
 *  request(?)      [IN]        To drop all Active calls)
 * RETURNS
 *  void
 *****************************************************************************/
void MakePsHangupallActiveAcceptOtherRequest(void *callBack)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    MYQUEUE Message;
    MMI_CC_CHLD_REQ *hangUp;

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

    ClearInputEventHandler(MMI_DEVICE_ALL);
#ifdef __MMI_TOUCH_SCREEN__
    wgui_clear_pen_handlers();
#endif 

    SetChldReqSent(CM_HANGUPALLACTIVE_REQ_SENT);

    Message.oslSrcId = MOD_MMI;
    Message.oslDestId = MOD_L4C;
    Message.oslMsgId = PRT_ENDALLACTIVE_EVENT;

    hangUp = (MMI_CC_CHLD_REQ*) OslConstructDataPtr(sizeof(MMI_CC_CHLD_REQ));
    hangUp->opcode = CSMCC_REL_ACTIVE_AND_ACCEPT;

    Message.oslDataPtr = (oslParaType*) hangUp;
    Message.oslPeerBuffPtr = NULL;

    SetProtocolEventHandler((PsFuncPtr) callBack, PRT_ENDALLACTIVEREQ_SUCCESS);
    SetProtocolEventHandler((PsFuncPtr) CBackHangupAllActiveAcceptOther, PRT_END_CHLD_RSP);
    OslMsgSendExtQueue(&Message);
    return;
}


/*****************************************************************************
 * FUNCTION
 *  MakePsEndSelectiveCall
 * DESCRIPTION
 *  Makes call to Protcol Stack to end a Selective Active Call
 *  
 *  The call back registers a handler with the event dynamically
 *  The handle describes the call to end
 * PARAMETERS
 *  callBack        [?]         
 *  handle          [IN]        
 *  U16(?)          [IN]        
 * RETURNS
 *  void
 *****************************************************************************/
void MakePsEndSelectiveCall(void *callBack, CM_CALL_HANDLE handle)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    MYQUEUE Message;
    MMI_CC_CHLD_REQ *hangupReq;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    MMI_TRACE((MMI_TRACE_G5_CM, MMI_CM_FUNC_MakePsEndSelectiveCall, handle));

    ClearInputEventHandler(MMI_DEVICE_ALL);
#ifdef __MMI_TOUCH_SCREEN__
    wgui_clear_pen_handlers();
#endif 

    SetChldReqSent(CM_ENDSELECTIVE_REQ_SENT);

    Message.oslSrcId = MOD_MMI;
    Message.oslDestId = MOD_L4C;
    Message.oslMsgId = PRT_CALLENDSPECIFIC_EVENT;

    /* if (GetCurrentState () == CM_OUTGOING_STATE)
       {
       SetKeyHandler(DropRequest,KEY_LSK, KEY_EVENT_UP);
       SetKeyHandler(DropRequest,KEY_END, KEY_EVENT_DOWN);
       } */
    hangupReq = (MMI_CC_CHLD_REQ*) OslConstructDataPtr(sizeof(MMI_CC_CHLD_REQ));
    if (GetCurrentState() != CM_OUTGOING_STATE && GetCallState(handle) == CM_ACTIVE_STATE)
    {
        hangupReq->opcode = CSMCC_REL_SPECIFIC_ACTIVE_CALL;
    }
    else
    {
        hangupReq->opcode = CSMCC_REL_SPECIFIC_CALL;
    }
    hangupReq->call_id = (U8) handle;

    Message.oslDataPtr = (oslParaType*) hangupReq;
    Message.oslPeerBuffPtr = NULL;

    SetProtocolEventHandler((PsFuncPtr) callBack, PRT_CALLENDSPECIFIC_SUCCESS);
    SetProtocolEventHandler((PsFuncPtr) CheckFailureChld, PRT_END_CHLD_RSP);
    OslMsgSendExtQueue(&Message);
    return;
}


/*****************************************************************************
 * FUNCTION
 *  MakePsActiveHold
 * DESCRIPTION
 *  Makes call to Protcol Stack to Retrieve Held Call
 *  
 *  The call back registers a handler with the event dynamically
 * PARAMETERS
 *  callBack        [?]     
 * RETURNS
 *  void
 *****************************************************************************/
void MakePsActiveHold(void *callBack)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    MYQUEUE Message;
    MMI_CC_CHLD_REQ *retrReq;

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

    ClearInputEventHandler(MMI_DEVICE_ALL);
#ifdef __MMI_TOUCH_SCREEN__
    wgui_clear_pen_handlers();
#endif 

    Message.oslSrcId = MOD_MMI;
    Message.oslDestId = MOD_L4C;
    Message.oslMsgId = PRT_RETRIEVECALL_EVENT;

    retrReq = (MMI_CC_CHLD_REQ*) OslConstructDataPtr(sizeof(MMI_CC_CHLD_REQ));
    retrReq->opcode = CSMCC_HOLD_ACTIVE_AND_ACCEPT;
    Message.oslDataPtr = (oslParaType*) retrReq;
    Message.oslPeerBuffPtr = NULL;

    SetProtocolEventHandler((PsFuncPtr) callBack, PRT_END_CHLD_RSP);
    OslMsgSendExtQueue(&Message);
    return;
}


/*****************************************************************************
 * FUNCTION
 *  MakePsSplitRequest
 * DESCRIPTION
 *  Helper function to Invoke Stack function or pass
 *  the msg structure that can be understandable to Protocol stack.
 *  This is the stack function call to request the split of particular call in a group of active calls.
 *  
 *  We are currently assuming our own msg structure and passing to NSW Task Queue.
 * PARAMETERS
 *  nCallHandle     [IN]        
 *  request(?)      [IN]        Is made by sending a particular call's call handle)
 * RETURNS
 *  void
 *****************************************************************************/
void MakePsSplitRequest(CM_CALL_HANDLE nCallHandle)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    MYQUEUE Message;
    MMI_CC_CHLD_REQ *splitReq;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    MMI_TRACE((MMI_TRACE_G5_CM, MMI_CM_FUNC_MakePsSplitRequest, nCallHandle));

    ClearInputEventHandler(MMI_DEVICE_ALL);
#ifdef __MMI_TOUCH_SCREEN__