rilclass.cpp

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

        }
	}
    else if (hrCmdID==m_hrCBSRequest) {
		m_hrCBSRequest= 0;

        debug("ril-req CBS reply\n");
	}
    else if (hrCmdID==m_hrCellIdRequest) {
		m_hrCellIdRequest= 0;

        debug("ril-req CellId reply\n");
	}
    else if (hrCmdID==m_hrRestrictedSimCmdRequest) {
		m_hrRestrictedSimCmdRequest= 0;

		if (dwCode==RIL_RESULT_OK) {
			HandleRestrictedSimCmdAnswer((RILSIMRESPONSE*)lpData, cbdata);
		}
	}
    else {
        debug("ril::HandleResult unknown\n");
        bDumpRawPacket= true;
    }
    if (bDumpRawPacket)
        debug("rawres: %hs\n", hexdump((BYTE*)lpData, cbdata).c_str());
}
void RilClass::HandleSignalQualityAnswer(RILSIGNALQUALITY *sq)
{
    if (sq->cbSize!=sizeof(RILSIGNALQUALITY))
		debug("ril-HandleSignalQualityAnswer: size mismatch: %d, expected %d\n", sq->cbSize, sizeof(RILSIGNALQUALITY));
	debug("ril-HandleSignalQualityAnswer %hs\n", GetRilSignalQuality(sq).c_str());
}
void RilClass::HandleSignalQualityError(DWORD dwRilError)
{
	debug("ril-HandleSignalQualityError %08lx\n", dwRilError);
}
std::string GetSimRecordTypeString(DWORD dwType)
{
    switch(dwType)
    {
case RIL_SIMRECORDTYPE_UNKNOWN: return "RIL_SIMRECORDTYPE_UNKNOWN";
case RIL_SIMRECORDTYPE_TRANSPARENT: return "RIL_SIMRECORDTYPE_TRANSPARENT";
case RIL_SIMRECORDTYPE_CYCLIC: return "RIL_SIMRECORDTYPE_CYCLIC";
case RIL_SIMRECORDTYPE_LINEAR: return "RIL_SIMRECORDTYPE_LINEAR";
case RIL_SIMRECORDTYPE_MASTER: return "RIL_SIMRECORDTYPE_MASTER";
case RIL_SIMRECORDTYPE_DEDICATED: return "RIL_SIMRECORDTYPE_DEDICATED";

default: return stringformat("simrecordtype-%d", dwType);
    }
}
std::string GetSimRecordStatusString(RILSIMRECORDSTATUS *ei, DWORD dwSize)
{
    std::string info= "RILSIMRECORDSTATUS : ";

    if (ei->dwParams&RIL_PARAM_SRS_RECORDTYPE) info += stringformat(" rectype=%hs", GetSimRecordTypeString(ei->dwRecordType).c_str());
    if (ei->dwParams&RIL_PARAM_SRS_ITEMCOUNT ) info += stringformat(" count=%d", ei->dwItemCount);
    if (ei->dwParams&RIL_PARAM_SRS_SIZE      ) info += stringformat(" itemsize=%d", ei->dwSize);

    info += hexdump((BYTE*)(ei+1), dwSize-sizeof(RILSIMRECORDSTATUS));

    DWORD dwKnown= RIL_PARAM_SRS_RECORDTYPE| RIL_PARAM_SRS_ITEMCOUNT | RIL_PARAM_SRS_SIZE;
    if (ei->dwParams&~dwKnown)
        info += stringformat("  unknownparams-%08lx", ei->dwParams&~dwKnown);

    return info;
}
void RilClass::HandleSimRecordStatusAnswer(RILSIMRECORDSTATUS *sq, DWORD dwSize)
{
	debug("ril-HandleSimRecordStatusAnswer(%04x): %hs\n", m_dwCurSimRecFile, GetSimRecordStatusString(sq, dwSize).c_str());
    if (sq->dwRecordType==RIL_SIMRECORDTYPE_LINEAR)
        SendRestrictedSimCmd(RIL_SIMCMD_READRECORD, m_dwCurSimRecFile, NULL, 0, 3, 1, 4, sq->dwSize);
    else if (sq->dwRecordType==RIL_SIMRECORDTYPE_CYCLIC)
        SendRestrictedSimCmd(RIL_SIMCMD_READRECORD, m_dwCurSimRecFile, NULL, 0, 3, 0, 4, sq->dwSize);
    else if (sq->dwRecordType==RIL_SIMRECORDTYPE_TRANSPARENT)
        SendRestrictedSimCmd(RIL_SIMCMD_READBINARY, m_dwCurSimRecFile, NULL, 0, 3, 0, 0, sq->dwSize);
    else
        debug("unhandled simrecord - %04x\n", m_dwCurSimRecFile);
}

