rilclass.cpp

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

case RIL_CALLSTAT_DIALING: return "DIALING"; 
case RIL_CALLSTAT_ALERTING: return "ALERTING";
case RIL_CALLSTAT_INCOMING: return "INCOMING";
case RIL_CALLSTAT_WAITING: return "WAITING"; 
default: return stringformat("callstat-%d", dw);
}
}
std::string CpiStatusString(DWORD dw)
{
    switch(dw)
    {
case RIL_CPISTAT_UNKNOWN: return "UNKNOWN";     
case RIL_CPISTAT_NEW_OUTGOING: return "OUTGOING";
case RIL_CPISTAT_NEW_INCOMING: return "INCOMING";
case RIL_CPISTAT_CONNECTED: return "CONNECTED";   
case RIL_CPISTAT_DISCONNECTED: return "DISCONNECTED";
default: return stringformat("cpistat-%d", dw);
    }
}
std::string CallTypeString(DWORD dw)
{
    switch(dw)
    {
case RIL_CAPS_CALLTYPE_VOICE: return "VOICE";
case RIL_CAPS_CALLTYPE_DATA: return "DATA"; 
case RIL_CAPS_CALLTYPE_FAX: return "FAX";  
default: return stringformat("calltype-%d", dw);
    }
}
std::string MultipartyString(DWORD dw)
{
    switch(dw)
    {
case RIL_CALL_SINGLEPARTY: return "SINGLEPARTY";
case RIL_CALL_MULTIPARTY: return "MULTIPARTY"; 
default: return stringformat("mparty-%d", dw);
    }
}
std::string DisconnectCodeString(DWORD dw)
{
    if (IS_ERROR(dw))
        return RilErrorString(dw);
    else
        return RilResultString(dw);
}
std::string GetCallInfoString(RILCALLINFO* ci)
{
    std::string info= "CALLINFO: ";
    if (ci->dwParams&RIL_PARAM_CI_ID         ) info += stringformat("  id=%d", ci->dwID);
    if (ci->dwParams&RIL_PARAM_CI_DIRECTION  ) info += stringformat("  dir=%s", CallDirectionString(ci->dwDirection).c_str());
    if (ci->dwParams&RIL_PARAM_CI_STATUS     ) info += stringformat("  stat=%s", CallStatusString(ci->dwStatus).c_str());
    if (ci->dwParams&RIL_PARAM_CI_TYPE       ) info += stringformat("  type=%s", CallTypeString(ci->dwType).c_str());
    if (ci->dwParams&RIL_PARAM_CI_MULTIPARTY ) info += stringformat("  multi=%s", MultipartyString(ci->dwMultiparty).c_str());
    if (ci->dwParams&RIL_PARAM_CI_ADDRESS    ) info += stringformat("  addr=%hs", GetRilAddressString(&ci->raAddress).c_str());
    if (ci->dwParams&RIL_PARAM_CI_DESCRIPTION) info += stringformat("  desc=%ls", ci->wszDescription);
    if (ci->dwParams&RIL_PARAM_CI_CPISTATUS  ) info += stringformat("  cpistat=%s", CpiStatusString(ci->dwStatus).c_str());
    if (ci->dwParams&RIL_PARAM_CI_DISCONNECTCODE) info += stringformat("  disccode=%s", DisconnectCodeString(ci->dwDisconnectCode).c_str());

    DWORD dwKnown= RIL_PARAM_CI_ID|RIL_PARAM_CI_DIRECTION|RIL_PARAM_CI_STATUS|RIL_PARAM_CI_TYPE|RIL_PARAM_CI_MULTIPARTY|RIL_PARAM_CI_ADDRESS|RIL_PARAM_CI_DESCRIPTION|RIL_PARAM_CI_CPISTATUS|RIL_PARAM_CI_DISCONNECTCODE;
    if (ci->dwParams&~dwKnown)
        info += stringformat("  unknownparams-%08lx", ci->dwParams&~dwKnown);
    return info;
}

