voice.cpp

windows mobile RIL软件

    prgi->dwParams |= RIL_PARAM_GI_TXGAIN;
#endif

    pBlob = (void*)prgi;
    cbBlob = sizeof(RILGAININFO);

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


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

#if defined(OEM1_DRIVER) || defined(OEM2_DRIVER) || defined(EMP_DRIVER)
    if (!QueueCmd(pHandle, "AT\r", CMDOPT_NONE, APIID_GETAUDIOGAIN, ParseGetAudioGain, NULL, hr)) {
#else
    if (!QueueCmd(pHandle, "AT+VGR?;+VGT?\r", CMDOPT_NONE, APIID_GETAUDIOGAIN, ParseGetAudioGain, NULL, hr)) {
#endif
        hr = E_FAIL;
        goto Error;
    }

Error:
    return hr;
}


//
//
//
HRESULT RILDrv_SetAudioGain(DWORD dwParam, const RILGAININFO* lpGainInfo)
{
    FUNCTION_TRACE(RILDrv_SetAudioGain);
    char szCmd[MAX_PATH];
    LPSTR szWalk = szCmd;
    HRESULT hr = S_OK;
    CRilInstanceHandle* pHandle = ExtractHandle(dwParam);
    if (!pHandle || !lpGainInfo) {
        hr = E_FAIL;
        goto Error;
    }

    if (!(lpGainInfo->dwParams & RIL_PARAM_GI_RXGAIN) && !(lpGainInfo->dwParams & RIL_PARAM_GI_TXGAIN)) {
        hr = E_INVALIDARG;
        goto Error;
    }

    (void)strncpyz(szWalk, "AT", MAX_PATH - (szWalk - szCmd));
    szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
    DEBUGCHK(NULL != szWalk);

    if (lpGainInfo->dwParams & RIL_PARAM_GI_RXGAIN) {
#if defined(WAVECOM_DRIVER)
        // Wavecom module specifies gain opposite GSM 07.07, C.2.4
        (void)_snprintfz(szWalk, MAX_PATH - (szWalk - szCmd), "+VGR=%u", 255 - (lpGainInfo->dwRxGain >> 24));
#else // Standard GSM case, used for OEM1 and OEM2 and EMP
        g_dwCacheDownlinkVolume = (lpGainInfo->dwRxGain >> 24);
#ifdef OEM2_DRIVER
        // downlink volume on OEM2 is in the range 0-100, not 0-255, so nomalize here.
        g_dwCacheDownlinkVolume = (g_dwCacheDownlinkVolume*100)/255;
#elif defined(EMP_DRIVER)
        // downlink volume on EMP is in the range 0-8, not 0-255, so nomalize here.
        g_dwCacheDownlinkVolume = (g_dwCacheDownlinkVolume*8)/255;
#endif // OEM2_DRIVER
        (void)_snprintfz(szWalk, MAX_PATH - (szWalk - szCmd), "+CLVL=%u", g_dwCacheDownlinkVolume);
#endif // Standard GSM case
        szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
        DEBUGCHK(NULL != szWalk);

#if !defined(OEM2_DRIVER) && !defined(OEM1_DRIVER) && !defined(EMP_DRIVER)
        if (lpGainInfo->dwParams & RIL_PARAM_GI_TXGAIN) {
            (void)strncpyz(szWalk, ";", MAX_PATH - (szWalk - szCmd));
            szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
            DEBUGCHK(NULL != szWalk);
        }
#endif
    }

#if !defined(OEM2_DRIVER) && !defined(OEM1_DRIVER) && !defined(EMP_DRIVER) // OEM1 and OEM2 and EMP do not support an AT command to modify Tx gain
    if (lpGainInfo->dwParams & RIL_PARAM_GI_TXGAIN) {
        (void)_snprintfz(szWalk, MAX_PATH - (szWalk - szCmd), "+VGT=%u", (lpGainInfo->dwTxGain >> 24));

        szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
        DEBUGCHK(NULL != szWalk);
    }
#else // OEM1 and OEM2 and EMP
    g_dwCacheUplinkVolume = lpGainInfo->dwTxGain;   // For OEM1 and OEM2 and EMP, only cache TxGain value in gsm driver, no AT command is sent out.
#endif
    
    (void)strncpyz(szWalk, "\r", MAX_PATH - (szWalk - szCmd));  // NO_TYPO: 30

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

Error:
    return hr;
}

#endif

