callctrl.cpp

手机RILGSM实现的源代码

            (void)_snprintfz(szWalk, CALLCTRL_CMDBUF_LENGTH - (szWalk - szCmd), ",\"%s\",%u", szSubAddress, bType);
            szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
            DEBUGCHK(NULL != szWalk);
        }
    }
    (void)strncpyz(szWalk, "\r", CALLCTRL_CMDBUF_LENGTH - (szWalk - szCmd));  // NO_TYPO: 30

    if (!QueueCmd(pHandle, szCmd, CMDOPT_NONE, APIID_TRANSFERCALL, NULL, NULL, hr)) {
        hr = E_FAIL;
        goto Error;
    }

Error:
#else  // WAVECOM_DRIVER

    HRESULT hr = E_NOTIMPL;
#endif // WAVECOM_DRIVER

    return hr;
}


//
//
//
static HRESULT ParseGetLineStatusRsp(LPCSTR szRsp, void*& pBlob, UINT& cbBlob)
{
    FUNCTION_TRACE(ParseGetLineStatusRsp);
    UINT nValue;
    DWORD* pdwLineStatus = NULL;
    HRESULT hr = S_OK;

    pBlob = NULL;
    cbBlob = 0;

    pdwLineStatus = (DWORD*)AllocBlob(sizeof(DWORD));
    if (!pdwLineStatus) {
        hr = E_OUTOFMEMORY;
        goto Error;
    }
    memset(pdwLineStatus, 0x00, sizeof(DWORD));

    // Parse "<prefix>+CPAS: <line_status><postfix>"
    if (!ParseRspPrefix(szRsp, szRsp)                                  ||
        !MatchStringBeginning(szRsp, "+CPAS: ", szRsp)                 ||
        !ParseUIntAndVerifyAbove(szRsp, TRUE, NUM_LINESTATS, nValue, szRsp) ||
        !ParseRspPostfix(szRsp, szRsp)) {
        hr = E_FAIL;
        goto Error;
    }
    *pdwLineStatus = g_rgdwLineStats[nValue];
#if 0
    SetBacklightIncomingCall(RIL_LINESTAT_RINGING == g_rgdwLineStats[nValue]);
#endif
    pBlob = (void*)pdwLineStatus;
    cbBlob = sizeof(DWORD);

Error:
    if (FAILED(hr)) {
        FreeBlob(pdwLineStatus);
    }
    return hr;
}


//
//
//
HRESULT RILDrv_GetLineStatus(DWORD dwParam)
{
    FUNCTION_TRACE(RILDrv_GetLineStatus);
    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 idle line status.  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        
        DWORD* pdwLineStatus = (DWORD*)AllocBlob(sizeof(DWORD));
        if (!pdwLineStatus) {
            hr = E_OUTOFMEMORY;
            goto Error;
        }
        hr = pHandle->GetDevice()->GetNextCmdID();
        *pdwLineStatus = RIL_LINESTAT_READY;
        pHandle->Notify(RIL_RESULT_OK, hr, pdwLineStatus, sizeof(DWORD));
    }
    else
#endif // RIL_RADIO_RESILIENCE
    {
        if (!QueueCmd(pHandle, "AT+CPAS\r", CMDOPT_NONE, APIID_GETLINESTATUS, ParseGetLineStatusRsp, NULL, hr)) {
            hr = E_FAIL;
            goto Error;
        }
    }

Error:
    return hr;
}

//
//
//
HRESULT RILDrv_SetCurrentAddressId(DWORD dwParam, DWORD dwAddressId)
{
    FUNCTION_TRACE(RILDrv_SetCurrentAddressId);
#ifdef OEM1_DRIVER
    HRESULT hr = S_OK;
    char szCmd[MAX_PATH];
    CNotificationData* pnd = NULL;
    CRilInstanceHandle* pHandle = ExtractHandle(dwParam);
    if (!pHandle) {
        hr = E_FAIL;
        goto Error;
    }

    pnd = new CNotificationData;
    if (pnd && !pnd->InitFromDWORDBlob(RIL_NOTIFY_CURRENTLINECHANGED, dwAddressId)) {
        delete pnd;
        pnd = NULL;
    }

    (void)_snprintfz(szCmd, MAX_PATH, "AT%%ALS=%u\r", dwAddressId);
    if (!QueueCmd(pHandle, szCmd, CMDOPT_NONE, APIID_SETCURRENTADDRESSID, NULL, pnd, hr)) {
        hr = E_FAIL;
        goto Error;
    }

Error:
#else
    HRESULT hr = E_NOTIMPL;
#endif
    return hr;
}