void RilClass::HandleEquipmentInfoAnswer(RILEQUIPMENTINFO* info)
{
    if (info->cbSize!=sizeof(RILEQUIPMENTINFO))
		debug("ril-HandleEquipmentInfoAnswer: size mismatch: %d, expected %d\n", info->cbSize, sizeof(RILEQUIPMENTINFO));
    debug("ril-HandleEquipmentInfoAnswer: %hs\n", GetEquipmentInfoString(info).c_str());
}

void RilClass::HandleEquipmentStateAnswer(RILEQUIPMENTSTATE* state)
{
    if (state->cbSize!=sizeof(RILEQUIPMENTSTATE))
		debug("ril-HandleEquipmentStateAnswer: size mismatch: %d, expected %d\n", state->cbSize, sizeof(RILEQUIPMENTSTATE));
    debug("ril-HandleEquipmentStateAnswer: %hs\n", GetEquipmentStateString(state).c_str());
}
void RilClass::HandleCurrentAddressIdAnswer(DWORD dwId)
{
    debug("ril-HandleCurrentAddressIdAnswer: %08lx\n", dwId);
}

void RilClass::HandleCallListAnswer(RILCALLINFO* cilist, int ncalls, DWORD dwExtra)
{
    debug("RilClass::HandleCallListAnswer[%d calls]\n", ncalls);
	for (int i=0 ; i<ncalls ; i++)
	{
		debug("    call %d: %hs  %08lx\n", i, GetCallInfoString(cilist).c_str(),
                dwExtra ? *(DWORD*)(((BYTE*)cilist)+sizeof(RILCALLINFO)) : 0 );

        cilist = (RILCALLINFO*)(((BYTE*)cilist)+sizeof(RILCALLINFO)+dwExtra);
	}
    if (ncalls==0)
        debug("\n");
}