bool HandleCallControlRingEvent(RILRINGINFO* ri, DWORD cbdata)
{
	if (ri->cbSize!=cbdata) {
		debug("ril-HandleCallControlRingEvent: size mismatch ( rec:%d not:%d )\n", ri->cbSize, cbdata);
    }
    debug("ril-callcontrolring: %hs  %hs\n", GetRingInfoString(ri).c_str(), GetCallTypeString(ri->dwCallType).c_str());
    return true;
}
bool HandleCallControlConnectEvent(RILCONNECTINFO* ci, DWORD cbdata)
{
	if (ci->cbSize!=cbdata) {
		debug("ril-HandleCallControlConnectEvent: size mismatch ( rec:%d not:%d )\n", ci->cbSize, cbdata);
    }
    debug("ril-callcontrolconnect: %hs  %hs\n", GetConnectInfoString(ci).c_str(), GetCallTypeString(ci->dwCallType).c_str());

    if (g_ril) g_ril->RequestCallList();
    return true;
}

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

bool HandleCallControlDataServiceNegotiatedEvent(RILSERVICEINFO* si, DWORD cbdata)
{
	if (si->cbSize!=cbdata) {
		debug("ril-HandleCallControlDataServiceNegotiatedEvent: size mismatch ( rec:%d not:%d )\n", si->cbSize, cbdata);
    }
    debug("ril-callcontroldatasvc: %hs\n", GetServiceInfoString(si).c_str());
    return true;
}

std::string AddressTypeString(DWORD dw)
{
    switch(dw)
    {
case RIL_ADDRTYPE_UNKNOWN: return "UNKNOWN";      
case RIL_ADDRTYPE_INTERNATIONAL: return "INTERNATIONAL";
case RIL_ADDRTYPE_NATIONAL: return "NATIONAL";     
case RIL_ADDRTYPE_NETWKSPECIFIC: return "NETWKSPECIFIC";
case RIL_ADDRTYPE_SUBSCRIBER: return "SUBSCRIBER";   
case RIL_ADDRTYPE_ALPHANUM: return "ALPHANUM";     
case RIL_ADDRTYPE_ABBREV: return "ABBREV";       
default: return stringformat("addrtype-%d", dw);
    }
}
std::string NumberPlanString(DWORD dw)
{
    switch(dw)
    {
case RIL_NUMPLAN_UNKNOWN: return "UNKNOWN";  
case RIL_NUMPLAN_TELEPHONE: return "TELEPHONE";
case RIL_NUMPLAN_DATA: return "DATA";     
case RIL_NUMPLAN_TELEX: return "TELEX";    
case RIL_NUMPLAN_NATIONAL: return "NATIONAL"; 
case RIL_NUMPLAN_PRIVATE: return "PRIVATE";  
case RIL_NUMPLAN_ERMES: return "ERMES";    
default: return stringformat("numplan-%d", dw);
    }
}
std::string GetRilAddressString(RILADDRESS* ra)
{
    std::string info;
    if (ra->dwParams&RIL_PARAM_A_TYPE   ) info += stringformat(" type=%s", AddressTypeString(ra->dwType).c_str());
    if (ra->dwParams&RIL_PARAM_A_NUMPLAN) info += stringformat(" numplan=%s", NumberPlanString(ra->dwNumPlan).c_str());
    if (ra->dwParams&RIL_PARAM_A_ADDRESS) info += stringformat(" address=%ls", ra->wszAddress);

    DWORD dwKnown= RIL_PARAM_A_TYPE|RIL_PARAM_A_NUMPLAN|RIL_PARAM_A_ADDRESS;
    if (ra->dwParams&~dwKnown)
        info += stringformat("  unknownparams-%08lx", ra->dwParams&~dwKnown);
    return std::string("ADDRESS:[")+info+"]";
}
std::string SubAddressTypeString(DWORD dw)
{
switch(dw)
{
case RIL_SUBADDRTYPE_NSAP: return "NSAP";
case RIL_SUBADDRTYPE_USER: return "USER";
default: return stringformat("subaddrtype-%d", dw);
}
}
std::string GetRilSubAddressString(RILSUBADDRESS* ra)
{
    std::string info= "SUBADDRESS: ";
    if (ra->dwParams&RIL_PARAM_SA_TYPE      ) info += stringformat(" type=%s", SubAddressTypeString(ra->dwType).c_str());
    if (ra->dwParams&RIL_PARAM_SA_SUBADDRESS) info += stringformat(" subaddress=%ls", ra->wszSubAddress);

    DWORD dwKnown= RIL_PARAM_SA_TYPE|RIL_PARAM_SA_SUBADDRESS;
    if (ra->dwParams&~dwKnown)
        info += stringformat("  unknownparams-%08lx", ra->dwParams&~dwKnown);
    return info;
}
std::string RemotePartyValidityString(DWORD dw)
{
    switch(dw)
    {
case RIL_REMOTEPARTYINFO_VALID: return "VALID";      
case RIL_REMOTEPARTYINFO_WITHHELD: return "WITHHELD";   
case RIL_REMOTEPARTYINFO_UNAVAILABLE: return "UNAVAILABLE";
default: return stringformat("validity-%d", dw);
    }
}
std::string GetRemotePartyInfoString(RILREMOTEPARTYINFO* pi)
{
    std::string info= "REMOTEPARTYINFO: ";

    if (pi->dwParams&RIL_PARAM_RPI_ADDRESS    ) info += stringformat(" calleraddress=%hs", GetRilAddressString(&pi->raAddress).c_str());
    if (pi->dwParams&RIL_PARAM_RPI_SUBADDRESS ) info += stringformat(" callersubaddress=%hs", GetRilSubAddressString(&pi->rsaSubAddress).c_str());
    if (pi->dwParams&RIL_PARAM_RPI_DESCRIPTION) info += stringformat(" desc=%ls", pi->wszDescription);
    if (pi->dwParams&RIL_PARAM_RPI_VALIDITY   ) info += stringformat(" validity=%s", RemotePartyValidityString(pi->dwValidity).c_str());

    DWORD dwKnown= RIL_PARAM_RPI_ADDRESS|RIL_PARAM_RPI_SUBADDRESS|RIL_PARAM_RPI_DESCRIPTION|RIL_PARAM_RPI_VALIDITY;
    if (pi->dwParams&~dwKnown)
        info += stringformat("  unknownparams-%08lx", pi->dwParams&~dwKnown);
    return info;
}

