callctrl.cpp

windows mobile RIL软件

    {
        if(RILDrv_OpenMyWav())
        {
            DeviceIoControl (g_hWavDev, IOCTL_GSM_CALL_INACTIVE, 0, 0, NULL, 0, &dwRet, NULL);
        }
    }
#else
    if ( E_FAIL == hr )
    {
        // Indicate call is inactive to audio driver only if call list is empty.
        IndicateCallActivityToAudioSubsystem(FALSE, TRUE);
    }
#endif

    return hr;
}


//
//
//
HRESULT RILDrv_Answer(DWORD dwParam)
{
    FUNCTION_TRACE(RILDrv_Answer);
	DEBUGMSG(ZONE_INFO, (TEXT("RILDrv :+RILDrv_Answer\r\n")));
	
    CNotificationData* pnd = NULL;
    RILCONNECTINFO rci; memset(&rci,0,sizeof(rci)); // zero struct
    HRESULT hr = S_OK;

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

    // Set up the voice connect notification. If  incoming call is a data call,
    //    we will get a "CONNECT" instead of "OK", which will prevent this notification
    //    from being sent
    pnd = new CNotificationData;
    if (pnd) {
        rci.cbSize = sizeof(RILCONNECTINFO);
        rci.dwParams = RIL_PARAM_CNI_CALLTYPE;
#ifdef EMP_DRIVER
        // It may be a VT call on EMP platform, so use the global variable
        rci.dwCallType = g_dwCallType;
#else
        rci.dwCallType = RIL_CALLTYPE_VOICE;
#endif

        // check for externally determined calltype
        if (g_rfExternalCalltypeDetermination)
        {
            //  There may be no call id associated with the call yet,
            //  so use the previously stored calltype
            EnterCriticalSection(&g_csRingingCallData);
            if (g_rcdRingingCallData.fCalltypeValid)
            {
                rci.dwCallType = g_rcdRingingCallData.dwCalltype;
                DEBUGMSG(ZONE_INFO, (TEXT("RILDrv : i : RILDrv_Answer : using calltype %d.\r\n"), g_rcdRingingCallData.dwCalltype));
                g_rcdRingingCallData.dwCalltype = RIL_CALLTYPE_UNKNOWN;
                g_rcdRingingCallData.fCalltypeValid = FALSE;
                //  Just in case there was a call id, clear the associated ringing call globals
                g_rcdRingingCallData.fCallIdValid = FALSE;
                g_rcdRingingCallData.dwCallId = RIL_MAX_TRACKED_CALL_ID;
            }
            DEBUGMSG(ZONE_INFO, (TEXT("RILDrv : i : RILDrv_Answer : Ringing Call TypeValid = %d, type = %d, IdValid = %d, Id = %d, \r\n"), 
                g_rcdRingingCallData.fCalltypeValid, g_rcdRingingCallData.dwCalltype,g_rcdRingingCallData.fCallIdValid,g_rcdRingingCallData.dwCallId));
            LeaveCriticalSection(&g_csRingingCallData);
        }
        
        if (!pnd->InitFromRealBlob(RIL_NOTIFY_CONNECT, &rci, sizeof(RILCONNECTINFO))) {
            delete pnd;
            pnd = NULL;
        }
    }
//#if defined(PHILIP_DRIVER)
#if 0

    BOOL fWaveDevSet = FALSE;
    DWORD dwRet;
    //signal audio driver that at least one call is active
    if(RILDrv_OpenMyWav())
    {
        if (DeviceIoControl (g_hWavDev, IOCTL_GSM_CALL_ACTIVE, 0, 0, NULL, 0, &dwRet, NULL))
        {
            fWaveDevSet = TRUE;
        }
    }
#else
	// Indicate call is Active.
    IndicateCallActivityToAudioSubsystem(TRUE, FALSE);
#endif


//added by viking wang
#if 0 
    EnterCriticalSection(&g_CallInfoSection);
    if (g_iNrCallInfo > 0) 
	{
        INT i;

        for (i=0; i<g_iNrCallInfo; i++) {
            if (g_CallInfo[i].dwStatus==RIL_CALLSTAT_ALERTING) {
                if (g_CallInfo[i].dwType == RIL_CALLTYPE_DATA || g_CallInfo[i].dwType == RIL_CALLTYPE_FAX)
                    bIsCSDCall = FALSE;
            }
            if (g_CallInfo[i].dwStatus==RIL_CALLSTAT_ACTIVE || g_CallInfo[i].dwStatus==RIL_CALLSTAT_ONHOLD) {
                bCallActive = TRUE;
            }
        }
    }
    LeaveCriticalSection(&g_CallInfoSection);
#else
	for (char i = 0; i < RIL_MAX_TRACKED_CALL_ID; i++)
    {
    	if (g_rgfCallsInProgress[i])
        {
			if(g_rgfCallStates[i].dwStatus == RIL_CALLSTAT_ALERTING)
			{
				if(g_rgfCallStates[i].dwType == RIL_CALLTYPE_DATA || g_rgfCallStates[i].dwType == RIL_CALLTYPE_FAX)
					bIsCSDCall = FALSE;
			}
			
        	if ( (g_rgfCallStates[i].dwStatus == RIL_CALLSTAT_ACTIVE) 
			||	(g_rgfCallStates[i].dwStatus == RIL_CALLSTAT_ONHOLD)
			)
            {
           		bCallActive = TRUE; 	
            	break;
            }
        }
    }
#endif
//end adding by viking wang


#ifdef EMP_DRIVER
    // EMP uses *EVA to answer a VT call
    if (RIL_CALLTYPE_VT == g_dwCallType) {
        if (!QueueCmd(pHandle, "AT*EVA\r", CMDOPT_ANSWER, APIID_ANSWER, NULL, pnd, hr)) {
            hr = E_FAIL;
        }
    }
    else
#endif
	//added by viking wang for call manager
	if (bIsCSDCall)
	{

    	if (!QueueCmd(pHandle, "ATA\r", CMDOPT_ANSWER, APIID_ANSWER, NULL, pnd, hr)) {
        	hr = E_FAIL;
        	goto Error;
    	}
	}
	else
	{			
		if (!QueueCmd(pHandle, bCallActive ? "AT+CHLD=2\r" : "ATA\r", CMDOPT_ANSWER, APIID_ANSWER, NULL, pnd, hr)) {
            hr = E_FAIL;
            goto Error;
        }

	/*	if(bCallActive)
		{
			pnd = new CNotificationData;
        	if (pnd && !pnd->InitFromRealBlob(RIL_NOTIFY_CALLSTATECHANGED, NULL, 0)) {
            	delete pnd;
            	pnd = NULL;
        	}
			if (!QueueCmd(pHandle, "AT\r", CMDOPT_NONE, APIID_ANSWER, NULL, pnd, hr)) {
				DEBUGMSG(ZONE_INFO, (TEXT("RILDrv :+RILDrv_Answer:CLCC Error\r\n")));
            	hr = E_FAIL;
            	goto Error;
        	}			
			
		}*/
		
	}
    pnd = NULL;

Error:
//#if defined(PHILIP_DRIVER)
#if 0
    if ((E_FAIL == hr) && (TRUE == fWaveDevSet))
    {
        if(RILDrv_OpenMyWav())
        {
            DeviceIoControl (g_hWavDev, IOCTL_GSM_CALL_INACTIVE, 0, 0, NULL, 0, &dwRet, NULL);
        }
    }
#else
    if (E_FAIL == hr) 
    {
        // Indicate call is inactive to audio driver only if call list is empty.

        IndicateCallActivityToAudioSubsystem(FALSE, TRUE);

    }
#endif

    return hr;
}