//
//
//
HRESULT RILDrv_SetAudioDevices(DWORD dwParam, const RILAUDIODEVICEINFO* lpAudioDeviceInfo)
{
    FUNCTION_TRACE(RILDrv_SetAudioDevices);
#if defined(WAVECOM_DRIVER) || defined(OEM1_DRIVER)
    // HW-SPECIFIC: This uses WaveCom-specific IOCTLs

    DWORD dwDummy;
    CComHandle* pComDevice;
    HRESULT hr = S_OK;
    CRilInstanceHandle* pHandle = ExtractHandle(dwParam);
    if (!pHandle || !lpAudioDeviceInfo) {
        hr = E_FAIL;
        goto Error;
    }

    if (!(lpAudioDeviceInfo->dwParams & RIL_PARAM_ADI_TXDEVICE) &&
        !(lpAudioDeviceInfo->dwParams & RIL_PARAM_ADI_RXDEVICE)) {
        hr = E_INVALIDARG;
        goto Error;
    }

    if (lpAudioDeviceInfo->dwParams & RIL_PARAM_ADI_TXDEVICE) {
        DEBUGCHK(NULL != pHandle->GetDevice());
        DEBUGCHK(NULL != pHandle->GetDevice()->GetComDevice());
        pComDevice = pHandle->GetDevice()->GetComDevice();

        if (RIL_AUDIO_NONE == lpAudioDeviceInfo->dwTxDevice) {
            (void)pComDevice->IOControl(IOCTL_SPKR_DISABLE, NULL, 0, NULL, 0, dwDummy);
        } else {
            (void)pComDevice->IOControl(IOCTL_SPKR_ENABLE, NULL, 0, NULL, 0, dwDummy);
        }
    }

    // Send a no-op AT command to force an OK response
    if (!QueueCmd(pHandle, NULL, CMDOPT_NOOP, APIID_SETAUDIODEVICES, NULL, NULL, hr)) {
        hr = E_FAIL;
        goto Error;
    }
Error:

#else  // defined(WAVECOM_DRIVER) || defined(OEM1_DRIVER) 

    HRESULT hr = E_NOTIMPL;
#endif // defined(WAVECOM_DRIVER) || defined(OEM1_DRIVER)

    return hr;
}


//
//
//
static HRESULT ParseGetAudioMuting(LPCSTR szRsp, void*& pBlob, UINT& cbBlob)
{
    FUNCTION_TRACE(ParseGetAudioMuting);
    BOOL* pfEnabled = NULL;
    HRESULT hr = S_OK;

    pBlob = NULL;
    cbBlob = 0;

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


#ifdef RIL_CACHE_AUDIO_MUTING

    *pfEnabled = g_fAudioMutingOn;

#else // RIL_CACHE_AUDIO_MUTING

    UINT nValue;

    // Parse "<prefix>+CMUT: <enabled><postfix>"
    if (!ParseRspPrefix(szRsp, szRsp)                           ||
        !MatchStringBeginning(szRsp, "+CMUT: ", szRsp)          ||
        !ParseUIntAndVerifyAbove(szRsp, TRUE, 2, nValue, szRsp) ||
        !ParseRspPostfix(szRsp, szRsp)) {
        hr = E_FAIL;
        goto Error;
    }
    *pfEnabled = (1 == nValue);

#endif // RIL_CACHE_AUDIO_MUTING

    pBlob = (void*)pfEnabled;
    cbBlob = sizeof(BOOL);

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


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

#ifdef RIL_CACHE_AUDIO_MUTING

    if (!QueueCmd(pHandle,  NULL, CMDOPT_NOOP, APIID_GETAUDIOMUTING, ParseGetAudioMuting, NULL, hr)) {
        hr = E_FAIL;
        goto Error;
    }   

#else   // RIL_CACHE_AUDIO_MUTING

#ifdef RIL_RADIO_RESILIENCE
    if (ShouldSpoofCommand())
    {
        // If the radio was reset recently, just return unmuted.  Otherwise this may get
        // queued up after all the init commands, and take a long time to execute
        // 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        
        BOOL* pfEnabled = (BOOL*)AllocBlob(sizeof(BOOL));
        if (!pfEnabled) {
            hr = E_OUTOFMEMORY;
            goto Error;
        }
        hr = pHandle->GetDevice()->GetNextCmdID();
        *pfEnabled = FALSE;
        pHandle->Notify(RIL_RESULT_OK, hr, pfEnabled, sizeof(BOOL));
    }
    else
#endif // RIL_RADIO_RESILIENCE
    {
        if (!QueueCmd(pHandle, "AT+CMUT?\r", CMDOPT_NONE, APIID_GETAUDIOMUTING, ParseGetAudioMuting, NULL, hr)) {
            hr = E_FAIL;
            goto Error;
        }
    }

#endif  // RIL_CACHE_AUDIO_MUTING

Error:
    return hr;
}


//
//
//
HRESULT RILDrv_SetAudioMuting(DWORD dwParam, BOOL fEnable)
{
    FUNCTION_TRACE(RILDrv_SetAudioMuting);
    char szCmd[MAX_PATH];
    HRESULT hr = S_OK;
    CRilInstanceHandle* pHandle = ExtractHandle(dwParam);
    if (!pHandle) {
        hr = E_FAIL;
        goto Error;
    }

    (void)_snprintfz(szCmd, MAX_PATH, "AT+CMUT=%u\r", (fEnable ? 1 : 0));
    if (!QueueCmd(pHandle, szCmd, CMDOPT_NONE, APIID_SETAUDIOMUTING, NULL, NULL, hr)) {
        hr = E_FAIL;
        goto Error;
    }
#if defined (RIL_CACHE_AUDIO_MUTING)    
    else {
        g_fAudioMutingOn = fEnable;
    }
#endif  // RIL_CACHE_AUDIO_MUTING

Error:
    return hr;
}