rilclass.cpp

wince ril程序

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 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());

    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;
    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);
        return false;
    }
    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);
        return false;
    }
    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 ( not:%d )\n", cbdata);
        return false;
    }
    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);
        return false;
    }
    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);
        return false;
    }
    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);
    }
}

bool HandleNetworkGprsStatusChangedEvent(DWORD* d, DWORD cbdata)
{
	if (cbdata!=sizeof(DWORD)) {
		debug("ril-HandleNetworkGprsStatusChangedEvent: size mismatch ( not:%d )\n", cbdata);
        return false;
    }
    debug("ril-GprsStatus: %hs\n", GetRegistrationStatusString(*d).c_str());
    return true;
}
bool RilClass::HandleNetworkRegistrationStatusChangedEvent(DWORD* d, DWORD cbdata)
{
	if (cbdata!=sizeof(DWORD)) {
		debug("ril-HandleNetworkRegistrationStatusChangedEvent: size mismatch ( not:%d )\n", cbdata);
        return false;
    }
    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";
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());