msg.cpp

手机RILGSM实现的源代码

    UINT nValue;
    BOOL fStorageSpecified = TRUE;
    RILMSGSTORAGEINFO rmsi; memset(&rmsi,0,sizeof(rmsi)); // zero struct
    HRESULT hr = S_OK;
    CRilInstanceHandle* pHandle = ExtractHandle(dwParam);
    if (!pHandle || !lpMsgServiceInfo)
    {
        hr = E_FAIL;
        goto Error;
    }

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

    if (lpMsgServiceInfo->dwParams & RIL_PARAM_MSI_SERVICE)
    {
        if (RIL_MSGSVCTYPE_PHASE2 == lpMsgServiceInfo->dwService)
        {
            nValue = 0;
        }
        else if (RIL_MSGSVCTYPE_PHASE2PLUS == lpMsgServiceInfo->dwService)
        {
            nValue = 1;
        }
        else
        {
            DEBUGCHK(FALSE);
        }

        // Add "+CSMS=<service>"
        (void)_snprintfz(szWalk, MAX_PATH - (szWalk - szCmd), "+CSMS=%u", nValue);
        szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
        DEBUGCHK(NULL != szWalk);
    }


#ifdef WAVECOM_DRIVER
    // HW-SPECIFIC: WaveCom hardware reports data for only one storage location

    // Figure out the storage value we need to set
    if (lpMsgServiceInfo->dwParams & RIL_PARAM_MSI_READLOCATION)
    {
        nValue = lpMsgServiceInfo->dwReadLocation;
    }
    else if (lpMsgServiceInfo->dwParams & RIL_PARAM_MSI_WRITELOCATION)
    {
        nValue = lpMsgServiceInfo->dwWriteLocation;
    }
    else if (lpMsgServiceInfo->dwParams & RIL_PARAM_MSI_STORELOCATION)
    {
        nValue = lpMsgServiceInfo->dwStoreLocation;
    }
    else
    {
        fStorageSpecified = FALSE;
    }

    // Set the storage, if it is provided
    if (fStorageSpecified)
    {
        DEBUGCHK(NUM_MSGLOCS > nValue);

        if (RIL_MSGLOC_UNKNOWN == nValue)
        {
            hr = E_INVALIDARG;
            goto Error;
        }

        // Add ";", if needed
        if (szWalk != szCmd + 2)
        {  // NO_TYPO: 30
            (void)strncpyz(szWalk, ";", MAX_PATH - (szWalk - szCmd));
            szWalk++;
        }

        // Add "+CPMS=<storage>"
        (void)_snprintfz(szWalk, MAX_PATH - (szWalk - szCmd), "+CPMS=\"%s\"", g_rgszMsgLocations[nValue]);
        szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
        DEBUGCHK(NULL != szWalk);

        rmsi.dwReadLocation = nValue;
        rmsi.dwWriteLocation = nValue;
        rmsi.dwStoreLocation = nValue;
        rmsi.dwParams = RIL_PARAM_MSTI_ALL;
    }