//
//
//
HRESULT RILDrv_Hangup(DWORD dwParam)
{
    FUNCTION_TRACE(RILDrv_Hangup);
    CNotificationData* pnd = NULL;
    BOOL fSuccess;
    HRESULT hr = S_OK;
    CRilInstanceHandle* pHandle = ExtractHandle(dwParam);
	DEBUGMSG(ZONE_INFO, (TEXT("RILDrv :+RILDrv_Hangup\r\n")));
    if (!pHandle) {
        hr = E_FAIL;
        goto Error;
    }

    pnd = new CNotificationData;
    if (pnd) {
        if (pHandle->FPreferred()) {
            fSuccess = pnd->InitFromRealBlob(RIL_NOTIFY_EMERGENCYHANGUP, NULL, 0);
        } else {
           // must notify of disconnect here since this lets drivers go to lower power state
            fSuccess = pnd->InitFromDWORDBlob(RIL_NOTIFY_DISCONNECT, RIL_DISCINIT_LOCAL);
        }
        if (!fSuccess) {
            delete pnd;
            pnd = NULL;
        }
    }
#ifdef EMP_DRIVER
    if (RIL_CALLTYPE_VT == g_dwCallType)
    {
        // EMP uses *EVH to hangup a VT call
        if (!QueueCmd(pHandle, "AT*EVH\r", CMDOPT_HANGUP, APIID_HANGUP, NULL, pnd, hr)) {
            hr = E_FAIL;
            goto Error;
        }
    }
    else
#endif
    if (!QueueCmd(pHandle, "ATH\r", CMDOPT_HANGUP, APIID_HANGUP, NULL, pnd, hr)) {
        hr = E_FAIL;
        goto Error;
    }
    pnd = NULL;

Error:
    return hr;
}


