rilclass.cpp

获取 mobile 手机的信号强度 开源的rilcla

    if (dwClass&RIL_INFOCLASS_DATACIRCUITASYNC) list.push_back("DataCircuitASync");
    if (dwClass&RIL_INFOCLASS_PACKETACCESS) list.push_back("PacketAccess");
    if (dwClass&RIL_INFOCLASS_PADACCESS) list.push_back("PadAccess");

    DWORD dwAll= RIL_INFOCLASS_VOICE|RIL_INFOCLASS_DATA|RIL_INFOCLASS_FAX|RIL_INFOCLASS_SMS|RIL_INFOCLASS_DATACIRCUITSYNC|RIL_INFOCLASS_DATACIRCUITASYNC|RIL_INFOCLASS_PACKETACCESS|RIL_INFOCLASS_PADACCESS;
    if (dwClass & ~ dwAll) list.push_back(stringformat("RIL_INFOCLASS_%x", dwClass & ~ dwAll));

    return JoinStringList(list, ",");
}

RilClass::RilClass()
{
    m_hRil= 0;
    m_hrCallListRequest= 0;
    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;
    m_hrRestrictedSimCmdRequest= 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;

    debugt("RIL_Result: %hs id=%08lx %d bytes\n", 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.

    if (hrCmdID==m_hrEquipmentInfoRq) {
		m_hrEquipmentInfoRq= 0;
		if (dwCode==RIL_RESULT_OK) {
			if (cbdata!=sizeof(RILEQUIPMENTINFO)) {
                debug("ERROR: invalid sized RILEQUIPMENTINFO: %d, expected %d\n", cbdata, sizeof(RILEQUIPMENTINFO));
                bDumpRawPacket= true;
            }
            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, expected %d\n", cbdata, sizeof(RILEQUIPMENTSTATE));
                bDumpRawPacket= true;
            }
            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, expected %d\n", cbdata, sizeof(DWORD));
                bDumpRawPacket= true;
            }
            HandleCurrentAddressIdAnswer(*(DWORD*)lpData);
		}
	}
    else if (hrCmdID==m_hrSimRecordStatusRequest) {

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

		if (dwCode==RIL_RESULT_OK) {
			if (cbdata!=sizeof(RILSIGNALQUALITY)) {
                debug("ERROR: invalid sized RILSIGNALQUALITY: %d, expected %d\n", cbdata, sizeof(RILSIGNALQUALITY));
                bDumpRawPacket= true;
            }
            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);
            }
            else 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, expected %d\n", cbdata, sizeof(RILAUDIODEVICEINFO));
                bDumpRawPacket= true;
            }
            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, expected %d\n", cbdata, sizeof(BOOL));
                bDumpRawPacket= true;
            }
            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, expected %d\n", cbdata, sizeof(BOOL));
                bDumpRawPacket= true;
            }
            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, expected %d\n", cbdata, sizeof(RILCELLTOWERINFO));
                bDumpRawPacket= true;
            }
            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, expected %d\n", cbdata, sizeof(DWORD));
                bDumpRawPacket= true;
            }
            debug("ril-get call waiting reply : %hs\n", RilInfoClassString(*(DWORD*)lpData).c_str());
        }
        else {
            debug("ril-get call waiting error : %hs\n", dwCode);
        }
	}
    else if (hrCmdID==m_hrSetCallWaitingRequest) {
		m_hrSetCallWaitingRequest= 0;
		if (dwCode==RIL_RESULT_OK) {
            debug("ril-set call waiting ok\n");
        }
        else {
            debug("ril-set call waiting error - %08lx\n", dwCode);