gprs.cpp

手机RILGSM实现的源代码

}

// +CGQMIN?
HRESULT RILDrv_GetMinimumQualityOfServiceList (DWORD dwParam)
{
    FUNCTION_TRACE(RILDrv_GetMinimumQualityOfServiceList);
    DEBUGMSG(ZONE_ERROR, (TEXT("RILDrv : E : RILDrv_GetMinimumQualityOfServiceList\r\n")));

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

    if (!QueueCmd(pHandle,
                  "AT+CGQMIN?\r",
                  CMDOPT_NONE,
                  APIID_GETMINIMUMQUALITYOFSERVICELIST,
                  ParseGetMinimumQualityOfServiceList,  // Parse fn
                  NULL,     // Ptr to notification data
                  hr))
    {
        hr = E_FAIL;
        goto Error;
    }

    Error:
    return hr;
}

// +CGQREQ=[<cid> [,<precedence > [,<delay> [,<reliability.> [,<peak> [,<mean>]]]]]]
// +CGQMIN=[<cid> [,<precedence > [,<delay> [,<reliability.> [,<peak> [,<mean>]]]]]]
/*
typedef struct rilgprsqosprofile_tag {
    DWORD cbSize;                       // @field structure size in bytes
    DWORD dwParams;                     // @field indicates valid parameters
    DWORD dwContextID;                  // @field the context number
    DWORD dwPrecedenceClass;            // @field a RIL_GPRSPRECEDENCECLASS_* constant
    DWORD dwDelayClass;                 // @field a RIL_GPRSDELAYCLASS_* constant
    WCHAR dwReliabilityClass;           // @field a RIL_GPRSRELIABILITYCLASS_* constant
    DWORD dwPeakThruClass;              // @field a RIL_GPRSPEAKTHRUCLASS_* constant
    DWORD dwMeanThruClass;              // @field a RIL_GPRSMEANTHRUCLASS_* constant
} RILGPRSQOSPROFILE, *LPRILGPRSQOSPROFILE;
*/
HRESULT SetQOS(DWORD dwParam, const RILGPRSQOSPROFILE* lpGprsQosProfile, LPCSTR szATCmd, const APIID apiid)
{
    FUNCTION_TRACE(RILDrv_SetRequestedQualityOfService);
    DEBUGMSG(ZONE_ERROR, (TEXT("RILDrv : E : RILDrv_SetRequestedQualityOfService\r\n")));

    HRESULT hr = E_INVALIDARG;
    char szCmd[MAX_PATH];
    LPSTR szWalk = szCmd;
    UINT Value;

    CRilInstanceHandle* pHandle = ExtractHandle(dwParam);
    if (!pHandle || !lpGprsQosProfile)
    {
        goto Error;
    }

    // Build command
#if !defined(OEM2_DRIVER)
    (void)_snprintfz(szCmd, MAX_PATH, "AT%s=%u,", szATCmd, lpGprsQosProfile->dwContextID);
    szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
    DEBUGCHK(NULL != szWalk);

    {
#else
    (void)_snprintfz(szCmd, MAX_PATH, "AT%s=%u", szATCmd, lpGprsQosProfile->dwContextID);
    szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
    DEBUGCHK(NULL != szWalk);

    if (lpGprsQosProfile->dwParams & (RIL_PARAM_GQOSP_PRECEDENCECLASS     |
                                      RIL_PARAM_GQOSP_DELAYCLASS          |
                                      RIL_PARAM_GQOSP_RELIABILITYCLASS    |
                                      RIL_PARAM_GQOSP_PEAKTHRUCLASS       |
                                      RIL_PARAM_GQOSP_MEANTHRUCLASS))
    {
        (void)strncpyz(szWalk, ",", MAX_PATH - (szWalk - szCmd));
        szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
        DEBUGCHK(NULL != szWalk);
#endif // defined(OEM2_DRIVER)
        if (lpGprsQosProfile->dwParams & RIL_PARAM_GQOSP_PRECEDENCECLASS)
        {
            if (!ValueFromFlag(lpGprsQosProfile->dwPrecedenceClass,g_GprsPrecedenceClass,NUM_GPRSPRECEDENCECLASS,Value))
            {
                goto Error;
            }
            (void)_snprintfz(szWalk, MAX_PATH - (szWalk - szCmd), "%u",Value);

            szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
            DEBUGCHK(NULL != szWalk);
        }

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

        if (lpGprsQosProfile->dwParams & RIL_PARAM_GQOSP_DELAYCLASS)
        {
            if (!ValueFromFlag(lpGprsQosProfile->dwDelayClass,g_GprsDelayClass,NUM_GPRSDELAYCLASS,Value))
            {
                goto Error;
            }
            (void)_snprintfz(szWalk, MAX_PATH - (szWalk - szCmd), "%u",Value);

            szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
            DEBUGCHK(NULL != szWalk);
        }

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


        if (lpGprsQosProfile->dwParams & RIL_PARAM_GQOSP_RELIABILITYCLASS)
        {
            if (!ValueFromFlag(lpGprsQosProfile->dwReliabilityClass,g_GprsReliabilityClass,NUM_GPRSRELIABILITYCLASS,Value))
            {
                goto Error;
            }
            (void)_snprintfz(szWalk, MAX_PATH - (szWalk - szCmd), "%u",Value);

            szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
            DEBUGCHK(NULL != szWalk);
        }

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

        if (lpGprsQosProfile->dwParams & RIL_PARAM_GQOSP_PEAKTHRUCLASS)
        {
            if (!ValueFromFlag(lpGprsQosProfile->dwPeakThruClass,g_GprsPeakThruClass,NUM_GPRSPEAKTHRUCLASS,Value))
            {
                goto Error;
            }
            (void)_snprintfz(szWalk, MAX_PATH - (szWalk - szCmd), "%u",Value);

            szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
            DEBUGCHK(NULL != szWalk);
        }

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

        if (lpGprsQosProfile->dwParams & RIL_PARAM_GQOSP_MEANTHRUCLASS)
        {
            if (!ValueFromFlag(lpGprsQosProfile->dwMeanThruClass,g_GprsMeanThruClass,NUM_GPRSMEANTHRUCLASS,Value))
            {
                goto Error;
            }
            (void)_snprintfz(szWalk, MAX_PATH - (szWalk - szCmd), "%u",Value);

            szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
            DEBUGCHK(NULL != szWalk);
        }
    }

    // Add "\r"
    (void)strncpyz(szWalk, "\r", MAX_PATH - (szWalk - szCmd));

    if (!QueueCmd(pHandle,
                  szCmd,
                  CMDOPT_NONE,
                  apiid,
                  NULL,     // Parse fn
                  NULL,     // Ptr to notification data
                  hr))
    {
        hr = E_FAIL;
        goto Error;
    }

    Error:
    return hr;
}

// +CGQREQ=<params>
HRESULT RILDrv_SetRequestedQualityOfService (DWORD dwParam, const RILGPRSQOSPROFILE* lpGprsQosProfile)
{
    FUNCTION_TRACE(RILDrv_SetRequestedQualityOfService);
    DEBUGMSG(ZONE_ERROR, (TEXT("RILDrv : E : RILDrv_SetRequestedQualityOfService\r\n")));
    return SetQOS(dwParam,lpGprsQosProfile, "+CGQREQ",APIID_SETREQUESTEDQUALITYOFSERVICE);
}

// +CGQMIN=<params>
HRESULT RILDrv_SetMinimumQualityOfService (DWORD dwParam, const RILGPRSQOSPROFILE* lpGprsQosProfile)
{
    FUNCTION_TRACE(RILDrv_SetRequestedQualityOfService);
    DEBUGMSG(ZONE_ERROR, (TEXT("RILDrv : E : RILDrv_SetMinimumQualityOfService\r\n")));
    return SetQOS(dwParam,lpGprsQosProfile, "+CGQMIN",APIID_SETMINIMUMQUALITYOFSERVICE);
}

HRESULT DeleteQOS(DWORD dwParam, DWORD dwContextID, LPCSTR szATCmd, const APIID apiid)
{
    FUNCTION_TRACE(DeleteQOS);

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

    // Build command
    char szCmd[MAX_PATH];
    (void)_snprintfz(szCmd, MAX_PATH, "AT%s=%u\r", szATCmd, dwContextID);
    if (!QueueCmd(pHandle,
                  szCmd,
#ifdef GPRS_QOS_DELETE_NOOP_HACK
    // QOS deletion happens before every GPRS call currently,
    // and on some radios this is not a good idea.  For now,
    // just NOOP the QOS deletion
                  CMDOPT_NOOP,
#else
                  CMDOPT_NONE,
#endif
                  apiid,
                  NULL,     // Parse fn
                  NULL,     // Ptr to notification data
                  hr))
    {
        hr = E_FAIL;
        goto Error;
    }

    Error:
    return hr;
}

// +CGQREQ=<dwContextID>
HRESULT RILDrv_DeleteRequestedQualityOfService (DWORD dwParam, DWORD dwContextID)
{
    FUNCTION_TRACE(RILDrv_DeleteRequestedQualityOfService);
    DEBUGMSG(ZONE_ERROR, (TEXT("RILDrv : E : RILDrv_DeleteRequestedQualityOfService\r\n")));

    return DeleteQOS(dwParam, dwContextID, "+CGQREQ", APIID_DELETEREQUESTEDQUALITYOFSERVICE);
}

// +CGQMIN=<dwContextID)
HRESULT RILDrv_DeleteMinimumQualityOfService (DWORD dwParam, DWORD dwContextID)
{
    FUNCTION_TRACE(RILDrv_DeleteMinimumQualityOfService);
    DEBUGMSG(ZONE_ERROR, (TEXT("RILDrv : E : RILDrv_DeleteMinimumQualityOfService\r\n")));

    return DeleteQOS(dwParam, dwContextID, "+CGQMIN", APIID_DELETEMINIMUMQUALITYOFSERVICE);
}

// +CGATT=[0|1]
HRESULT RILDrv_SetGPRSAttached (DWORD dwParam, BOOL fAttached)
{
    FUNCTION_TRACE(RILDrv_SetGPRSAttached);
    DEBUGMSG(ZONE_ERROR, (TEXT("RILDrv : E : RILDrv_SetGPRSAttached\r\n")));

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

    // Build command
    char szCmd[MAX_PATH];
    (void)_snprintfz(szCmd, MAX_PATH, "AT+CGATT=%u\r", fAttached ? 1 : 0);

    if (!QueueCmd(pHandle,
                  szCmd,
                  CMDOPT_NONE,
                  APIID_SETGPRSATTACHED,
                  NULL,  // Parse fn
                  NULL,     // Ptr to notification data
                  hr))
    {
        hr = E_FAIL;
        goto Error;
    }

    Error:
    return hr;
}

/*
+CGATT: <state>
<state>: indicates the state of GPRS attachment
0 - detached
1 - attached
*/
HRESULT ParseGetGPRSAttached(LPCSTR szRsp, void*& pBlob, UINT& cbBlob)
{
    FUNCTION_TRACE(ParseGetGPRSAttached);

    UINT nValue;
    HRESULT hr = E_FAIL;
    BOOL *pbResult=NULL;

    pBlob = NULL;
    cbBlob = 0;

    // Parse "<prefix>"
    if (!ParseRspPrefix(szRsp, szRsp))
    {
        goto Error;
    }

    // Parse "+CGATT: "
    if (!MatchStringBeginning(szRsp, "+CGATT: ", szRsp))
    {
        goto Error;
    }

    // Parse <state>
    if (!ParseUInt(szRsp, TRUE, nValue, szRsp))
    {
        goto Error;
    }

    pbResult = (BOOL*)AllocBlob(sizeof(BOOL));
    if (!pbResult)
    {
        goto Error;
    }
    *pbResult=nValue;
    pBlob = (void*)pbResult;
    cbBlob = sizeof(BOOL);
    hr = S_OK;

    Error:
    if (FAILED(hr))
    {
        FreeBlob(pbResult);
    }

    return hr;
}

// +CGATT?
HRESULT RILDrv_GetGPRSAttached (DWORD dwParam)
{
    FUNCTION_TRACE(RILDrv_GetGPRSAttached);
    DEBUGMSG(ZONE_ERROR, (TEXT("RILDrv : E : RILDrv_GetGPRSAttached\r\n")));

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

#ifdef RIL_RADIO_RESILIENCE
    if (ShouldSpoofCommand())
    {
        // If the radio was reset recently, just return FALSE.  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* pfAttachState = (BOOL*)AllocBlob(sizeof(BOOL));
        if (!pfAttachState) {
            hr = E_OUTOFMEMORY;
            goto Error;
        }
        hr = pHandle->GetDevice()->GetNextCmdID();
        *pfAttachState = FALSE;
        pHandle->Notify(RIL_RESULT_OK, hr, pfAttachState, sizeof(BOOL));
    }
    else
#endif // RIL_RADIO_RESILIENCE
    {
        if (!QueueCmd(pHandle,
                      "AT+CGATT?\r",
                      CMDOPT_NONE,
                      APIID_GETGPRSATTACHED,
                      ParseGetGPRSAttached,  // Parse fn
                      NULL,     // Ptr to notification data
                      hr))
        {
            hr=E_FAIL;
            goto Error;
        }
    }
    Error:
    return hr;
}

// +CGACT=[0|1],<dwContextID>[,<dwContextID>...]
HRESULT RILDrv_SetGPRSContextActivated (DWORD dwParam, DWORD dwContextID, BOOL fContextActivation)
{
    FUNCTION_TRACE(RILDrv_SetGPRSContextActivated);
    DEBUGMSG(ZONE_ERROR, (TEXT("RILDrv : E : RILDrv_SetGPRSContextActivated\r\n")));

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

    // Build command
    char szCmd[MAX_PATH];
    (void)_snprintfz(szCmd, MAX_PATH, "AT+CGACT=%u,%u\r", fContextActivation ? 1 : 0, dwContextID);
#if 0
    if(fContextActivation)//zhaozipeng 20070718
        g_dwActiveGPRSContextID = dwContextID;
    else
        g_dwActiveGPRSContextID = 0;
#endif
    // CMDOPT_NOOP is used when fContextActivation=1 because:
    //   If GPRS context activation requires a username/password, then that information would need to be
    //   provided at the time of activation - but the activating entity (CellTSP) does not have access
    //   to the username/password - therefore, we're going to defer activation to the time of
    //   RILDrv_EnterGPRSDataMode and allow the PPP negotiation process to provide the username/password
    //   as it does with normal CSD RAS connections

    if(((RILDrv_CC_GetCallAmountByType(CALL_TYPE_VOICE_FIRST) > 0))
        || (RILDrv_CC_GetCallAmountByType(CALL_TYPE_VOICE_SECOND) > 0)
        || (FALSE == g_bCurrentGprsAttachStatus))
        {
            RETAILMSG(1,(TEXT("[TI]RILDrv_SetGPRSContextActivated: SetGPRSContext Deactivated\r\n")));
            fContextActivation = TRUE;
        }
    
    if (!QueueCmd(pHandle,
        szCmd,
        fContextActivation ? CMDOPT_NOOP : CMDOPT_DEACT,
        APIID_SETGPRSCONTEXTACTIVATED,
        NULL,  // Parse fn