void RilClass::HandleAudioMutingAnswer(BOOL bMuted)
{
    debug("ril audio muting: %d\n", bMuted);
}
std::string GetCellTowerInfoString(RILCELLTOWERINFO *p)
{
    std::string info= "CELLTOWERINFO: ";
    if (p->dwParams&RIL_PARAM_CTI_MOBILECOUNTRYCODE      ) info += stringformat(" MobileCountryCode= %hs",       p->dwMobileCountryCode         );
    if (p->dwParams&RIL_PARAM_CTI_MOBILENETWORKCODE      ) info += stringformat(" MobileNetworkCode= %hs",       p->dwMobileNetworkCode         );
    if (p->dwParams&RIL_PARAM_CTI_LOCATIONAREACODE       ) info += stringformat(" LocationAreaCode= %hs",        p->dwLocationAreaCode          );
    if (p->dwParams&RIL_PARAM_CTI_CELLID                 ) info += stringformat(" CellID= %hs",                  p->dwCellID                    );
    if (p->dwParams&RIL_PARAM_CTI_BASESTATIONID          ) info += stringformat(" BaseStationID= %hs",           p->dwBaseStationID             );
    if (p->dwParams&RIL_PARAM_CTI_BROADCASTCONTROLCHANNEL) info += stringformat(" BroadcastControlChannel= %hs", p->dwBroadcastControlChannel   );
    if (p->dwParams&RIL_PARAM_CTI_RXLEVEL                ) info += stringformat(" RxLevel= %hs",                 p->dwRxLevel                   );
    if (p->dwParams&RIL_PARAM_CTI_RXLEVELFULL            ) info += stringformat(" RxLevelFull= %hs",             p->dwRxLevelFull               );
    if (p->dwParams&RIL_PARAM_CTI_RXLEVELSUB             ) info += stringformat(" RxLevelSub= %hs",              p->dwRxLevelSub                );
    if (p->dwParams&RIL_PARAM_CTI_RXQUALITY              ) info += stringformat(" RxQuality= %hs",               p->dwRxQuality                 );
    if (p->dwParams&RIL_PARAM_CTI_RXQUALITYFULL          ) info += stringformat(" RxQualityFull= %hs",           p->dwRxQualityFull             );
    if (p->dwParams&RIL_PARAM_CTI_RXQUALITYSUB           ) info += stringformat(" RxQualitySub= %hs",            p->dwRxQualitySub              );
    if (p->dwParams&RIL_PARAM_CTI_IDLETIMESLOT           ) info += stringformat(" IdleTimeSlot= %hs",            p->dwIdleTimeSlot              );
    if (p->dwParams&RIL_PARAM_CTI_TIMINGADVANCE          ) info += stringformat(" TimingAdvance= %hs",           p->dwTimingAdvance             );
    if (p->dwParams&RIL_PARAM_CTI_GPRSCELLID             ) info += stringformat(" GPRSCellID= %hs",              p->dwGPRSCellID                );
    if (p->dwParams&RIL_PARAM_CTI_GPRSBASESTATIONID      ) info += stringformat(" GPRSBaseStationID= %hs",       p->dwGPRSBaseStationID         );
    if (p->dwParams&RIL_PARAM_CTI_NUMBCCH                ) info += stringformat(" NumBCCH= %hs",                 p->dwNumBCCH                   );
    if (p->dwParams&RIL_PARAM_CTI_NMR                    ) info += stringformat(" BCCH= %hs",                    hexdump(p->rgbBCCH, MAXLENGTH_BCCH).c_str());
    if (p->dwParams&RIL_PARAM_CTI_BCCH                   ) info += stringformat(" NMR= %hs",                     hexdump(p->rgbNMR, MAXLENGTH_NMR).c_str());

    DWORD dwKnown= RIL_PARAM_CTI_MOBILECOUNTRYCODE|RIL_PARAM_CTI_MOBILENETWORKCODE|RIL_PARAM_CTI_LOCATIONAREACODE|RIL_PARAM_CTI_CELLID|RIL_PARAM_CTI_BASESTATIONID|RIL_PARAM_CTI_BROADCASTCONTROLCHANNEL|RIL_PARAM_CTI_RXLEVEL|RIL_PARAM_CTI_RXLEVELFULL|RIL_PARAM_CTI_RXLEVELSUB|RIL_PARAM_CTI_RXQUALITY|RIL_PARAM_CTI_RXQUALITYFULL|RIL_PARAM_CTI_RXQUALITYSUB|RIL_PARAM_CTI_IDLETIMESLOT|RIL_PARAM_CTI_TIMINGADVANCE|RIL_PARAM_CTI_GPRSCELLID|RIL_PARAM_CTI_GPRSBASESTATIONID|RIL_PARAM_CTI_NUMBCCH|RIL_PARAM_CTI_NMR|RIL_PARAM_CTI_BCCH;
    if (p->dwParams&~dwKnown)
        info += stringformat("  unknownparams-%08lx", p->dwParams&~dwKnown);
    return info;
}

void RilClass::HandleCellTowerInfoAnswer(RILCELLTOWERINFO *p)
{
    if (p->cbSize!=sizeof(RILCELLTOWERINFO))
		debug("ril-HandleCellTowerInfoAnswer: size mismatch: %d, expected %d\n", p->cbSize, sizeof(RILCELLTOWERINFO));
    debug("ril-HandleCellTowerInfoAnswer: %hs\n", GetCellTowerInfoString(p).c_str());
}


