rilclass.cpp

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

default: return stringformat("eqstate-%d", rp);
    }
}
std::string GetPbLocString(int rp)
{
    switch(rp)
    {
case RIL_PBLOC_UNKNOWN: return "RIL_PBLOC_UNKNOWN";
case RIL_PBLOC_SIMEMERGENCY: return "RIL_PBLOC_SIMEMERGENCY";
case RIL_PBLOC_SIMFIXDIALING: return "RIL_PBLOC_SIMFIXDIALING";
case RIL_PBLOC_SIMLASTDIALING: return "RIL_PBLOC_SIMLASTDIALING";
case RIL_PBLOC_OWNNUMBERS: return "RIL_PBLOC_OWNNUMBERS";
case RIL_PBLOC_SIMPHONEBOOK: return "RIL_PBLOC_SIMPHONEBOOK";
default: return stringformat("pbloc-%d", rp);
    }
}

std::string GetReadyStateString(int rp)
{
    std::string state;
    if (rp==RIL_READYSTATE_NONE)       state += " RIL_READYSTATE_NONE";
    if (rp&RIL_READYSTATE_INITIALIZED) state += " RIL_READYSTATE_INITIALIZED";
    if (rp&RIL_READYSTATE_SIM)         state += " RIL_READYSTATE_SIM";
    if (rp&RIL_READYSTATE_SMS)         state += " RIL_READYSTATE_SMS";
    if (rp&RIL_READYSTATE_UNLOCKED)    state += " RIL_READYSTATE_UNLOCKED";
    if (rp&~(RIL_READYSTATE_INITIALIZED|RIL_READYSTATE_SIM|RIL_READYSTATE_SMS|RIL_READYSTATE_UNLOCKED))
        state += stringformat("RIL_READYSTATE_%08lx", rp&~(RIL_READYSTATE_INITIALIZED|RIL_READYSTATE_SIM|RIL_READYSTATE_SMS|RIL_READYSTATE_UNLOCKED));
    return state;
}
std::string GetEquipmentStateString(RILEQUIPMENTSTATE* es)
{
    std::string info= "EQUIPMENTSTATE: ";

    if (es->dwParams&RIL_PARAM_EQUIPMENTSTATE_RADIOSUPPORT) info += stringformat(" %hs", GetRadioSupportString(es->dwRadioSupport).c_str());
    if (es->dwParams&RIL_PARAM_EQUIPMENTSTATE_EQSTATE     ) info += stringformat(" %hs", GetEqStateString(es->dwEqState).c_str());
    if (es->dwParams&RIL_PARAM_EQUIPMENTSTATE_READYSTATE  ) info += stringformat(" %hs", GetReadyStateString(es->dwReadyState).c_str());

    DWORD dwKnown= RIL_PARAM_EQUIPMENTSTATE_RADIOSUPPORT|RIL_PARAM_EQUIPMENTSTATE_EQSTATE|RIL_PARAM_EQUIPMENTSTATE_READYSTATE;
    if (es->dwParams&~dwKnown)
        info += stringformat("  unknownparams-%08lx", es->dwParams&~dwKnown);
    return info;
}
std::string GetEquipmentInfoString(RILEQUIPMENTINFO* ei)
{
    std::string info= "EQUIPMENTINFO: ";

    if (ei->dwParams&RIL_PARAM_EI_MANUFACTURER) info += stringformat(" manufacturer=%hs", ei->szManufacturer);
    if (ei->dwParams&RIL_PARAM_EI_MODEL       ) info += stringformat(" model=%hs", ei->szModel);
    if (ei->dwParams&RIL_PARAM_EI_REVISION    ) info += stringformat(" revision=%hs", ei->szRevision);
    if (ei->dwParams&RIL_PARAM_EI_SERIALNUMBER) info += stringformat(" serial=%hs", ei->szSerialNumber);

    DWORD dwKnown= RIL_PARAM_EI_MANUFACTURER|RIL_PARAM_EI_MODEL|RIL_PARAM_EI_REVISION|RIL_PARAM_EI_SERIALNUMBER;
    if (ei->dwParams&~dwKnown)
        info += stringformat("  unknownparams-%08lx", ei->dwParams&~dwKnown);
    return info;
}
std::string GetRilSignalQuality(RILSIGNALQUALITY *sq)
{
    std::string info= "RILSIGNALQUALITY: ";
    if (sq->dwParams&RIL_PARAM_SQ_SIGNALSTRENGTH    ) info += stringformat(" ss=%4d", sq->nSignalStrength);
    if (sq->dwParams&RIL_PARAM_SQ_MINSIGNALSTRENGTH ) info += stringformat(" mins=%4d", sq->nMinSignalStrength);
    if (sq->dwParams&RIL_PARAM_SQ_MAXSIGNALSTRENGTH ) info += stringformat(" maxs=%4d", sq->nMaxSignalStrength);
    if (sq->dwParams&RIL_PARAM_SQ_BITERRORRATE      ) info += stringformat(" ber=%4d", sq->dwBitErrorRate);
    if (sq->dwParams&RIL_PARAM_SQ_LOWSIGNALSTRENGTH ) info += stringformat(" los=%4d", sq->nLowSignalStrength);
    if (sq->dwParams&RIL_PARAM_SQ_HIGHSIGNALSTRENGTH) info += stringformat(" his=%4d", sq->nHighSignalStrength);

    DWORD dwKnown= RIL_PARAM_SQ_SIGNALSTRENGTH|RIL_PARAM_SQ_MINSIGNALSTRENGTH|RIL_PARAM_SQ_MAXSIGNALSTRENGTH|RIL_PARAM_SQ_BITERRORRATE|RIL_PARAM_SQ_LOWSIGNALSTRENGTH|RIL_PARAM_SQ_HIGHSIGNALSTRENGTH;
    if (sq->dwParams&~dwKnown)
        info += stringformat("  unknownparams-%08lx", sq->dwParams&~dwKnown);
    return info;
}
std::string GetCallWaitingInfo(RILCALLWAITINGINFO *cw)
{
    std::string info= "RILCALLWAITINGINFO : ";
    if (cw->dwParams&RIL_PARAM_CWI_CALLTYPE  ) info += stringformat(" ct=%4d", cw->dwCallType);
    if (cw->dwParams&RIL_PARAM_CWI_ADDRESSID ) info += stringformat(" adr=%4d", cw->dwAddressId);
    if (cw->dwParams&RIL_PARAM_CWI_CALLERINFO) info += stringformat(" ci=%s", GetRemotePartyInfoString(&(cw->rrpiCallerInfo)).c_str());

    DWORD dwKnown= RIL_PARAM_CWI_CALLTYPE|RIL_PARAM_CWI_ADDRESSID|RIL_PARAM_CWI_CALLERINFO;
    if (cw->dwParams&~dwKnown)
        info += stringformat("  unknownparams-%08lx", cw->dwParams&~dwKnown);
    return info;
}
bool RilClass::HandleRadioStateChangedEvent(RILEQUIPMENTSTATE* es, DWORD cbdata)
{
	if (es->cbSize!=cbdata) {
		debug("ril-HandleRadioStateChangedEvent: size mismatch ( rec:%d not:%d )\n", es->cbSize, cbdata);
    }

    debug("ril-RadioState: %hs\n", GetEquipmentStateString(es).c_str());
    return true;
}
bool HandleRadioPresenceChangedEvent(DWORD* d, DWORD cbdata)
{
	if (cbdata!=sizeof(DWORD)) {
		debug("ril-HandleRadioPresenceChangedEvent: size mismatch ( rec:4, not:%d )\n", cbdata);
    }

    debug("ril-RadioPresence: %hs\n", GetRadioPresenceString(*d).c_str());
    return true;
}
std::string MsgProtocolString(DWORD dw)
{
switch(dw)
{
case RIL_MSGPROTOCOL_UNKNOWN: return "UNKNOWN";
case RIL_MSGPROTOCOL_SMETOSME: return "SMETOSME";
case RIL_MSGPROTOCOL_IMPLICIT: return "IMPLICIT";
case RIL_MSGPROTOCOL_TELEX: return "TELEX";
case RIL_MSGPROTOCOL_TELEFAX_GROUP3: return "TELEFAX_GROUP3";
case RIL_MSGPROTOCOL_TELEFAX_GROUP4: return "TELEFAX_GROUP4";
case RIL_MSGPROTOCOL_VOICEPHONE: return "VOICEPHONE";
case RIL_MSGPROTOCOL_ERMES: return "ERMES";
case RIL_MSGPROTOCOL_PAGING: return "PAGING";
case RIL_MSGPROTOCOL_VIDEOTEX: return "VIDEOTEX";
case RIL_MSGPROTOCOL_TELETEX: return "TELETEX";
case RIL_MSGPROTOCOL_TELETEX_PSPDN: return "TELETEX_PSPDN";
case RIL_MSGPROTOCOL_TELETEX_CSPDN: return "TELETEX_CSPDN";
case RIL_MSGPROTOCOL_TELETEX_PSTN: return "TELETEX_PSTN";
case RIL_MSGPROTOCOL_TELETEX_ISDN: return "TELETEX_ISDN";
case RIL_MSGPROTOCOL_UCI: return "UCI";
case RIL_MSGPROTOCOL_MSGHANDLING: return "MSGHANDLING";
case RIL_MSGPROTOCOL_X400: return "X400";
case RIL_MSGPROTOCOL_EMAIL: return "EMAIL";
case RIL_MSGPROTOCOL_GSMSTATION: return "GSMSTATION";
case RIL_MSGPROTOCOL_SM_TYPE0: return "SM_TYPE0";
case RIL_MSGPROTOCOL_RSM_TYPE1: return "RSM_TYPE1";
case RIL_MSGPROTOCOL_RSM_TYPE2: return "RSM_TYPE2";
case RIL_MSGPROTOCOL_RSM_TYPE3: return "RSM_TYPE3";
case RIL_MSGPROTOCOL_RSM_TYPE4: return "RSM_TYPE4";
case RIL_MSGPROTOCOL_RSM_TYPE5: return "RSM_TYPE5";
case RIL_MSGPROTOCOL_RSM_TYPE6: return "RSM_TYPE6";
case RIL_MSGPROTOCOL_RSM_TYPE7: return "RSM_TYPE7";
case RIL_MSGPROTOCOL_RETURNCALL: return "RETURNCALL";
case RIL_MSGPROTOCOL_ME_DOWNLOAD: return "ME_DOWNLOAD";
case RIL_MSGPROTOCOL_DEPERSONALIZATION: return "DEPERSONALIZATION";
case RIL_MSGPROTOCOL_SIM_DOWNLOAD: return "SIM_DOWNLOAD";
default: return stringformat("msgprotocol-%d", dw);
}
}
std::string MsgDeliveryStatusString(DWORD dw)
{
switch(dw)
{
case RIL_MSGDLVSTATUS_RECEIVEDBYSME: return "RECEIVEDBYSME";
case RIL_MSGDLVSTATUS_FORWARDEDTOSME: return "FORWARDEDTOSME";
case RIL_MSGDLVSTATUS_REPLACEDBYSC: return "REPLACEDBYSC";
case RIL_MSGDLVSTATUS_CONGESTION_TRYING: return "CONGESTION_TRYING";
case RIL_MSGDLVSTATUS_SMEBUSY_TRYING: return "SMEBUSY_TRYING";
case RIL_MSGDLVSTATUS_SMENOTRESPONDING_TRYING: return "SMENOTRESPONDING_TRYING";
case RIL_MSGDLVSTATUS_SVCREJECTED_TRYING: return "SVCREJECTED_TRYING";
case RIL_MSGDLVSTATUS_QUALITYUNAVAIL_TRYING: return "QUALITYUNAVAIL_TRYING";
case RIL_MSGDLVSTATUS_SMEERROR_TRYING: return "SMEERROR_TRYING";
case RIL_MSGDLVSTATUS_CONGESTION: return "CONGESTION";
case RIL_MSGDLVSTATUS_SMEBUSY: return "SMEBUSY";
case RIL_MSGDLVSTATUS_SMENOTRESPONDING: return "SMENOTRESPONDING";
case RIL_MSGDLVSTATUS_SVCREJECTED: return "SVCREJECTED";
case RIL_MSGDLVSTATUS_QUALITYUNAVAIL_TEMP: return "QUALITYUNAVAIL_TEMP";
case RIL_MSGDLVSTATUS_SMEERROR: return "SMEERROR";
case RIL_MSGDLVSTATUS_REMOTEPROCERROR: return "REMOTEPROCERROR";
case RIL_MSGDLVSTATUS_INCOMPATIBLEDEST: return "INCOMPATIBLEDEST";
case RIL_MSGDLVSTATUS_CONNECTIONREJECTED: return "CONNECTIONREJECTED";
case RIL_MSGDLVSTATUS_NOTOBTAINABLE: return "NOTOBTAINABLE";
case RIL_MSGDLVSTATUS_NOINTERNETWORKING: return "NOINTERNETWORKING";
case RIL_MSGDLVSTATUS_VPEXPIRED: return "VPEXPIRED";
case RIL_MSGDLVSTATUS_DELETEDBYORIGSME: return "DELETEDBYORIGSME";
case RIL_MSGDLVSTATUS_DELETEDBYSC: return "DELETEDBYSC";
case RIL_MSGDLVSTATUS_NOLONGEREXISTS: return "NOLONGEREXISTS";
case RIL_MSGDLVSTATUS_QUALITYUNAVAIL: return "QUALITYUNAVAIL";
case RIL_MSGDLVSTATUS_RESERVED_COMPLETED: return "RESERVED_COMPLETED";
case RIL_MSGDLVSTATUS_RESERVED_TRYING: return "RESERVED_TRYING";
case RIL_MSGDLVSTATUS_RESERVED_ERROR: return "RESERVED_ERROR";
case RIL_MSGDLVSTATUS_RESERVED_TMPERROR: return "RESERVED_TMPERROR";
case RIL_MSGDLVSTATUS_SCSPECIFIC_COMPLETED: return "SCSPECIFIC_COMPLETED";
case RIL_MSGDLVSTATUS_SCSPECIFIC_TRYING: return "SCSPECIFIC_TRYING";
case RIL_MSGDLVSTATUS_SCSPECIFIC_ERROR: return "SCSPECIFIC_ERROR";
case RIL_MSGDLVSTATUS_SCSPECIFIC_TMPERROR: return "SCSPECIFIC_TMPERROR";
default: return stringformat("msgdeliverystatus-%d", dw);
}
}
std::string MsgVPFormatString(DWORD dw)
{
switch(dw)
{
case RIL_MSGVP_NONE: return "NONE";    
case RIL_MSGVP_RELATIVE: return "RELATIVE";
case RIL_MSGVP_ENHANCED: return "ENHANCED";
case RIL_MSGVP_ABSOLUTE: return "ABSOLUTE";
default: return stringformat("msgvpformat-%d", dw);
}
}

