rilclass.cpp

wince ril程序

    m_hrEquipmentInfoRq= 0;
    m_hrEquipmentStateRequest= 0;
    m_hrCurrentAddressIdRequest= 0;
    m_hrSignalQualityRequest= 0;
    m_hrSimRecordStatusRequest= 0;
    m_hrAudioDevicesRequest= 0;
    m_hrAudioMutingRequest= 0;
    m_hrCellTowerInfoRequest= 0;
    m_hrSubscriberNumbersRequest= 0;
    m_hrLockedStateRequest= 0;
	m_hrSetAudioMutingRequest= 0;
	m_hrGetCallWaitingRequest= 0;
	m_hrSetCallWaitingRequest= 0;

    m_hrCBSRequest= 0;
	m_hrCellIdRequest= 0;
}
RilClass::~RilClass()
{
    close();
}
bool RilClass::open(DWORD dwIndex)
{
#ifdef _HAVE_RIL
    HRESULT res= RIL_Initialize(dwIndex, &ResultProc, &NotifyProc, -1, (DWORD)this, &m_hRil);
    if (res)
    {
        error("RIL_Initialize: %08lx\n", res);
        return false;
    }
#endif
    return true;
}
bool RilClass::close()
{
    bool bRes= true;
#ifdef _HAVE_RIL
    if (m_hRil)
    {
        HRESULT res= RIL_Deinitialize(m_hRil);
        if (res)
        {
            error("RIL_Deinitialize: %08lx\n", res);
            bRes= false;
        }
        m_hRil= 0;
    }
#endif
    return bRes;
}
std::string GetSerialPortStatisticsString(RILSERIALPORTSTATS *p)
{
    std::string info= "PORTSTATS:";
    if (p->dwParams&RIL_PARAM_SPS_READBITSPERSECOND)    info += stringformat(" read:%d bps",  p->dwReadBitsPerSecond);
    if (p->dwParams&RIL_PARAM_SPS_WRITTENBITSPERSECOND) info += stringformat(" write:%d bps", p->dwWrittenBitsPerSecond);

    DWORD dwKnown= RIL_PARAM_SPS_READBITSPERSECOND|RIL_PARAM_SPS_WRITTENBITSPERSECOND;
    if (p->dwParams&~dwKnown)
        info += stringformat("  unknownparams-%08lx", p->dwParams&~dwKnown);
    return info;
}
void RilClass::GetDriverInfo()
{
    HRESULT hr;

    HANDLE hSerial;
    hr= RIL_GetSerialPortHandle(m_hRil, &hSerial);
    if (IS_ERROR(hr))
        error(hr, "RIL_GetSerialPortHandle");
    debug("RIL_GetSerialPortHandle: handle=%08lx\n", hSerial);

    RILSERIALPORTSTATS portstats;
    hr= RIL_GetSerialPortStatistics(m_hRil, &portstats);
    if (IS_ERROR(hr))
        error(hr, "RIL_GetSerialPortStatistics");
    debug("RIL_GetSerialPortStatistics: %hs\n", GetSerialPortStatisticsString(&portstats).c_str());

    DWORD dwVersion;
    hr= RIL_GetDriverVersion(m_hRil, &dwVersion);
    if (IS_ERROR(hr))
        error(hr, "RIL_GetDriverVersion");
    debug("RIL_GetDriverVersion: version=%08lx\n", dwVersion);

    DWORD dwRadioPresence;
    hr= RIL_GetRadioPresence(m_hRil, &dwRadioPresence);
    if (IS_ERROR(hr))
        error(hr, "RIL_GetRadioPresence");
    debug("RIL_GetRadioPresence: presence=%hs\n", GetRadioPresenceString(dwRadioPresence).c_str());


}
void RilClass::ResultProc(DWORD dwCode, HRESULT hrCmdID, const void *lpData, DWORD cbdata, DWORD dwParam)
{
    ((RilClass*)dwParam)->HandleResult(dwCode, hrCmdID, lpData, cbdata);
}
void RilClass::NotifyProc(DWORD dwCode, const void *lpData, DWORD cbdata, DWORD dwParam)
{
    ((RilClass*)dwParam)->HandleNotify(dwCode, lpData, cbdata);
}
void RilClass::HandleResult(DWORD dwCode, HRESULT hrCmdID, const void *lpData, DWORD cbdata)
{
	DWORD dwRilError= 0;
    bool bDumpRawPacket= false;

    SYSTEMTIME now;
    GetLocalTime(&now);

    debug("%04d-%02d-%02d %02d:%02d:%02d.%03d  RIL_Result: %hs id=%08lx %d bytes\n", 
            now.wYear, now.wMonth, now.wDay,
            now.wHour, now.wMinute, now.wSecond, now.wMilliseconds,
            RilResultString(dwCode).c_str(), hrCmdID, cbdata);

    if (dwCode==RIL_RESULT_ERROR) {
		if (cbdata!=sizeof(DWORD)) {
            debug("ril-error - missing error code : cbdata=%d\n", cbdata);
            bDumpRawPacket= true;
		}
        else {
			dwRilError= *(DWORD*)lpData;
            debug("ril-error: %hs\n", RilErrorString(dwRilError).c_str());
		}
    }

	//  find command the requested this result.

    else if (hrCmdID==m_hrEquipmentInfoRq) {
		m_hrEquipmentInfoRq= 0;
		if (dwCode==RIL_RESULT_OK) {
			if (cbdata!=sizeof(RILEQUIPMENTINFO)) {
                debug("ERROR: invalid sized RILEQUIPMENTINFO: %d\n", cbdata);
                bDumpRawPacket= true;
            }
            else {
                HandleEquipmentInfoAnswer((RILEQUIPMENTINFO*)lpData);
            }
		}
	}
    else if (hrCmdID==m_hrEquipmentStateRequest) {
		m_hrEquipmentStateRequest= 0;
		if (dwCode==RIL_RESULT_OK) {
			if (cbdata!=sizeof(RILEQUIPMENTSTATE)) {
                debug("ERROR: invalid sized RILEQUIPMENTSTATE: %d\n", cbdata);
                bDumpRawPacket= true;
            }
            else {
                HandleEquipmentStateAnswer((RILEQUIPMENTSTATE*)lpData);
            }
		}
	}
    else if (hrCmdID==m_hrCurrentAddressIdRequest) {
		m_hrCurrentAddressIdRequest= 0;
		if (dwCode==RIL_RESULT_OK) {
			if (cbdata!=sizeof(DWORD)) {
                debug("ERROR: CurrentAddressIdRequest - invalid sized DWORD: %d\n", cbdata);
                bDumpRawPacket= true;
            }
            else {
                HandleCurrentAddressIdAnswer(*(DWORD*)lpData);
            }
		}
	}
    else if (hrCmdID==m_hrSimRecordStatusRequest) {
		m_hrSimRecordStatusRequest= 0;

		if (dwCode==RIL_RESULT_OK) {
			if (cbdata!=sizeof(RILSIMRECORDSTATUS)) {
                debug("ERROR: invalid sized RILSIMRECORDSTATUS: %d\n", cbdata);
                bDumpRawPacket= true;
            }
            else {
                HandleSimRecordStatusAnswer((RILSIMRECORDSTATUS*)lpData, cbdata);
            }
		}
	}

    else if (hrCmdID==m_hrSignalQualityRequest) {
		m_hrSignalQualityRequest= 0;

		if (dwCode==RIL_RESULT_OK) {
			if (cbdata!=sizeof(RILSIGNALQUALITY)) {
                debug("ERROR: invalid sized RILSIGNALQUALITY: %d\n", cbdata);
                bDumpRawPacket= true;
            }
            else {
                HandleSignalQualityAnswer((RILSIGNALQUALITY *)lpData);
            }
		}
		else {
			HandleSignalQualityError(dwRilError);
		}
	}
	else if (hrCmdID==m_hrCallListRequest) {
		m_hrCallListRequest= 0;

		if (dwCode==RIL_RESULT_OK) {
            if ((cbdata%sizeof(RILCALLINFO))==0) {
                HandleCallListAnswer((RILCALLINFO*)lpData, cbdata/sizeof(RILCALLINFO), 0);
            }
            if ((cbdata%(sizeof(RILCALLINFO)+sizeof(DWORD)))==0) {
                HandleCallListAnswer((RILCALLINFO*)lpData, cbdata/(sizeof(RILCALLINFO)+sizeof(DWORD)), sizeof(DWORD));
            }
            else {
                debug("ERROR: cbdata not round nr of RILCALLINFO{+4}(%d): %d\n", sizeof(RILCALLINFO), cbdata);
                bDumpRawPacket= true;
            }
		}
	}
	else if (hrCmdID==m_hrAudioDevicesRequest) {
		m_hrAudioDevicesRequest= 0;

		if (dwCode==RIL_RESULT_OK) {
			if (cbdata!=sizeof(RILAUDIODEVICEINFO)) {
                debug("ERROR: invalid sized RILAUDIODEVICEINFO: %d\n", cbdata);
                bDumpRawPacket= true;
            }
            else {
                HandleAudioDevicesAnswer((RILAUDIODEVICEINFO*)lpData);
            }
		}
	}
    else if (hrCmdID==m_hrLockedStateRequest) {
		m_hrLockedStateRequest= 0;

		if (dwCode==RIL_RESULT_OK) {
			if (cbdata!=sizeof(BOOL)) {
                debug("ERROR: LockedStateRequest- invalid sized DWORD: %d\n", cbdata);
                bDumpRawPacket= true;
            }
            else {
                HandleLockedStateAnswer(*(DWORD*)lpData);
            }
		}
	}
    else if (hrCmdID==m_hrSubscriberNumbersRequest) {
		m_hrSubscriberNumbersRequest= 0;

		if (dwCode==RIL_RESULT_OK) {
            if (cbdata%sizeof(RILSUBSCRIBERINFO)) {
                debug("ERROR: cbdata not round nr of RILSUBSCRIBERINFO(%d): %d\n", sizeof(RILSUBSCRIBERINFO), cbdata);
                bDumpRawPacket= true;
            }
            else {
                HandleSubscriberNumbersAnswer((RILSUBSCRIBERINFO*)lpData, cbdata/sizeof(RILSUBSCRIBERINFO));
            }
		}
	}
    else if (hrCmdID==m_hrAudioMutingRequest) {
		m_hrAudioMutingRequest= 0;

		if (dwCode==RIL_RESULT_OK) {
			if (cbdata!=sizeof(BOOL)) {
                debug("ERROR: AudioMutingRequest- invalid sized BOOl : %d\n", cbdata);
                bDumpRawPacket= true;
            }
            else {
                HandleAudioMutingAnswer(*(BOOL*)lpData);
            }
		}
	}
    else if (hrCmdID==m_hrCellTowerInfoRequest) {
		m_hrCellTowerInfoRequest= 0;

		if (dwCode==RIL_RESULT_OK) {
			if (cbdata!=sizeof(RILCELLTOWERINFO)) {
                debug("ERROR: invalid sized RILCELLTOWERINFO: %d\n", cbdata);
                bDumpRawPacket= true;
            }
            else {
                HandleCellTowerInfoAnswer((RILCELLTOWERINFO*)lpData);
            }
		}
	}
    else if (hrCmdID==m_hrSetAudioMutingRequest) {
		m_hrSetAudioMutingRequest= 0;
        debug("ril-set muting reply\n");
	}
    else if (hrCmdID==m_hrGetCallWaitingRequest) {
		m_hrGetCallWaitingRequest= 0;
		if (dwCode==RIL_RESULT_OK) {
			if (cbdata!=sizeof(DWORD)) {
                debug("ERROR: invalid sized RIL_INFOCLASS DWORD: %d\n", cbdata);
                bDumpRawPacket= true;
            }
            else {
                debug("ril-get call waiting reply : %hs\n", RilInfoClassString(*(DWORD*)lpData).c_str());
            }
        }
        else {
            debug("ril-get call waiting error : %hs\n", dwCode);