std::string GetSubscriberInfoString(RILSUBSCRIBERINFO *p)
{
    std::string info= "SUBINFO: ";
    if (p->dwParams&RIL_PARAM_SI_ADDRESS     ) info += stringformat(" address    = %hs", GetRilAddressString(&p->raAddress).c_str());
    if (p->dwParams&RIL_PARAM_SI_DESCRIPTION ) info += stringformat(" description= %ls", p->wszDescription);
    if (p->dwParams&RIL_PARAM_SI_SPEED       ) info += stringformat(" speed      = %08x", p->dwSpeed);
    if (p->dwParams&RIL_PARAM_SI_SERVICE     ) info += stringformat(" service    = %08x", p->dwService);
    if (p->dwParams&RIL_PARAM_SI_ITC         ) info += stringformat(" itc        = %08x", p->dwITC);
    if (p->dwParams&RIL_PARAM_SI_ADDRESSID   ) info += stringformat(" addressid  = %08x", p->dwAddressId);

    DWORD dwKnown= RIL_PARAM_SI_ADDRESS|RIL_PARAM_SI_DESCRIPTION|RIL_PARAM_SI_SPEED|RIL_PARAM_SI_SERVICE|RIL_PARAM_SI_ITC|RIL_PARAM_SI_ADDRESSID;
    if (p->dwParams&~dwKnown)
        info += stringformat("  unknownparams-%08lx", p->dwParams&~dwKnown);
    return info;
}
void RilClass::HandleSubscriberNumbersAnswer(RILSUBSCRIBERINFO *pList, int n)
{
    for (int i=0 ; i<n ; i++)
        debug("ril subscriberinfo - %d : %s\n", i, GetSubscriberInfoString(pList+i).c_str());
}


//--------------------------------------------------------------------
std::string GetLockedStateString(DWORD dwLockedState)
{
    switch(dwLockedState)
    {
case RIL_LOCKEDSTATE_UNKNOWN: return "RIL_LOCKEDSTATE_UNKNOWN";
case RIL_LOCKEDSTATE_READY: return "RIL_LOCKEDSTATE_READY";
case RIL_LOCKEDSTATE_SIM_PIN: return "RIL_LOCKEDSTATE_SIM_PIN";
case RIL_LOCKEDSTATE_SIM_PUK: return "RIL_LOCKEDSTATE_SIM_PUK";
case RIL_LOCKEDSTATE_PH_SIM_PIN: return "RIL_LOCKEDSTATE_PH_SIM_PIN";
case RIL_LOCKEDSTATE_PH_FSIM_PIN: return "RIL_LOCKEDSTATE_PH_FSIM_PIN";
case RIL_LOCKEDSTATE_PH_FSIM_PUK: return "RIL_LOCKEDSTATE_PH_FSIM_PUK";
case RIL_LOCKEDSTATE_SIM_PIN2: return "RIL_LOCKEDSTATE_SIM_PIN2";
case RIL_LOCKEDSTATE_SIM_PUK2: return "RIL_LOCKEDSTATE_SIM_PUK2";
case RIL_LOCKEDSTATE_PH_NET_PIN: return "RIL_LOCKEDSTATE_PH_NET_PIN";
case RIL_LOCKEDSTATE_PH_NET_PUK: return "RIL_LOCKEDSTATE_PH_NET_PUK";
case RIL_LOCKEDSTATE_PH_NETSUB_PIN: return "RIL_LOCKEDSTATE_PH_NETSUB_PIN";
case RIL_LOCKEDSTATE_PH_NETSUB_PUK: return "RIL_LOCKEDSTATE_PH_NETSUB_PUK";
case RIL_LOCKEDSTATE_PH_SP_PIN: return "RIL_LOCKEDSTATE_PH_SP_PIN";
case RIL_LOCKEDSTATE_PH_SP_PUK: return "RIL_LOCKEDSTATE_PH_SP_PUK";
case RIL_LOCKEDSTATE_PH_CORP_PIN: return "RIL_LOCKEDSTATE_PH_CORP_PIN";
case RIL_LOCKEDSTATE_PH_CORP_PUK: return "RIL_LOCKEDSTATE_PH_CORP_PUK";
default: return stringformat("lockedstate-%d", dwLockedState);
    }
}

void RilClass::HandleLockedStateAnswer(DWORD dwLockedState)
{
    debug("ril lockedstate : %hs\n", GetLockedStateString(dwLockedState).c_str());
}

void RilClass::HandleAudioDevicesAnswer(RILAUDIODEVICEINFO* devinfo)
{
    if (devinfo->cbSize!=sizeof(RILAUDIODEVICEINFO))
		debug("ril-HandleAudioDevicesAnswer: size mismatch: %d , expected %d\n", devinfo->cbSize, sizeof(RILAUDIODEVICEINFO));
    debug("ril audio devices: tx=%d rx=%d\n", devinfo->dwTxDevice, devinfo->dwRxDevice);
}