std::string MsgCommandTypeString(DWORD dw)
{
switch(dw)
{
case RIL_MSGCMDTYPE_STATUSREQ: return "STATUSREQ";      
case RIL_MSGCMDTYPE_CANCELSTATUSREQ: return "CANCELSTATUSREQ";
case RIL_MSGCMDTYPE_DELETEMESSAGE: return "DELETEMESSAGE";  
case RIL_MSGCMDTYPE_ENABLESTATUSREQ: return "ENABLESTATUSREQ";
default: return stringformat("cmdtype-%d", dw);
}
}

std::string DCSTypeString(DWORD dw)
{
switch(dw)
{
case RIL_DCSTYPE_GENERAL: return "GENERAL";
case RIL_DCSTYPE_MSGWAIT: return "MSGWAIT";
case RIL_DCSTYPE_MSGCLASS: return "MSGCLASS";
case RIL_DCSTYPE_LANGUAGE: return "LANGUAGE";
default: return stringformat("dcstype-%d", dw);
}
}

std::string DCSFlagsString(DWORD dw)
{
    StringList list;
if (dw&RIL_DCSFLAG_COMPRESSED) list.push_back("COMPRESSED");
if (dw&RIL_DCSFLAG_INDICATIONACTIVE) list.push_back("INDICATIONACTIVE");
if (dw&RIL_DCSFLAG_DISCARD) list.push_back("DISCARD");

if (dw==0) list.push_back("NONE");
DWORD dwKnown= RIL_DCSFLAG_COMPRESSED|RIL_DCSFLAG_INDICATIONACTIVE|RIL_DCSFLAG_DISCARD;
if (dw&~dwKnown) list.push_back(stringformat("RIL_DCSFLAG_%08lx", dw&~dwKnown));

return JoinStringList(list, ",");
}