bool HandleSupServiceCallerIdEvent(RILREMOTEPARTYINFO* pi, DWORD cbdata)
{
	if (pi->cbSize!=cbdata) {
		debug("ril-HandleSupServiceCallerIdEvent: size mismatch ( rec:%d not:%d )\n", pi->cbSize, cbdata);
    }
    debug("ril-supservice: %hs\n", GetRemotePartyInfoString(pi).c_str());
    return true;
}
bool HandleSimtoolkitCommandEvent(BYTE* lpData, DWORD cbdata)
{
    debug("ril-SIMTOOLKITCMD: %hs\n", lpData==NULL?"NULL":hexdump(lpData,cbdata).c_str());
    return true;
}

std::string GetRegistrationStatusString(int rs)
{
    switch(rs)
    {
case RIL_REGSTAT_UNKNOWN: return "RIL_REGSTAT_UNKNOWN";
case RIL_REGSTAT_UNREGISTERED: return "RIL_REGSTAT_UNREGISTERED";
case RIL_REGSTAT_HOME: return "RIL_REGSTAT_HOME";
case RIL_REGSTAT_ATTEMPTING: return "RIL_REGSTAT_ATTEMPTING";
case RIL_REGSTAT_DENIED: return "RIL_REGSTAT_DENIED";
case RIL_REGSTAT_ROAMING: return "RIL_REGSTAT_ROAMING";
default: return stringformat("regstat-%d", rs);
    }
}
std::string GetSystemtypeString(int dw)
{
    StringList l;
    if (dw&RIL_SYSTEMTYPE_IS95A) l.push_back("IS95A");       
    if (dw&RIL_SYSTEMTYPE_IS95B) l.push_back("IS95B");       
    if (dw&RIL_SYSTEMTYPE_1XRTTPACKET) l.push_back("1XRTTPACKET"); 
    if (dw&RIL_SYSTEMTYPE_GSM) l.push_back("GSM");         
    if (dw&RIL_SYSTEMTYPE_GPRS) l.push_back("GPRS");        
    if (dw&RIL_SYSTEMTYPE_EDGE) l.push_back("EDGE");        
    if (dw&RIL_SYSTEMTYPE_1XEVDOPACKET) l.push_back("1XEVDOPACKET");
    if (dw&RIL_SYSTEMTYPE_1XEVDVPACKET) l.push_back("1XEVDVPACKET");
    if (dw&RIL_SYSTEMTYPE_UMTS) l.push_back("UMTS");        

if (dw==0) l.push_back("NONE");
DWORD dwKnown= RIL_SYSTEMTYPE_NONE|RIL_SYSTEMTYPE_IS95A|RIL_SYSTEMTYPE_IS95B|RIL_SYSTEMTYPE_1XRTTPACKET|RIL_SYSTEMTYPE_GSM|RIL_SYSTEMTYPE_GPRS|RIL_SYSTEMTYPE_EDGE|RIL_SYSTEMTYPE_1XEVDOPACKET|RIL_SYSTEMTYPE_1XEVDVPACKET|RIL_SYSTEMTYPE_UMTS;
if (dw&~dwKnown) l.push_back(stringformat("RIL_SYSTEMTYPE_%08lx", dw&~dwKnown));

return JoinStringList(l, ",");
}

