callctrl.cpp

手机RILGSM实现的源代码

        // The length of szCmd is limited by MAX_PATH(260), thus at most 107 characters can be fit into one AT command
        for (; (*pchChars) && (pchChars-lpszChars<=107); pchChars++) //old is      for (; *pchChars; pchChars++) 
        {
            NumVals++;
            if (nSent >= 20)
            {
                (void)_snprintfz(szWalk, MAX_PATH - (szWalk - szCmd), "\";+VTS=\"%c", *pchChars);
                szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
                DEBUGCHK(NULL != szWalk);
                nSent = 1;
            }
            else
            {
                (void)_snprintfz(szWalk, MAX_PATH - (szWalk - szCmd), ",%c", *pchChars);
                szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
                DEBUGCHK(NULL != szWalk);
                nSent++;
            }
        }
        (void)_snprintfz(szWalk, MAX_PATH - (szWalk - szCmd), "\"", *pchChars);
        szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
        DEBUGCHK(NULL != szWalk);
        
    }
#endif // !defined(OEM2_DRIVER) // SUPPORT_DTMF_DURATION
    (void)strncpyz(szWalk, "\r", MAX_PATH - (szWalk - szCmd));  // NO_TYPO: 30

    // Pick a timeout value to use
    dwTimeout = (2 * NumVals * dwDuration) + g_TimeoutAPIDefault;
    DEBUGMSG(ZONE_INFO, (TEXT("RILDrv : i : RILDrv_SendDTMF : Sending DTMF, NumVals=%d, dwDuration=%d, Timeout = %d ms\r\n"), NumVals, dwDuration, dwTimeout));

    if (!QueueCmdWithTimeout(pHandle, szCmd, NULL, CMDOPT_SUPPRESSLOGGING, APIID_SENDDTMF, NULL, NULL, hr, dwTimeout,0)) {
        hr = E_FAIL;
        goto Error;
    }

Error:
    return hr;
}

//A mt call is incoming When making a mo call, but mo call is just early than mt call
void DealCallConflict()
{
    if((g_rgfCallStates[1].dwParams & RIL_PARAM_CI_STATUS) 
        &&(g_rgfCallStates[2].dwParams & RIL_PARAM_CI_STATUS) 
        &&(RIL_CALLDIR_INCOMING == g_rgfCallStates[1].dwDirection) 
        &&(RIL_CALLDIR_OUTGOING == g_rgfCallStates[2].dwDirection) 
        && (RIL_CALLSTAT_WAITING == g_rgfCallStates[1].dwStatus)
        && (RIL_CALLSTAT_DIALING == g_rgfCallStates[2].dwStatus ))
    {      
        char szCmd_ath[MAX_PATH];

        RETAILMSG(1, (TEXT("[TI]------------DealConflict():Handup the call,ID:1\r\n")));    
        //handup line 1 phones, line 2 phone will be released automatedly
        (void)_snprintfz(szCmd_ath, MAX_PATH, "AT%%CHLD = 71\r");	
        QueueCmdIgnoreRsp(APIID_NONE, szCmd_ath, CMDOPT_NONE, g_TimeoutAPIDefault, NULL, NULL, 0, 0, 0);     
    }   
}

//
//
//
static HRESULT ParseGetCallList(LPCSTR szRsp, void*& pBlob, UINT& cbBlob)
{
    HRESULT hr = S_OK;
    pBlob = NULL;
    cbBlob = 0;

    RETAILMSG(1, (TEXT("[TI] ParseGetCallList: Begin\r\n")));

    // 1. prepare for parse clcc response
    RILDrv_CC_PrepareForParseCLCC() ;

    // 2.parse the clcc response of driver 1
    hr = RILDrv_CC_ParseCLCCForDriver(szRsp,pBlob,cbBlob);

    if (FAILED(hr)) 
    {
        RETAILMSG(1, (TEXT("[TI]ParseGetCallList : call RILDrv_CC_ParseCLCCForDriver failed\r\n")));
        return hr ;
    }
    if((cbBlob <= 0 && pBlob != NULL) ||
        (cbBlob > 0 && pBlob == NULL) )
    {
        RETAILMSG(1, (TEXT("[TI]Error for mem allocater\r\n")));
    }
    RETAILMSG(1, (TEXT("[TI]ParseGetCallList: END\r\n")));
    return hr;
    
}