std::string DCSAlphabetString(DWORD dw)
{
switch(dw)
{
case RIL_DCSALPHABET_DEFAULT: return "DEFAULT";
case RIL_DCSALPHABET_8BIT: return "8BIT";
case RIL_DCSALPHABET_UCS2: return "UCS2";
default: return stringformat("dcsalphabet-%d", dw);
}
}

std::string DCSIndicationString(DWORD dw)
{
switch(dw)
{
case RIL_DCSINDICATION_VOICEMAIL: return "VOICEMAIL";
case RIL_DCSINDICATION_FAX: return "FAX";
case RIL_DCSINDICATION_EMAIL: return "EMAIL";
case RIL_DCSINDICATION_OTHER: return "OTHER";
default: return stringformat("dcsindication-%d", dw);
}
}

std::string DCSLangString(DWORD dw)
{
switch(dw)
{
case RIL_DCSLANG_UNKNOWN: return "UNKNOWN";
case RIL_DCSLANG_GERMAN: return "GERMAN";
case RIL_DCSLANG_ENGLISH: return "ENGLISH";
case RIL_DCSLANG_ITALIAN: return "ITALIAN";
case RIL_DCSLANG_FRENCH: return "FRENCH";
case RIL_DCSLANG_SPANISH: return "SPANISH";
case RIL_DCSLANG_DUTCH: return "DUTCH";
case RIL_DCSLANG_SWEDISH: return "SWEDISH";
case RIL_DCSLANG_DANISH: return "DANISH";
case RIL_DCSLANG_PORTUGUESE: return "PORTUGUESE";
case RIL_DCSLANG_FINNISH: return "FINNISH";
case RIL_DCSLANG_NORWEGIAN: return "NORWEGIAN";
case RIL_DCSLANG_GREEK: return "GREEK";
case RIL_DCSLANG_TURKISH: return "TURKISH";
case RIL_DCSLANG_HUNGARIAN: return "HUNGARIAN";
case RIL_DCSLANG_POLISH: return "POLISH";
case RIL_DCSLANG_CZECH: return "CZECH";
case RIL_DCSLANG_ALL: return "ALL";
default: return stringformat("dcslang-%d", dw);
}
}

std::string GetDataEncodingSchemeString(RILMSGDCS *p)
{
    std::string info= "ENCODING";
    if (p->dwParams&RIL_PARAM_MDCS_TYPE       ) info += stringformat(" type=%s", DCSTypeString(p->dwType).c_str());
    if (p->dwParams&RIL_PARAM_MDCS_FLAGS      ) info += stringformat(" flags=%s", DCSFlagsString(p->dwFlags).c_str());
    if (p->dwParams&RIL_PARAM_MDCS_MSGCLASS   ) info += stringformat(" class=%d", p->dwMsgClass-1);
    if (p->dwParams&RIL_PARAM_MDCS_ALPHABET   ) info += stringformat(" alphabet=%s", DCSAlphabetString(p->dwAlphabet).c_str());
    if (p->dwParams&RIL_PARAM_MDCS_INDICATIO