#else  // WAVECOM_DRIVER


    if ((lpMsgServiceInfo->dwParams & RIL_PARAM_MSI_READLOCATION) ||
        (lpMsgServiceInfo->dwParams & RIL_PARAM_MSI_WRITELOCATION) ||
        (lpMsgServiceInfo->dwParams & RIL_PARAM_MSI_STORELOCATION))
    {
        // At least one location is specified

        // Add ";", if needed
        if (szWalk != szCmd + 2)
        {  // NO_TYPO: 30
            (void)strncpyz(szWalk, ";", MAX_PATH - (szWalk - szCmd));
            szWalk++;
        }

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

        if (lpMsgServiceInfo->dwParams & RIL_PARAM_MSI_READLOCATION)
        {
            nValue = lpMsgServiceInfo->dwReadLocation;
            if (RIL_MSGLOC_UNKNOWN == nValue)
            {
                hr = E_INVALIDARG;
                goto Error;
            }
            DEBUGCHK(NUM_MSGLOCS > nValue);

            // Add "<read_storage>"
            (void)_snprintfz(szWalk, MAX_PATH - (szWalk - szCmd), "\"%s\"", g_rgszMsgLocations[nValue]);
            szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
            DEBUGCHK(NULL != szWalk);

            rmsi.dwReadLocation = nValue;
            rmsi.dwParams |= RIL_PARAM_MSTI_READLOCATION;
        }

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

        if (lpMsgServiceInfo->dwParams & RIL_PARAM_MSI_WRITELOCATION)
        {
            nValue = lpMsgServiceInfo->dwWriteLocation;
            if (RIL_MSGLOC_UNKNOWN == nValue)
            {
                hr = E_INVALIDARG;
                goto Error;
            }
            DEBUGCHK(NUM_MSGLOCS > nValue);

            // Add "<write_storage>"
            (void)_snprintfz(szWalk, MAX_PATH - (szWalk - szCmd), "\"%s\"", g_rgszMsgLocations[nValue]);
            szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
            DEBUGCHK(NULL != szWalk);

            rmsi.dwWriteLocation = nValue;
            rmsi.dwParams |= RIL_PARAM_MSTI_WRITELOCATION;
        }

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

        if (lpMsgServiceInfo->dwParams & RIL_PARAM_MSI_STORELOCATION)
        {
            nValue = lpMsgServiceInfo->dwStoreLocation;
            if (RIL_MSGLOC_UNKNOWN == nValue)
            {
                hr = E_INVALIDARG;
                goto Error;
            }
            DEBUGCHK(NUM_MSGLOCS > nValue);

            // Add "<store_storage>"
            (void)_snprintfz(szWalk, MAX_PATH - (szWalk - szCmd), "\"%s\"", g_rgszMsgLocations[nValue]);
            szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
            DEBUGCHK(NULL != szWalk);

            rmsi.dwStoreLocation = nValue;
            rmsi.dwParams |= RIL_PARAM_MSTI_STORELOCATION;
        }
    }
#endif // WAVECOM_DRIVER


    // Add "<CR>"
    (void)strncpyz(szWalk, "\r", MAX_PATH - (szWalk - szCmd));  // NO_TYPO: 30

    if (rmsi.dwParams)
    {
        pnd = new CNotificationData;
        if (pnd)
        {
            rmsi.cbSize = sizeof(RILMSGSTORAGEINFO);
            if (!pnd->InitFromRealBlob(RIL_NOTIFY_MSGSTORAGECHANGED, &rmsi, sizeof(RILMSGSTORAGEINFO)))
            {
                delete pnd;
                pnd = NULL;
            }
        }
    }

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

    Error:
    return hr;
}


//
//
//
static HRESULT ParseGetMsgConfigRsp(LPCSTR szRsp, void*& pBlob, UINT& cbBlob)
{
    FUNCTION_TRACE(ParseGetMsgConfigRsp);
    UINT nValue;
    char szAddress[MAX_PATH];
    //    char szLanguageRange[MAX_PATH];
    RILMSGCONFIG* prmc = NULL;
    HRESULT hr = S_OK;
    ENCODING_TYPE etEncoding = ENCODING_GSMDEFAULT_HEX;

    pBlob = NULL;
    cbBlob = 0;

    prmc = (RILMSGCONFIG*)AllocBlob(sizeof(RILMSGCONFIG));
    if (!prmc)
    {
        hr = E_OUTOFMEMORY;
        goto Error;
    }
    memset(prmc, 0x00, sizeof(RILMSGCONFIG));
    prmc->cbSize = sizeof(RILMSGCONFIG);

    // Parse "<prefix>+CSCA: <svcctr_addr>,<type_of_addr><postfix>"
    if (!ParseRspPrefix(szRsp, szRsp)                               ||
        !MatchStringBeginning(szRsp, "+CSCA: ", szRsp)              ||
        !ParseString(szRsp, szAddress, MAX_PATH, szRsp)             ||
        !MatchStringBeginning(szRsp, ",", szRsp)                    ||
        !ParseUIntAndVerifyAbove(szRsp, TRUE, 0x100, nValue, szRsp) ||
        !ParseRspPostfix(szRsp, szRsp))
    {
        hr = E_FAIL;
        goto Error;
    }


#ifdef OEM2_DRIVER  // OEM2 uses GSM unpacked characters.
    etEncoding = ENCODING_GSMDEFAULT_UNICODE;
#endif

    // Convert data to address structure
    if (!StringToRILAddress(szAddress, (BYTE)nValue, prmc->raSvcCtrAddress, etEncoding))
    {
        hr = E_FAIL;
        goto Error;
    }
    prmc->dwParams |= RIL_PARAM_MC_SVCCTRADDRESS;

    pBlob = (void*)prmc;
    cbBlob = sizeof(RILMSGCONFIG);

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

}


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

    if (!QueueCmd(pHandle, "AT+CSCA?\r", CMDOPT_NONE, APIID_GETMSGCONFIG, ParseGetMsgConfigRsp, NULL, hr))
    {
        hr = E_FAIL;
        goto Error;
    }

    Error:
    return hr;
}