//--------------------------------------------------------------------
std::string GetCallTypeString(int calltype)
{
    switch(calltype)
    {
case RIL_CALLTYPE_UNKNOWN: return "RIL_CALLTYPE_UNKNOWN";
case RIL_CALLTYPE_VOICE: return "RIL_CALLTYPE_VOICE";
case RIL_CALLTYPE_DATA: return "RIL_CALLTYPE_DATA";
case RIL_CALLTYPE_FAX: return "RIL_CALLTYPE_FAX";
default: return stringformat("calltype-%d", calltype);
    }
}

std::string GetDisconnectInitString(int di)
{
    switch(di)
    {
case RIL_DISCINIT_NULL        : return "NULL";
case RIL_DISCINIT_LOCAL: return "RIL_DISCINIT_LOCAL";
case RIL_DISCINIT_REMOTE: return "RIL_DISCINIT_REMOTE";
case RIL_DISCINIT_NETWORKERROR: return "NETWORKERROR";
case RIL_DISCINIT_BUSY        : return "BUSY";
default: return stringformat("discinit-%d", di);
    }
}
std::string GetServiceInfoString(RILSERVICEINFO *si)
{
    std::string info= "SVCINFO: ";
    if (si->dwParams&RIL_PARAM_SVCI_SYNCHRONOUS) info += stringformat("  synchronous=%d", si->fSynchronous);
    if (si->dwParams&RIL_PARAM_SVCI_TRANSPARENT) info += stringformat("  transparent=%d", si->fTransparent);

    DWORD dwKnown= RIL_PARAM_SVCI_SYNCHRONOUS|RIL_PARAM_SVCI_TRANSPARENT;
    if (si->dwParams&~dwKnown)
        info += stringformat("  unknownparams-%08lx", si->dwParams&~dwKnown);
    return info;
}

std::string GetRingInfoString(RILRINGINFO* ri)
{
    std::string info= "RINGINFO: ";
    if (ri->dwParams&RIL_PARAM_RI_CALLTYPE   ) info += stringformat(" calltype= %hs", GetCallTypeString(ri->dwCallType).c_str());
    if (ri->dwParams&RIL_PARAM_RI_ADDRESSID  ) info += stringformat(" addressid= %d", ri->dwAddressId);
    if (ri->dwParams&RIL_PARAM_RI_SERVICEINFO) info += stringformat(" serviceinfo= %hs", GetServiceInfoString(&ri->rsiServiceInfo).c_str());

    DWORD dwKnown= RIL_PARAM_RI_CALLTYPE|RIL_PARAM_RI_ADDRESSID|RIL_PARAM_RI_SERVICEINFO;
    if (ri->dwParams&~dwKnown)
        info += stringformat("  unknownparams-%08lx", ri->dwParams&~dwKnown);
    return info;
}
std::string GetConnectInfoString(RILCONNECTINFO* ci)
{
    std::string info= "CONNECTINFO: ";
    if (ci->dwParams&RIL_PARAM_CNI_CALLTYPE) info += stringformat("  calltype=%hs", GetCallTypeString(ci->dwCallType).c_str());
    if (ci->dwParams&RIL_PARAM_CNI_BAUDRATE) info += stringformat("  baudrate=%d", ci->dwBaudRate);

    DWORD dwKnown= RIL_PARAM_CNI_CALLTYPE|RIL_PARAM_CNI_BAUDRATE;
    if (ci->dwParams&~dwKnown)
        info += stringformat("  unknownparams-%08lx", ci->dwParams&~dwKnown);
    return info;
}
std::string CallDirectionString(DWORD dw)
{
    switch(dw)
    {
case RIL_CALLDIR_INCOMING: return "INCOMING";
case RIL_CALLDIR_OUTGOING: return "OUTGOING";
default: return stringformat("calldir-%d", dw);
    }
}
std::string CallStatusString(DWORD dw)
{
switch(dw)
{
case RIL_CALLSTAT_ACTIVE: return "ACTIVE";  
case RIL_CALLSTAT_ONHOLD: return "ONHOLD";