//
HRESULT RILDrv_GetCallList(DWORD dwParam)
{
    FUNCTION_TRACE(RILDrv_GetCallList);
    HRESULT hr = S_OK;
       
    CRilInstanceHandle* pHandle = ExtractHandle(dwParam);
    if (!pHandle)
    {
        hr = E_FAIL;
        goto Error;
    }

#ifdef RIL_RADIO_RESILIENCE
    if (ShouldSpoofCommand())
    {
        // If the radio was reset recently, just return no calls.  Otherwise this may get
        // queued up after all the init commands, and take a long time to execute, only
        // to find out that there are no calls.  This is bad, since we want to handle
        // the RIL_NOTIFY_DISCONNECT that is sent up during reset so the UI can be
        // updated quickly
        hr = pHandle->GetDevice()->GetNextCmdID();
        pHandle->Notify(RIL_RESULT_OK, hr, NULL, 0);
    }
    else
#endif // RIL_RADIO_RESILIENCE        
    {       
        if (!QueueCmd(pHandle, "AT+CLCC\r", CMDOPT_NONE|CMDOPT_IGNORERADIOOFF, APIID_GETCALLLIST, ParseGetCallList, NULL, hr))
        {
            hr = E_FAIL;
            goto Error;
        }

        
        UpdateCLCCTimes(TRUE);
        
    }

Error:
    return hr;
}