bool HandleNetworkGprsStatusChangedEvent(DWORD* d, DWORD cbdata)
{
	if (cbdata!=sizeof(DWORD)) {
		debug("ril-HandleNetworkGprsStatusChangedEvent: size mismatch ( rec:4, not:%d )\n", cbdata);
    }
    debug("ril-GprsStatus: %hs\n", GetRegistrationStatusString(*d).c_str());
    return true;
}
bool HandleNetworkSystemChangedEvent(DWORD* d, DWORD cbdata)
{
	if (cbdata!=sizeof(DWORD)) {
		debug("ril-HandleNetworkSystemChangedEvent: size mismatch ( rec:4, not:%d )\n", cbdata);
    }
    debug("ril-Systemtype: %hs\n", GetSystemtypeString(*d).c_str());
    return true;
}
bool RilClass::HandleNetworkRegistrationStatusChangedEvent(DWORD* d, DWORD cbdata)
{
	if (cbdata!=sizeof(DWORD)) {
		debug("ril-HandleNetworkRegistrationStatusChangedEvent: size mismatch ( rec:4, not:%d )\n", cbdata);
    }
    debug("ril-RegistrationStatus: %hs\n", GetRegistrationStatusString(*d).c_str());
    return true;
}

std::string GetRadioPresenceString(int rp)
{
    switch(rp)
    {
case RIL_RADIOPRESENCE_NOTPRESENT: return "RIL_RADIOPRESENCE_NOTPRESENT";
case RIL_RADIOPRESENCE_PRESENT: return "RIL_RADIOPRESENCE_PRESENT";
default: return stringformat("radioprecense-%d", rp);
    }
}
std::string GetRadioSupportString(int rp)
{
    switch(rp)
    {
case RIL_RADIOSUPPORT_UNKNOWN: return "RIL_RADIOSUPPORT_UNKNOWN";
case RIL_RADIOSUPPORT_OFF: return "RIL_RADIOSUPPORT_OFF";
case RIL_RADIOSUPPORT_ON: return "RIL_RADIOSUPPORT_ON";
default: return stringformat("radiosupport-%d", rp);
    }
}
std::string GetEqStateString(int rp)
{
    switch(rp)
    {
case RIL_EQSTATE_UNKNOWN: return "RIL_EQSTATE_UNKNOWN";
case RIL_EQSTATE_MINIMUM: return "RIL_EQSTATE_MINIMUM";
case RIL_EQSTATE_FULL: return "RIL_EQSTATE_FULL";
case RIL_EQSTATE_DISABLETX: return "RIL_EQSTATE_DISABLETX";
case RIL_EQSTATE_DISABLERX: return "RIL_EQSTATE_DISABLERX";
case RIL_EQSTATE_DISABLETXANDRX: return "RIL_EQSTATE_DISABLETXANDRX";