//
//
//
HRESULT RILDrv_SetMsgConfig(DWORD dwParam, const RILMSGCONFIG* lpMsgConfigInfo)
{
    FUNCTION_TRACE(RILDrv_SetMsgConfig);
    char szCmd[MAXLENGTH_MSGIDS + MAX_PATH * 3];
    LPSTR szWalk = szCmd;
    char szSvcCtrAddress[MAX_PATH];
    BYTE bTypeOfAddress;
    HRESULT hr = S_OK;
    ENCODING_TYPE etEncoding = ENCODING_GSMDEFAULT_HEX;
    
    CRilInstanceHandle* pHandle = ExtractHandle(dwParam);
    if (!pHandle || !lpMsgConfigInfo)
    {
        hr = E_FAIL;
        goto Error;
    }

    (void)strncpyz(szWalk, "AT", MAX_PATH - (szWalk - szCmd));
    szWalk += 2;

    if (lpMsgConfigInfo->dwParams & RIL_PARAM_MC_SVCCTRADDRESS)
    {

#ifdef OEM2_DRIVER  // OEM2 uses GSM unpacked characters.
        etEncoding = ENCODING_GSMDEFAULT_UNICODE;
#endif
        
        hr = RILAddressToString(lpMsgConfigInfo->raSvcCtrAddress, szSvcCtrAddress, MAX_PATH, bTypeOfAddress, etEncoding);
        if (FAILED(hr))
        {
            goto Error;
        }
        (void)_snprintfz(szWalk, MAX_PATH - (szWalk - szCmd), "+CSCA=\"%s\",%u", szSvcCtrAddress, bTypeOfAddress);
        szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
        DEBUGCHK(NULL != szWalk);
    }

    (void)strncpyz(szWalk, ";+CSAS\r", MAX_PATH - (szWalk - szCmd));  // NO_TYPO: 30

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

    Error:
    return hr;
}

static RILCBMSGCONFIG * AllocCbMsgConfig(DWORD dwNumRanges)
{
    DWORD dwSize = sizeof(RILCBMSGCONFIG) + dwNumRanges * sizeof(RILRANGE);

    RILCBMSGCONFIG* prmc = (RILCBMSGCONFIG*)AllocBlob(dwSize);
    if (NULL != prmc)
    {
        memset(prmc, 0x00, dwSize);
        prmc->cbSize = dwSize;
    }

    return prmc;
}

//
//
//
static HRESULT ParseBroadcastMsgIDs(const LPCSTR szBroadcastMsgIDs,
                                    RILCBMSGCONFIG ** pprCbMsgConfig)
{
    DEBUGCHK(NULL != szBroadcastMsgIDs);

    HRESULT hr = S_OK;
    DWORD dwNumRanges;
    LPCSTR szDummy;
    DWORD dwNumIDs = 0;

    if (*szBroadcastMsgIDs)
    {
        dwNumIDs++;

        for (LPCSTR szPtr = szBroadcastMsgIDs; '\0' != *szPtr; szPtr++)
        {
            if (',' == *szPtr)
                dwNumIDs++;
        }
    }

    *pprCbMsgConfig = AllocCbMsgConfig(dwNumIDs);
    if (NULL == *pprCbMsgConfig)
    {
        hr = E_OUTOFMEMORY;
        goto Error;
    }

    if (!ParseRangesFromString(szBroadcastMsgIDs,
                               (*pprCbMsgConfig)->rgrrBroadcastMsgIDs,
                               dwNumRanges,
                               dwNumIDs,
                               szDummy))
    {
        hr = E_FAIL;
        goto Error;
    }

    DEBUGCHK(dwNumRanges == dwNumIDs);

Error:
    return hr;
}