//
//
//TWO DRIVER HAVE CALLS
static HRESULT ParseSpecialGetCallList(LPCSTR szRsp, void*& pBlob, UINT& cbBlob)
{
    HRESULT hr = S_OK;
    pBlob = NULL;
    cbBlob = 0;

    RETAILMSG(1, (TEXT("[TI] ParseSpecialGetCallList: Begin\r\n")));
    RILDrv_CC_PrepareForParseCLCC() ;
    hr = RILDrv_CC_ParseCLCCForDriver(szRsp,pBlob,cbBlob);
    if (FAILED(hr)) 
    {
        RETAILMSG(1, (TEXT("[TI]ParseGetCallList : call RILDrv_CC_ParseCLCCForDriver failed\r\n")));
        return hr ;
    }
    if((cbBlob <= 0 && pBlob != NULL) ||
        (cbBlob > 0 && pBlob == NULL) )
    {
        RETAILMSG(1, (TEXT("[TI]Error for mem allocater\r\n")));
    }
    RILDrv_CC_CombineCLCC(pBlob,cbBlob);
    // 4 init the clcc buffer of share memory
    //RILDrv_CC_InitCLCCBuf();

    RETAILMSG(1, (TEXT("[TI]ParseGetCallList: END\r\n")));

    return hr;
    
}
HRESULT RILDrv_GetSpecialCallList(DWORD dwParam)
{
    FUNCTION_TRACE(RILDrv_GetCallList);
    HRESULT hr = S_OK;
    RETAILMSG(1, (TEXT("[TI] clcc :RILDrv_GetSpecialCallList BEGIN.... \r\n")));

    CRilInstanceHandle* pHandle = ExtractHandle(dwParam);
    if (!pHandle) {
        hr = E_FAIL;
        goto Error;
    }

#ifdef RIL_RADIO_RESILIENCE
    if (ShouldSpoofCommand())
    {
        // If the radio was reset recently, just return no calls.  Otherwise this may get
        // queued up after all the init commands, and take a long time to execute, only
        // to find out that there are no calls.  This is bad, since we want to handle
        // the RIL_NOTIFY_DISCONNECT that is sent up during reset so the UI can be
        // updated quickly
        hr = pHandle->GetDevice()->GetNextCmdID();
        pHandle->Notify(RIL_RESULT_OK, hr, NULL, 0);
        RETAILMSG(1, (TEXT("[TI] clcc :RILDrv_GetSpecialCallList:ShouldSpoofCommand=TRUE \r\n")));
    }
    else
#endif // RIL_RADIO_RESILIENCE 
    {
        if (!QueueCmd(pHandle, "AT+CLCC\r", CMDOPT_NONE|CMDOPT_IGNORERADIOOFF, APIID_GETCALLLIST, ParseSpecialGetCallList, NULL, hr)) {
            hr = E_FAIL;
            goto Error;
        }

        
        UpdateCLCCTimes(TRUE);
        
    }

    
    RETAILMSG(1, (TEXT("[TI] clcc :RILDrv_GetSpecialCallList END.... \r\n")));
    
Error:
    return hr;
}
//hang up second incoming call
HRESULT RILDrv_HanugUpSecondIncomingCall(DWORD dwParam)
{
    CALLCTRL_SHARE_MEMORY_OPTION stShareMemOpt;  
    CRilInstanceHandle* pHandle = ExtractHandle(dwParam);
    UINT8 nCallIDInDriver = 0;
    UINT8 nCSDCIDInDriver = 0;    
    char szCmd[MAX_PATH] = {0};
    HRESULT hr = S_OK;
    RETAILMSG(1, (TEXT("[TI]RILDrv_HanugUpSecondIncomingCall enter\r\n")));
    if (!pHandle)
    {
        hr = E_FAIL;
        goto Error;
    }
    if(!RILDrv_CC_GetShareMemOpt(stShareMemOpt))
    {
        hr = E_FAIL;
        goto Error;
    }
    if((RILDrv_CC_IsCallStatusExist(stShareMemOpt.nRILDriver1CallStatus,CALL_STATUS_VOICE_2ND_INCOMING)) || GetFakeHangUpFlagInLocal())//add by fengguisen for new CHINA MOBILE specification 
    {      
        (void)strncpyz(szCmd, "AT%CHLD=0\r", MAX_PATH);
    }
    QueueCmdIgnoreRsp(APIID_NONE, szCmd, CMDOPT_HANGUP|CMDOPT_NOT_SEND_RESPONSE, g_TimeoutAPIDefault, NULL, NULL, 0, 0, 0);        
Error:
    return hr;     
}
//
//
//
HRESULT RILDrv_ManageCalls(DWORD dwParam, DWORD dwCommand, DWORD dwID)
{
    FUNCTION_TRACE(RILDrv_ManageCalls);
    CNotificationData* pnd = NULL;
    BOOL fNeedNotification = TRUE;
    char szCmd[MAX_PATH] = {0};
    DWORD dwOpt = CMDOPT_NONE;
    HRESULT hr = S_OK;

    //add by fengguisen for Simultaneous voice and data call
    UINT8 nCSDCIDInDriver = 0;
    UINT8 n2ndVoiceCIDInDriver = 0;
    UINT8 nCallIDInDriver = 0;
    UINT8 nCallIDInTotal = 0;
    BOOL  bRelease2ndVoiceCall = FALSE;
    BOOL  bCallExist  = FALSE;
    //BOOL  bSendCmd = TRUE;
    BOOL  bRetS_OK = FALSE;
    CALLCTRL_SHARE_MEMORY_OPTION stShareMemOpt;
    BOOL fNeedSendActiveCallNet = FALSE;    
    //end add
    
    CRilInstanceHandle* pHandle = ExtractHandle(dwParam);
    if (!pHandle)
    {
        hr = E_FAIL;
        goto Error;
    }

    nCallIDInTotal = (UINT8)(dwID) ;

    //add by fengguisen for Simultaneous voice and data call
    //change Total call id to Local Driver call ID
    RETAILMSG(1, (TEXT("[TI]RILDrv_ManageCalls: dwCommand=%d,dwID=%d\r\n"),dwCommand,dwID));

    if(!RILDrv_CC_GetShareMemOpt(stShareMemOpt))
    {
        hr = E_FAIL;
        goto Error;
    }

    if(RIL_HOLD_ACTIVE_CALL_ID == dwID)
    {
       // RETAILMSG(1, (TEXT("[TI]RILDrv_ManageCalls: Need hold actvie because df have dialing call\r\n")));
        if((RILDrv_CC_IsCallExist(stShareMemOpt.nRILDriver1CallFlag,CALL_FLAG_VOICE_FIRST))
            &&(RILDrv_CC_IsCallStatusExist(stShareMemOpt.nRILDriver1CallStatus,CALL_STATUS_VOICE_ACTIVE)))
        {
            if(RILDrv_CC_IsCallStatusExist(stShareMemOpt.nRILDriver1CallStatus,CALL_STATUS_VOICE_1ST_INCOMING))
            {
                RETAILMSG(1, (TEXT("[TI]RILDrv_ManageCalls: Need hold actvie and hold sucessful,because TI have incoming call\r\n")));            
                SetEvent(g_hCHLDERROEvent);
            }
            else
            {
            RETAILMSG(1, (TEXT("[TI]RILDrv_ManageCalls: Need hold actvie and hold sucessful\r\n")));
            QueueCmdIgnoreRsp(APIID_NONE, "AT+CHLD=2\r", CMDOPT_FORCEPARSE, g_TimeoutAPIDefault, ParseCHLDResulut, NULL, 0, 0, 0);
        }
        }
        goto Error;
    }
    else if(RIL_CONFIRM_HOLD_CALL_ID == dwID)
    {
        if((!RILDrv_CC_IsCallExist(stShareMemOpt.nRILDriver1CallFlag,CALL_FLAG_VOICE_FIRST))
            &&(!RILDrv_CC_IsCallExist(stShareMemOpt.nRILDriver1CallFlag,CALL_FLAG_CSD)))//
        {
            RETAILMSG(1, (TEXT("[TI]RILDrv_ManageCalls: RIL_CONFIRM_HOLD_CALL_ID there is no call\r\n")));          
            SetEvent(g_hCHLDOKEvent);
        }
        else
        {
            if(ISInCALLProgress())
            {
                RETAILMSG(1, (TEXT("[TI]RILDrv_ManageCalls: RIL_CONFIRM_HOLD_CALL_ID\r\n")));
                QueueCmdIgnoreRsp(APIID_NONE, "AT+CHLD=2\r", CMDOPT_FORCEPARSE, g_TimeoutAPIDefault, ParseCHLDResulut, NULL, 0, 0, 0);
            }
            else
            {
                SetEvent(g_hCHLDOKEvent);             
            }
        }
        goto Error;        
    }
    else if(RIL_WAIT_ANOTHER_HOLD_CALL_ID == dwID)
    {
        RETAILMSG(1, (TEXT("[TI]RILDrv_ManageCalls: RIL_WAIT_ANOTHER_HOLD_CALL_ID\r\n")));
        HANDLE hEvents[2] = {g_hCHLDOKEvent,g_hCHLDERROEvent};
        DWORD dwWaitResult = WaitForMultipleObjects(2, hEvents, FALSE, 10000);	
        if(dwWaitResult == WAIT_OBJECT_0)
        {
            RETAILMSG(1, (TEXT("[TI]RILDrv_ManageCalls:WAIT g_hCHLDOKEvent OKr\n")));
        }
        else if(dwWaitResult == 1+WAIT_OBJECT_0 )//df return erro
        {
            hr = E_FAIL;
            RETAILMSG(1, (TEXT("[TI]RILDrv_ManageCalls:WAIT g_hCHLDERROEvent OKr\n")));
            if(!RILDrv_CC_GetShareMemOpt(stShareMemOpt))
            {
                hr = E_FAIL;
                goto Error;
            }
            if((RILDrv_CC_IsCallStatusExist(stShareMemOpt.nRILDriver2CallStatus,CALL_STATUS_UNKNOWN)))//df have no calls
            {
                hr = S_OK;
                RETAILMSG(1, (TEXT("[TI]RILDrv_ManageCalls:WAIT g_hCHLDERROEvent OK,and DF have NO active calls \n")));                
            }            
        }
        else if (dwWaitResult == WAIT_TIMEOUT)
        {
            hr = E_FAIL;
            RETAILMSG(1, (TEXT("[TI]RILDrv_ManageCalls:WAIT TIMEROUT OKr\n")));
        }
        if( hr == E_FAIL)
        {
            if((RILDrv_CC_IsCallStatusExist(stShareMemOpt.nRILDriver1CallStatus,CALL_STATUS_VOICE_1ST_INCOMING)))
            {
                QueueCmdIgnoreRsp(APIID_NONE, "AT+CHLD=0\r", CMDOPT_HANGUP, g_TimeoutAPIDefault, NULL, NULL, 0, 0, 0);
            }
        }
        else
        {
            if(!RILDrv_CC_IsCallStatusExist(stShareMemOpt.nRILDriver1CallStatus,CALL_STATUS_VOICE_ACTIVE))
            {