//
//
//
static HRESULT ParseGetCurrentAddressId(LPCSTR szRsp, void*& pBlob, UINT& cbBlob)
{
    FUNCTION_TRACE(ParseGetCurrentAddressId);
    UINT nValue;
    DWORD* pdwAddressId = NULL;
    HRESULT hr = S_OK;

    pBlob = NULL;
    cbBlob = 0;

    pdwAddressId = (DWORD*)AllocBlob(sizeof(DWORD));
    if (!pdwAddressId) {
        hr = E_OUTOFMEMORY;
        goto Error;
    }
    *pdwAddressId = 0;

    // Parse "<prefix>%ALS: <addressID><postfix>"
    if (!ParseRspPrefix(szRsp, szRsp)                   ||
        !MatchStringBeginning(szRsp, "%ALS: ", szRsp)   ||
        !ParseUInt(szRsp, TRUE, nValue, szRsp)          ||
        !ParseRspPostfix(szRsp, szRsp)) {
        hr = E_FAIL;
        goto Error;
    }
    *pdwAddressId = nValue;

    pBlob = (void*)pdwAddressId;
    cbBlob = sizeof(DWORD);

Error:
    if (FAILED(hr)) {
        FreeBlob(pdwAddressId);
    }
    return hr;
}

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

    if (!QueueCmd(pHandle, "AT%ALS?\r", CMDOPT_NONE, APIID_GETCURRENTADDRESSID, ParseGetCurrentAddressId, NULL, hr)) {
        hr = E_FAIL;
        goto Error;
    }

Error:
#else
    HRESULT hr = E_NOTIMPL;
#endif
    return hr;
}


//
//Added by wuguangliang
//Is in a call or not?
//
BOOL    ISInCALLProgress()
{
    //Indicator in a call
    BOOL bCallInProgress =FALSE;

    for(int i=0; i<RIL_MAX_TRACKED_CALL_ID; i++)
    {
        if (RIL_PARAM_CI_CPISTATUS  & g_rgfCallStates[i].dwParams)
        {
            switch (g_rgfCallStates[i].dwStatus)
            {
                case RIL_CPISTAT_CONNECTED:
                case RIL_CPISTAT_NEW_INCOMING:
                case RIL_CPISTAT_NEW_OUTGOING:
                    bCallInProgress = TRUE;
                    break;
                case RIL_CPISTAT_UNKNOWN :
                    if ( TRUE == g_rgfTCHAssigned[i] )
                    {
                        bCallInProgress = TRUE;
                    }
                    break;
                default:
                    break;
            }
        }
        else if (RIL_PARAM_CI_STATUS  & g_rgfCallStates[i].dwParams)
        {
            switch (g_rgfCallStates[i].dwStatus)
            {
                case RIL_CALLSTAT_ACTIVE:      
                case RIL_CALLSTAT_ONHOLD:  
                case RIL_CALLSTAT_DIALING: 
                case RIL_CALLSTAT_ALERTING: 
                case RIL_CALLSTAT_INCOMING: 
                case RIL_CALLSTAT_WAITING:
                    bCallInProgress = TRUE;
                    break;

                default:
                    break;
            }
        }

        if (bCallInProgress){
            break;
        }
    }

    return bCallInProgress;
}


//
//Active all call if all calls are hold
//
void ActiveIFALLHOLD()
{
    UINT iActivecalls =0;
    UINT iHoldcalls = 0;
    UINT iCallsInproceeding =0;
    
    for(int i=0; i<RIL_MAX_TRACKED_CALL_ID; i++)
    {
        if ((RIL_PARAM_CI_STATUS  & g_rgfCallStates[i].dwParams))
	{
	        switch (g_rgfCallStates[i].dwStatus)
	        {
		    case RIL_CALLSTAT_ACTIVE:      
                        iActivecalls++;
                        break;
          	    case RIL_CALLSTAT_ONHOLD:  
                        iHoldcalls++;
		         break;

		    case RIL_CALLSTAT_DIALING: 
		    case RIL_CALLSTAT_ALERTING: 
		    case RIL_CALLSTAT_INCOMING: 
		    case RIL_CALLSTAT_WAITING:
		        iCallsInproceeding++;
		        break;
                     
		    default:
			break;
		}	
	}
    }

	//Active if all are in hold status
    if (iHoldcalls>0 && iActivecalls ==0 && iCallsInproceeding ==0 )
    {
         QueueCmdIgnoreRsp(APIID_NONE, "AT+CHLD=2\r", CMDOPT_NONE, g_TimeoutAPIDefault, NULL, NULL, 0, 0, 0);
    }

}

//
//Active all call if all calls are hold
//
DWORD GetReleaseIncomingCallID()
{
    UINT iConnectedCalls =0;
    UINT iIncomingCalls =0;

    DWORD dwID =-1;
    
    for(int i=0; i<RIL_MAX_TRACKED_CALL_ID; i++)
    {
        if ((RIL_PARAM_CI_STATUS  & g_rgfCallStates[i].dwParams))
	{
	        switch (g_rgfCallStates[i].dwStatus)
	        {
		    case RIL_CALLSTAT_ACTIVE:      
          	    case RIL_CALLSTAT_ONHOLD:  
                        iConnectedCalls++;
		         break;

		    case RIL_CALLSTAT_DIALING: 
		    case RIL_CALLSTAT_ALERTING: 
		    case RIL_CALLSTAT_INCOMING: 
		    case RIL_CALLSTAT_WAITING:
                       if (g_rgfCallStates[i].dwDirection == RIL_CALLDIR_INCOMING)
                       {
		            iIncomingCalls++;
                          dwID = i;
                        }
		        break;
                     
		    default:
			break;
		}	
	}
    }

    if (iConnectedCalls>0 && iIncomingCalls==1)
    {
        return dwID;
    }
    else
        return -1;
}

//add by fengguisen for Simultaneous voice and data call

// ===========================================================
// Function Name: S