//
//
//
HRESULT RILDrv_SendDTMF(DWORD dwParam, LPCSTR lpszChars, DWORD dwDuration)
{
    FUNCTION_TRACE(RILDrv_SendDTMF);
#if !defined(OEM1_DRIVER) && !defined(EMP_DRIVER) // SUPPORT_DTMF_DURATION
    UINT nValue;
#endif
    DEBUGCHK(NULL != lpszChars);
    DEBUGCHK(0 < strlen(lpszChars));

    UINT NumVals;
    DWORD dwTimeout;

    char szCmd[MAX_PATH];
    LPSTR szWalk = szCmd;
    LPCSTR pchChars;
    HRESULT hr = S_OK;
    CRilInstanceHandle* pHandle = ExtractHandle(dwParam);
    if (!pHandle || !lpszChars) {
        hr = E_FAIL;
        goto Error;
    }
DEBUGMSG(ZONE_ERROR, (TEXT("+RILDrv : RILDrv_SendDTMF \r\n")));
#if !defined(OEM1_DRIVER) && !defined(EMP_DRIVER) // SUPPORT_DTMF_DURATION
    if ((dwDuration < 300) || (dwDuration == RIL_DTMFDURATION_DEFAULT))
    {
        dwDuration = 300;
    }

#ifdef PHILIP_DRIVER

    //Alan Luo: Only support VTD=0
    //nValue = (dwDuration + 50 ) / 100;
    nValue = 0;
    
#else
    nValue = (dwDuration + 50 ) / 100;
#endif

    (void)_snprintfz(szWalk, MAX_PATH - (szWalk - szCmd), "AT+VTD=%u;", nValue);
#else
    (void)_snprintfz(szWalk, MAX_PATH - (szWalk - szCmd), "AT");
    // Because we're not setting the duration, the radio is using the default
    // duration.  Make sure we use the default value so the timeout calculation
    // below is correct.
    dwDuration = 300;
#endif
    szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
    DEBUGCHK(NULL != szWalk);

    NumVals=0;
// Alan Luo: Fixed DTMF issue.
#if (!defined(OEM2_DRIVER) && !defined(EMP_DRIVER) && !defined(PHILIP_DRIVER))
    for (pchChars = lpszChars; *pchChars; pchChars++) {
        NumVals++;
        (void)_snprintfz(szWalk, MAX_PATH - (szWalk - szCmd), "+VTS=%c;", *pchChars);
        szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
        DEBUGCHK(NULL != szWalk);
    }
    // remove the trailing ";"
    *(--szWalk) = '\0';
#else

    // OEM2 has a special version of AT+VTS which allows up to 20 DTMF tones in a single command
    // EMP also supports multiple DTMF tones in a sigle command

    pchChars = lpszChars;
    if (*pchChars)
    {
        UINT nSent = 0;
        NumVals++;
        (void)_snprintfz(szWalk, MAX_PATH - (szWalk - szCmd), "+VTS=\"%c", *pchChars);
        szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
        DEBUGCHK(NULL != szWalk);
        pchChars++;
        nSent++;

        // 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++) 
        {
            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) && !defined(EMP_DRIVER)
    (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;
}

//
//
//
static HRESULT ParseGetCallList(LPCSTR szRsp, void*& pBlob, UINT& cbBlob)
{
    FUNCTION_TRACE(ParseGetCallList);
	UINT nNoCalls = 0;
    UINT nValue;
    UINT nUsed = 0;
    UINT nAllocated = 0;
    char szAddress[MAXLENGTH_ADDRESS];
    RILCALLINFO* rgrci = NULL;
    HRESULT hr = S_OK;
    BOOL bSuccess;
    BOOL bIncomingCall = FALSE;
    BOOL rgfNewCallsInProgress[RIL_MAX_TRACKED_CALL_ID] = { 0 };  // Initialize to FALSE
#if defined(OEM1_DRIVER_WAVEXT) //|| defined(PHILIP_DRIVER)
    // Used for Call Conference on P2-Sample
    DWORD dwRet = 0;
    static BOOL fInCall = FALSE;
#endif  //
    pBlob = NULL;
    cbBlob = 0;