pscallhelper.c

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

    wgui_clear_pen_handlers();
#endif 

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

    splitReq = (MMI_CC_CHLD_REQ*) OslConstructDataPtr(sizeof(MMI_CC_CHLD_REQ));
    splitReq->opcode = CSMCC_HOLD_ACTIVE_EXCEPT_SPECIFIC_CALL;
    splitReq->call_id = (U8) nCallHandle;

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

    SetProtocolEventHandler(SplitReqSucess, PRT_END_CHLD_RSP);
    OslMsgSendExtQueue(&Message);
    return;
}


/*****************************************************************************
 * FUNCTION
 *  MakePsConfCallRequest
 * 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 Conference of the calls
 *  
 *  We are currently assuming our own msg structure and passing to NSW Task Queue.
 * PARAMETERS
 *  void
 *  void(?)     [IN]        (request to Conference i.e all the calls become active)
 * RETURNS
 *  void
 *****************************************************************************/
void MakePsConfCallRequest(void)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    MYQUEUE Message;
    MMI_CC_CHLD_REQ *confReq;

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

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

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

    confReq = (MMI_CC_CHLD_REQ*) OslConstructDataPtr(sizeof(MMI_CC_CHLD_REQ));
    confReq->opcode = CSMCC_ADD_HELD_CALL;

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

    SetProtocolEventHandler(ConfReqSucess, PRT_END_CHLD_RSP);
    OslMsgSendExtQueue(&Message);
    return;
}


/*****************************************************************************
 * FUNCTION
 *  MakePsEctRequest
 * DESCRIPTION
 *  Sends ECT request to Protocol stack
 * PARAMETERS
 *  void
 * RETURNS
 *  void
 *****************************************************************************/
void MakePsEctRequest(void)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    MYQUEUE Message;
    MMI_CC_CHLD_REQ *ectReq;

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

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

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

    ectReq = (MMI_CC_CHLD_REQ*) OslConstructDataPtr(sizeof(MMI_CC_CHLD_REQ));
    ectReq->opcode = CSMCC_EXPLICIT_CALL_TRANSFER;

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

    SetProtocolEventHandler(EctReqSucess, PRT_END_CHLD_RSP);
    OslMsgSendExtQueue(&Message);
    return;
}


/*****************************************************************************
 * FUNCTION
 *  MakePsActivateCCBS
 * DESCRIPTION
 *  Makes call to Protcol Stack to Activate CCBS
 *  
 *  The call back registers a handler with the event dynamically
 * PARAMETERS
 *  callBack        [?]     
 * RETURNS
 *  void
 *****************************************************************************/
void MakePsActivateCCBS(void *callBack)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    MYQUEUE Message;
    MMI_CC_CHLD_REQ *ccbsReq;

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

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

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

    ccbsReq = (MMI_CC_CHLD_REQ*) OslConstructDataPtr(sizeof(MMI_CC_CHLD_REQ));
    ccbsReq->opcode = CSMCC_ACTIVATE_CCBS_CALL;

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

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


/*****************************************************************************
 * FUNCTION
 *  MakePsHangupallRequest
 * 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 calls
 *  
 *  We are currently assuming our own msg structure and passing to NSW Task Queue.
 * PARAMETERS
 *  callBack        [?]         
 *  request(?)      [IN]        To drop all the calls)
 * RETURNS
 *  void
 *****************************************************************************/
void MakePsHangupallRequest(void *callBack)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    MYQUEUE Message;
    MMI_CC_CHLD_REQ *hangUp;

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

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

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

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

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

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


/*****************************************************************************
 * FUNCTION
 *  MakePsSwapCallRequest
 * 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 Swap of the calls
 *  
 *  We are currently assuming our own msg structure and passing to NSW Task Queue.
 * PARAMETERS
 *  callBack        [?]     
 * RETURNS
 *  void
 *****************************************************************************/
void MakePsSwapCallRequest(void *callBack)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    MYQUEUE Message;
    MMI_CC_CHLD_REQ *swapReq;

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

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

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

    swapReq = (MMI_CC_CHLD_REQ*) OslConstructDataPtr(sizeof(MMI_CC_CHLD_REQ));
    swapReq->opcode = CSMCC_SWAP_CALL;

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

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


/*****************************************************************************
 * FUNCTION
 *  MakePsSendRelHeld
 * 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 Release of the held calls
 *  
 *  We are currently assuming our own msg structure and passing to NSW Task Queue.
 * PARAMETERS
 *  callBack        [?]     
 * RETURNS
 *  void
 *****************************************************************************/
void MakePsSendRelHeld(void *callBack)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    MYQUEUE Message;
    MMI_CC_CHLD_REQ *relHeldReq;

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

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

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

    relHeldReq = (MMI_CC_CHLD_REQ*) OslConstructDataPtr(sizeof(MMI_CC_CHLD_REQ));
    relHeldReq->opcode = CSMCC_REL_HELD;

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

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


/*****************************************************************************
 * FUNCTION
 *  MakePsHangupallActiveRequest
 * 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 MakePsHangupallActiveRequest(void *callBack)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    MYQUEUE Message;
    MMI_CC_CHLD_REQ *hangUp;

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

    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;

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

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


/*****************************************************************************
 * FUNCTION
 *  MakePsHangupallCallsRequest
 * 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 calls
 *  
 *  We are currently assuming our own msg structure and passing to NSW Task Queue.
 * PARAMETERS
 *  callBack        [?]         
 *  request(?)      [IN]        To drop all the calls)
 * RETURNS
 *  void
 *****************************************************************************/
void MakePsHangupallCallsRequest(void *callBack)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    MYQUEUE Message;
    MMI_CC_CHLD_REQ *hangUp;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/