//
//
//
static HRESULT ParseGetCellBroadcastMsgConfigRsp(LPCSTR szRsp, void*& pBlob, UINT& cbBlob)
{
    FUNCTION_TRACE(ParseGetCellBroadcastMsgConfigRsp);
    UINT nValue;
    BOOL fAccept = FALSE;
    char szLanguageRange[MAX_PATH];
    char szBroadcastMsgIDs[MAXLENGTH_MSGIDS];
    RILCBMSGCONFIG* prmc = NULL;
    HRESULT hr = S_OK;

    pBlob = NULL;
    cbBlob = 0;

    // Parse "<prefix>+CSCB: <mode>"
    if (!ParseRspPrefix(szRsp, szRsp)                  ||
        !MatchStringBeginning(szRsp, "+CSCB: ", szRsp) ||
        !ParseUIntAndVerifyAbove(szRsp, TRUE, 2, nValue, szRsp)) {
        hr = E_FAIL;
        goto Error;
    }

    // Cache accept value for when we have a structure allocated
    fAccept = (nValue == 0);

    // Parse ",<msg_ids>,<msg_langs><postfix>"
    if (!MatchStringBeginning(szRsp, ",", szRsp)                              ||
        !ParseString(szRsp, szBroadcastMsgIDs, MAXLENGTH_MSGIDS, szRsp))
    {
        hr = E_FAIL;
        goto Error;
    }

    // Parse broadcast message IDs
    // This also allocates the blob
    hr = ParseBroadcastMsgIDs(szBroadcastMsgIDs, &prmc);
    if (FAILED(hr))
    {
        goto Error;
    }

    prmc->fAccept = fAccept;
    prmc->dwParams |= (RIL_PARAM_CBMC_BROADCASTMSGIDS | RIL_PARAM_CBMC_ACCEPTIDS);

    if (MatchStringBeginning(szRsp, ",", szRsp))
    {
        if (!ParseString(szRsp, szLanguageRange, MAX_PATH, szRsp))
        {
            hr = E_FAIL;
            goto Error;
        }

        // Parse accepted languages
        if (!ParseBroadcastLangRange(szLanguageRange, prmc->dwBroadcastMsgLangs)) {
            hr = E_FAIL;
            goto Error;
        }

        prmc->dwParams |= RIL_PARAM_CBMC_BROADCASTMSGLANGS;
    }

    if (!ParseRspPostfix(szRsp, szRsp))
    {
        hr = E_FAIL;
        goto Error;
    }

    pBlob = (void*)prmc;
    cbBlob = prmc->cbSize;

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

}

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

    if (!QueueCmd(pHandle, "AT+CSCB?\r", CMDOPT_NONE, APIID_GETCBMSGCONFIG,
                  ParseGetCellBroadcastMsgConfigRsp, NULL, hr))
    {
        hr = E_FAIL;
        goto Error;
    }

    Error:
    return hr;
}

//
//
//
HRESULT RILDrv_SetCellBroadcastMsgConfig(DWORD dwParam, const RILCBMSGCONFIG* lpMsgConfigInfo)
{
    FUNCTION_TRACE(RILDrv_SetCellBroadcastMsgConfig);
    char szCmd[MAXLENGTH_MSGIDS + MAX_PATH * 3];
    LPSTR szWalk = szCmd;
    char szCBMsgLangs[MAX_PATH];
    char szBroadcastMsgIDs[MAX_PATH];
    HRESULT hr = S_OK;
    CRilInstanceHandle* pHandle = ExtractHandle(dwParam);
    if (!pHandle || !lpMsgConfigInfo)
    {
        hr = E_FAIL;
        goto Error;
    }

    if (!(lpMsgConfigInfo->dwParams & RIL_PARAM_CBMC_ACCEPTIDS))
    {
        hr = E_INVALIDARG;
        goto Error;
    }

    (void)_snprintfz(szCmd, MAX_PATH, "AT+CSCB=%d", (lpMsgConfigInfo->fAccept?0:1));
    szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
    DEBUGCHK(NULL != szWalk);

#if defined (WAVECOM_DRIVER)
    // HW-SPECIFIC: WaveCom hardware does not allow parameters with reject mode
    if (lpMsgConfigInfo->fAccept)
#endif
    {
        if ((lpMsgConfigInfo->dwParams & RIL_PARAM_CBMC_BROADCASTMSGIDS))
        {
            MakeBroadcastMsgIDs(lpMsgConfigInfo->rgrrBroadcastMsgIDs,
                                (lpMsgConfigInfo->cbSize - sizeof(RILCBMSGCONFIG)) / sizeof(RILRANGE),