/* (C) 2003 XDA Developers itsme@xs4all.nl * * Copyright 2001,2002,2003 NAH6 BV * All Rights Reserved * * $Header$ */ #include #include "debug.h" #include "stringutils.h" #include "ril.h" #include "RilClass.h" extern RilClass *g_ril; std::string GetLockedStateString(DWORD dwLockedState); std::string GetCallTypeString(int calltype); std::string GetDisconnectInitString(int di); std::string GetServiceInfoString(RILSERVICEINFO *si); std::string GetRingInfoString(RILRINGINFO* ri); std::string GetConnectInfoString(RILCONNECTINFO* ci); std::string GetCallInfoString(RILCALLINFO* ci); bool HandleCallControlRingEvent(RILRINGINFO* ri, DWORD cbdata); bool HandleCallControlConnectEvent(RILCONNECTINFO* ci, DWORD cbdata); bool HandleCallControlDisconnectEvent(DWORD* d, DWORD cbdata); bool HandleCallControlDataServiceNegotiatedEvent(RILSERVICEINFO* si, DWORD cbdata); std::string GetRilAddressString(RILADDRESS* ra); std::string GetRilSubAddressString(RILSUBADDRESS* ra); std::string GetRemotePartyInfoString(RILREMOTEPARTYINFO* pi); bool HandleSupServiceCallerIdEvent(RILREMOTEPARTYINFO* pi, DWORD cbdata); bool HandleSimtoolkitCommandEvent(BYTE* lpData, DWORD cbdata); std::string GetRegistrationStatusString(int rs); bool HandleNetworkGprsStatusChangedEvent(DWORD* d, DWORD cbdata); bool HandleNetworkSystemChangedEvent(DWORD* d, DWORD cbdata); std::string GetRadioPresenceString(int rp); std::string GetEquipmentStateString(RILEQUIPMENTSTATE* es); std::string GetEquipmentInfoString(RILEQUIPMENTINFO* ei); std::string GetRilSignalQuality(RILSIGNALQUALITY *sq); std::string GetCallWaitingInfo(RILCALLWAITINGINFO *cw); bool HandleRadioPresenceChangedEvent(DWORD* d, DWORD cbdata); std::string GetRilMessageString(RILMESSAGE* m); bool HandleMessageMessageEvent(RILMESSAGE* m, DWORD cbdata); bool HandleCallStateChangedEvent(void *p, DWORD cbdata); bool HandleCallProgressInfoEvent(RILCALLINFO*p, DWORD cbdata); std::string GetDataEncodingSchemeString(RILMSGDCS *p); std::string RilNClassString(DWORD code) { switch(NCLASS_FROM_NOTIFICATION(code)) { case RIL_NCLASS_FUNCRESULT : return "FUNCRESULT"; case RIL_NCLASS_CALLCTRL : return "CALLCTRL"; case RIL_NCLASS_MESSAGE : return "MESSAGE"; case RIL_NCLASS_NETWORK : return "NETWORK"; case RIL_NCLASS_SUPSERVICE : return "SUPSERVICE"; case RIL_NCLASS_PHONEBOOK : return "PHONEBOOK"; case RIL_NCLASS_SIMTOOLKIT : return "SIMTOOLKIT"; case RIL_NCLASS_MISC : return "MISC"; case RIL_NCLASS_RADIOSTATE : return "RADIOSTATE"; case RIL_NCLASS_DEVSPECIFIC : return "DEVSPECIFIC"; default: return stringformat("NCLASS_%04x", (code>>16)&0xffff); } } std::string RilResultString(HRESULT res) { switch(res) { case RIL_RESULT_OK: return "FUNCRESULT::OK"; case RIL_RESULT_NOCARRIER: return "FUNCRESULT::NOCARRIER"; case RIL_RESULT_ERROR: return "FUNCRESULT::ERROR"; case RIL_RESULT_NODIALTONE: return "FUNCRESULT::NODIALTONE"; case RIL_RESULT_BUSY: return "FUNCRESULT::BUSY"; case RIL_RESULT_NOANSWER: return "FUNCRESULT::NOANSWER"; case RIL_RESULT_CALLABORTED: return "FUNCRESULT::CALLABORTED"; case RIL_NOTIFY_RING: return "CALLCTRL::RING"; case RIL_NOTIFY_CONNECT: return "CALLCTRL::CONNECT"; case RIL_NOTIFY_DISCONNECT: return "CALLCTRL::DISCONNECT"; case RIL_NOTIFY_DATASVCNEGOTIATED: return "CALLCTRL::DATASVCNEGOTIATED"; case RIL_NOTIFY_CALLSTATECHANGED: return "CALLCTRL::CALLSTATECHANGED"; case RIL_NOTIFY_EMERGENCYMODEENTERED: return "CALLCTRL::EMERGENCYMODEENTERED"; case RIL_NOTIFY_EMERGENCYMODEEXITED: return "CALLCTRL::EMERGENCYMODEEXITED"; case RIL_NOTIFY_EMERGENCYHANGUP: return "CALLCTRL::EMERGENCYHANGUP"; case RIL_NOTIFY_HSCSDPARAMSNEGOTIATED: return "CALLCTRL::HSCSDPARAMSNEGOTIATED"; case RIL_NOTIFY_DIAL: return "CALLCTRL::DIAL"; case RIL_NOTIFY_CALLPROGRESSINFO: return "CALLCTRL::CALLPROGRESSINFO"; case RIL_NOTIFY_CURRENTLINECHANGED: return "CALLCTRL::CURRENTLINECHANGED"; case RIL_NOTIFY_GPRS_DISCONNECT: return "CALLCTRL::GPRS_DISCONNECT"; case RIL_NOTIFY_MESSAGE: return "MESSAGE::MESSAGE"; case RIL_NOTIFY_BCMESSAGE: return "MESSAGE::BCMESSAGE"; case RIL_NOTIFY_STATUSMESSAGE: return "MESSAGE::STATUSMESSAGE"; case RIL_NOTIFY_MSGSTORED: return "MESSAGE::MSGSTORED"; case RIL_NOTIFY_MSGDELETED: return "MESSAGE::MSGDELETED"; case RIL_NOTIFY_MSGSTORAGECHANGED: return "MESSAGE::MSGSTORAGECHANGED"; case RIL_NOTIFY_MESSAGE_IN_SIM: return "MESSAGE::MESSAGE_IN_SIM"; case RIL_NOTIFY_BCMESSAGE_IN_SIM: return "MESSAGE::BCMESSAGE_IN_SIM"; case RIL_NOTIFY_STATUSMESSAGE_IN_SIM: return "MESSAGE::STATUSMESSAGE_IN_SIM"; case RIL_NOTIFY_REGSTATUSCHANGED: return "NETWORK::REGSTATUSCHANGED"; case RIL_NOTIFY_CALLMETER: return "NETWORK::CALLMETER"; case RIL_NOTIFY_CALLMETERMAXREACHED: return "NETWORK::CALLMETERMAXREACHED"; case RIL_NOTIFY_GPRSREGSTATUSCHANGED: return "NETWORK::GPRSREGSTATUSCHANGED"; case RIL_NOTIFY_SYSTEMCHANGED: return "NETWORK::SYSTEMCHANGED"; case (0x00000008 | RIL_NCLASS_NETWORK): return "NETWORK::LOCATIONINFO"; case RIL_NOTIFY_CALLERID: return "SUPSERVICE::CALLERID"; case RIL_NOTIFY_DIALEDID: return "SUPSERVICE::DIALEDID"; case RIL_NOTIFY_CALLWAITING: return "SUPSERVICE::CALLWAITING"; case RIL_NOTIFY_SUPSERVICEDATA: return "SUPSERVICE::SUPSERVICEDATA"; case RIL_NOTIFY_INTERMEDIATESS: return "SUPSERVICE::INTERMEDIATESS"; case RIL_NOTIFY_UNSOLICITEDSS : return "SUPSERVICE::UNSOLICITEDSS"; case RIL_NOTIFY_PHONEBOOKENTRYSTORED: return "PHONEBOOK::PHONEBOOKENTRYSTORED"; case RIL_NOTIFY_PHONEBOOKENTRYDELETED: return "PHONEBOOK::PHONEBOOKENTRYDELETED"; case RIL_NOTIFY_PHONEBOOKSTORAGECHANGED: return "PHONEBOOK::PHONEBOOKSTORAGECHANGED"; case RIL_NOTIFY_SIMTOOLKITCMD: return "SIMTOOLKIT::SIMTOOLKITCMD"; case RIL_NOTIFY_SIMTOOLKITCALLSETUP: return "SIMTOOLKIT::SIMTOOLKITCALLSETUP"; case RIL_NOTIFY_SIMTOOLKITEVENT: return "SIMTOOLKIT::SIMTOOLKITEVENT"; case RIL_NOTIFY_SIMTOOLKITSESSIONEND: return "SIMTOOLKIT::SIMTOOLKITSESSIONEND"; case RIL_NOTIFY_RADIOEQUIPMENTSTATECHANGED: return "RADIOSTATE::RADIOEQUIPMENTSTATECHANGED"; case RIL_NOTIFY_RADIOPRESENCECHANGED: return "RADIOSTATE::RADIOPRESENCECHANGED"; case RIL_NOTIFY_SIMNOTACCESSIBLE: return "MISC::SIMNOTACCESSIBLE"; case RIL_NOTIFY_DTMFSIGNAL: return "MISC::DTMFSIGNAL"; case RIL_NOTIFY_GPRSCLASS_NETWORKCHANGED: return "MISC::GPRSCLASS_NETWORKCHANGED"; case RIL_NOTIFY_GPRSCLASS_RADIOCHANGED: return "MISC::GPRSCLASS_RADIOCHANGED"; case RIL_NOTIFY_SIGNALQUALITY: return "MISC::SIGNALQUALITY"; case RIL_NOTIFY_MAINTREQUIRED : return "MISC::MAINTREQUIRED"; case RIL_NOTIFY_PRIVACYCHANGED : return "MISC::PRIVACYCHANGED"; case RIL_NOTIFY_SIM_DATACHANGE : return "MISC::SIM_DATACHANGE"; case RIL_NOTIFY_ATLOGGING : return "MISC::ATLOGGING"; case RIL_NOTIFY_SIMSTATUSCHANGED: return "MISC::SIMSTATUSCHANGED"; case RIL_NOTIFY_CELLID: return "DEVSPECIFIC::CELLID"; default: return stringformat("%hs::%04x", RilNClassString(res).c_str(), res&0xffff); } } std::string RilErrorClassString(DWORD dwErrorClass) { switch(dwErrorClass) { case RIL_ERRORCLASS_NONE: return "RIL_ERRORCLASS_NONE"; case RIL_ERRORCLASS_PASSWORD: return "RIL_ERRORCLASS_PASSWORD"; case RIL_ERRORCLASS_SIM: return "RIL_ERRORCLASS_SIM"; case RIL_ERRORCLASS_NETWORKACCESS: return "RIL_ERRORCLASS_NETWORKACCESS"; case RIL_ERRORCLASS_NETWORK: return "RIL_ERRORCLASS_NETWORK"; case RIL_ERRORCLASS_MOBILE: return "RIL_ERRORCLASS_MOBILE"; case RIL_ERRORCLASS_NETWORKUNSUPPORTED: return "RIL_ERRORCLASS_NETWORKUNSUPPORTED"; case RIL_ERRORCLASS_MOBILEUNSUPPORTED: return "RIL_ERRORCLASS_MOBILEUNSUPPORTED"; case RIL_ERRORCLASS_BADPARAM: return "RIL_ERRORCLASS_BADPARAM"; case RIL_ERRORCLASS_STORAGE: return "RIL_ERRORCLASS_STORAGE"; case RIL_ERRORCLASS_SMSC: return "RIL_ERRORCLASS_SMSC"; case RIL_ERRORCLASS_DESTINATION: return "RIL_ERRORCLASS_DESTINATION"; case RIL_ERRORCLASS_DESTINATIONUNSUPPORTED: return "RIL_ERRORCLASS_DESTINATIONUNSUPPORTED"; case RIL_ERRORCLASS_RADIOUNAVAILABLE: return "RIL_ERRORCLASS_RADIOUNAVAILABLE"; default: return stringformat("RIL_ERRORCLASS_%02x", dwErrorClass); } } std::string RilErrorString(DWORD dwError) { switch(dwError) { case RIL_E_PHONEFAILURE: return "RIL_E_MOBILE::PHONEFAILURE"; case RIL_E_NOCONNECTION: return "RIL_E_MOBILE::NOCONNECTION"; case RIL_E_LINKRESERVED: return "RIL_E_MOBILE::LINKRESERVED"; case RIL_E_OPNOTALLOWED: return "RIL_E_MOBILEUNSUPPORTED::OPNOTALLOWED"; case RIL_E_OPNOTSUPPORTED: return "RIL_E_MOBILEUNSUPPORTED::OPNOTSUPPORTED"; case RIL_E_PHSIMPINREQUIRED: return "RIL_E_PASSWORD::PHSIMPINREQUIRED"; case RIL_E_PHFSIMPINREQUIRED: return "RIL_E_PASSWORD::PHFSIMPINREQUIRED"; case RIL_E_PHFSIMPUKREQUIRED: return "RIL_E_PASSWORD::PHFSIMPUKREQUIRED"; case RIL_E_SIMNOTINSERTED: return "RIL_E_SIM::SIMNOTINSERTED"; case RIL_E_SIMPINREQUIRED: return "RIL_E_PASSWORD::SIMPINREQUIRED"; case RIL_E_SIMPUKREQUIRED: return "RIL_E_PASSWORD::SIMPUKREQUIRED"; case RIL_E_SIMFAILURE: return "RIL_E_SIM::SIMFAILURE"; case RIL_E_SIMBUSY: return "RIL_E_SIM::SIMBUSY"; case RIL_E_SIMWRONG: return "RIL_E_SIM::SIMWRONG"; case RIL_E_INCORRECTPASSWORD: return "RIL_E_PASSWORD::INCORRECTPASSWORD"; case RIL_E_SIMPIN2REQUIRED: return "RIL_E_PASSWORD::SIMPIN2REQUIRED"; case RIL_E_SIMPUK2REQUIRED: return "RIL_E_PASSWORD::SIMPUK2REQUIRED"; case RIL_E_MEMORYFULL: return "RIL_E_STORAGE::MEMORYFULL"; case RIL_E_INVALIDINDEX: return "RIL_E_STORAGE::INVALIDINDEX"; case RIL_E_NOTFOUND: return "RIL_E_STORAGE::NOTFOUND"; case RIL_E_MEMORYFAILURE: return "RIL_E_STORAGE::MEMORYFAILURE"; case RIL_E_TEXTSTRINGTOOLONG: return "RIL_E_BADPARAM::TEXTSTRINGTOOLONG"; case RIL_E_INVALIDTEXTSTRING: return "RIL_E_BADPARAM::INVALIDTEXTSTRING"; case RIL_E_DIALSTRINGTOOLONG: return "RIL_E_BADPARAM::DIALSTRINGTOOLONG"; case RIL_E_INVALIDDIALSTRING: return "RIL_E_BADPARAM::INVALIDDIALSTRING"; case RIL_E_NONETWORKSVC: return "RIL_E_NETWORKACCESS::NONETWORKSVC"; case RIL_E_NETWORKTIMEOUT: return "RIL_E_NETWORK::NETWORKTIMEOUT"; case RIL_E_EMERGENCYONLY: return "RIL_E_NETWORKACCESS::EMERGENCYONLY"; case RIL_E_NETWKPINREQUIRED: return "RIL_E_PASSWORD::NETWKPINREQUIRED"; case RIL_E_NETWKPUKREQUIRED: return "RIL_E_PASSWORD::NETWKPUKREQUIRED"; case RIL_E_SUBSETPINREQUIRED: return "RIL_E_PASSWORD::SUBSETPINREQUIRED"; case RIL_E_SUBSETPUKREQUIRED: return "RIL_E_PASSWORD::SUBSETPUKREQUIRED"; case RIL_E_SVCPINREQUIRED: return "RIL_E_PASSWORD::SVCPINREQUIRED"; case RIL_E_SVCPUKREQUIRED: return "RIL_E_PASSWORD::SVCPUKREQUIRED"; case RIL_E_CORPPINREQUIRED: return "RIL_E_PASSWORD::CORPPINREQUIRED"; case RIL_E_CORPPUKREQUIRED: return "RIL_E_PASSWORD::CORPPUKREQUIRED"; case RIL_E_TELEMATICIWUNSUPPORTED: return "RIL_E_NETWORKUNSUPPORTED::TELEMATICIWUNSUPPORT"; case RIL_E_SMTYPE0UNSUPPORTED: return "RIL_E_SMSC::SMTYPE0UNSUPPORTED"; case RIL_E_CANTREPLACEMSG: return "RIL_E_SMSC::CANTREPLACEMSG"; case RIL_E_PROTOCOLIDERROR: return "RIL_E_SMSC::PROTOCOLIDERROR"; case RIL_E_DCSUNSUPPORTED: return "RIL_E_SMSC::DCSUNSUPPORTED"; case RIL_E_MSGCLASSUNSUPPORTED: return "RIL_E_SMSC::MSGCLASSUNSUPPORTED"; case RIL_E_DCSERROR: return "RIL_E_SMSC::DCSERROR"; case RIL_E_CMDCANTBEACTIONED: return "RIL_E_SMSC::CMDCANTBEACTIONED"; case RIL_E_CMDUNSUPPORTED: return "RIL_E_SMSC::CMDUNSUPPORTED"; case RIL_E_CMDERROR: return "RIL_E_SMSC::CMDERROR"; case RIL_E_MSGBODYHEADERERROR: return "RIL_E_SMSC::MSGBODYHEADERERROR"; case RIL_E_SCBUSY: return "RIL_E_SMSC::SCBUSY"; case RIL_E_NOSCSUBSCRIPTION: return "RIL_E_SMSC::NOSCSUBSCRIPTION"; case RIL_E_SCSYSTEMFAILURE: return "RIL_E_SMSC::SCSYSTEMFAILURE"; case RIL_E_INVALIDADDRESS: return "RIL_E_SMSC::INVALIDADDRESS"; case RIL_E_DESTINATIONBARRED: return "RIL_E_SMSC::DESTINATIONBARRED"; case RIL_E_REJECTEDDUPLICATE: return "RIL_E_SMSC::REJECTEDDUPLICATE"; case RIL_E_VPFUNSUPPORTED: return "RIL_E_SMSC::VPFUNSUPPORTED"; case RIL_E_VPUNSUPPORTED: return "RIL_E_SMSC::VPUNSUPPORTED"; case RIL_E_SIMMSGSTORAGEFULL: return "RIL_E_STORAGE::SIMMSGSTORAGEFULL"; case RIL_E_NOSIMMSGSTORAGE: return "RIL_E_SIM::NOSIMMSGSTORAGE"; case RIL_E_SIMTOOLKITBUSY: return "RIL_E_SIM::SIMTOOLKITBUSY"; case RIL_E_SIMDOWNLOADERROR: return "RIL_E_SIM::SIMDOWNLOADERROR"; case RIL_E_MSGSVCRESERVED: return "RIL_E_NETWORKUNSUPPORTED::MSGSVCRESERVED"; case RIL_E_INVALIDMSGPARAM: return "RIL_E_BADPARAM::INVALIDMSGPARAM"; case RIL_E_UNKNOWNSCADDRESS: return "RIL_E_SMSC::UNKNOWNSCADDRESS"; case RIL_E_UNASSIGNEDNUMBER: return "RIL_E_DESTINATION::UNASSIGNEDNUMBER"; case RIL_E_MSGBARREDBYOPERATOR: return "RIL_E_NETWORKACCESS::MSGBARREDBYOPERATOR"; case RIL_E_MSGCALLBARRED: return "RIL_E_NETWORKACCESS::MSGCALLBARRED"; case RIL_E_MSGXFERREJECTED: return "RIL_E_DESTINATION::MSGXFERREJECTED"; case RIL_E_DESTINATIONOUTOFSVC: return "RIL_E_DESTINATION::DESTINATIONOUTOFSVC"; case RIL_E_UNIDENTIFIEDSUBCRIBER: return "RIL_E_NETWORKACCESS::UNIDENTIFIEDSUBCRIBE"; case RIL_E_SVCUNSUPPORTED: return "RIL_E_NETWORKUNSUPPORTED::SVCUNSUPPORTED"; case RIL_E_UNKNOWNSUBSCRIBER: return "RIL_E_NETWORKACCESS::UNKNOWNSUBSCRIBER"; case RIL_E_NETWKOUTOFORDER: return "RIL_E_NETWORK::NETWKOUTOFORDER"; case RIL_E_NETWKTEMPFAILURE: return "RIL_E_NETWORK::NETWKTEMPFAILURE"; case RIL_E_CONGESTION: return "RIL_E_NETWORK::CONGESTION"; case RIL_E_RESOURCESUNAVAILABLE: return "RIL_E_NONE::RESOURCESUNAVAILABLE"; case RIL_E_SVCNOTSUBSCRIBED: return "RIL_E_NETWORKUNSUPPORTED::SVCNOTSUBSCRIBED"; case RIL_E_SVCNOTIMPLEMENTED: return "RIL_E_NETWORKUNSUPPORTED::SVCNOTIMPLEMENTED"; case RIL_E_INVALIDMSGREFERENCE: return "RIL_E_BADPARAM::INVALIDMSGREFERENCE"; case RIL_E_INVALIDMSG: return "RIL_E_BADPARAM::INVALIDMSG"; case RIL_E_INVALIDMANDATORYINFO: return "RIL_E_BADPARAM::INVALIDMANDATORYINFO"; case RIL_E_MSGTYPEUNSUPPORTED: return "RIL_E_NETWORKUNSUPPORTED::MSGTYPEUNSUPPORTED"; case RIL_E_ICOMPATIBLEMSG: return "RIL_E_NETWORKUNSUPPORTED::ICOMPATIBLEMSG"; case RIL_E_INFOELEMENTUNSUPPORTED: return "RIL_E_NETWORKUNSUPPORTED::INFOELEMENTUNSUPPORT"; case RIL_E_PROTOCOLERROR: return "RIL_E_NETWORK::PROTOCOLERROR"; case RIL_E_NETWORKERROR: return "RIL_E_NETWORK::NETWORKERROR"; case RIL_E_MESSAGINGERROR: return "RIL_E_NETWORK::MESSAGINGERROR"; case RIL_E_NOTREADY: return "RIL_E_NONE::NOTREADY"; case RIL_E_TIMEDOUT: return "RIL_E_NONE::TIMEDOUT"; case RIL_E_CANCELLED: return "RIL_E_NONE::CANCELLED"; case RIL_E_NONOTIFYCALLBACK: return "RIL_E_NONE::NONOTIFYCALLBACK"; case RIL_E_OPFMTUNAVAILABLE: return "RIL_E_NETWORKUNSUPPORTED::OPFMTUNAVAILABLE"; case RIL_E_NORESPONSETODIAL: return "RIL_E_NETWORKACCESS::NORESPONSETODIAL"; case RIL_E_SECURITYFAILURE: return "RIL_E_NONE::SECURITYFAILURE"; case RIL_E_RADIOFAILEDINIT: return "RIL_E_NONE::RADIOFAILEDINIT"; case RIL_E_DRIVERINITFAILED: return "RIL_E_RADIOUNAVAILABLE::DRIVERINITFAILED"; case RIL_E_RADIONOTPRESENT: return "RIL_E_RADIOUNAVAILABLE::RADIONOTPRESENT"; case RIL_E_RADIOOFF: return "RIL_E_RADIOUNAVAILABLE::RADIOOFF"; default: return stringformat("%s::%02x", RilErrorClassString(RILERRORCLASS(dwError)).c_str(), dwError&0xff); } } std::string RilInfoClassString(DWORD dwClass) { StringList list; if (dwClass&RIL_INFOCLASS_VOICE) list.push_back("Voice"); if (dwClass&RIL_INFOCLASS_DATA) list.push_back("Data"); if (dwClass&RIL_INFOCLASS_FAX) list.push_back("Fax"); if (dwClass&RIL_INFOCLASS_SMS) list.push_back("SMS"); if (dwClass&RIL_INFOCLASS_DATACIRCUITSYNC) list.push_back("DataCircuitSync"); 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); } } 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 ; idwParams&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 ; icbSize!=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"; 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"; 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_INDICATION ) info += stringformat(" ind=%s", DCSIndicationString(p->dwIndication).c_str()); if (p->dwParams&RIL_PARAM_MDCS_LANGUAGE ) info += stringformat(" lang=%s", DCSLangString(p->dwLanguage).c_str()); return info; } int char_size(RILMSGDCS *p) { return (p->dwAlphabet==RIL_DCSALPHABET_UCS2) ? 2 : 1; } std::string msgInDeliverString(RILMESSAGE *m) { std::string info; if (m->dwParams&RIL_PARAM_M_ORIGADDRESS) info += stringformat(" %s", GetRilAddressString(&m->msgInDeliver.raOrigAddress).c_str()); if (m->dwParams&RIL_PARAM_M_PROTOCOLID) info += stringformat(" protocol=%s", MsgProtocolString(m->msgInDeliver.dwProtocolID).c_str()); if (m->dwParams&RIL_PARAM_M_DATACODING) info += stringformat(" %s", GetDataEncodingSchemeString(&m->msgInDeliver.rmdDataCoding).c_str()); if (m->dwParams&RIL_PARAM_M_SCRECEIVETIME) info += stringformat(" SYSTEMTIME"); //, m->msgInDeliver.stSCReceiveTime; // @field receive time (UTC) //if (m->dwParams&RIL_PARAM_M_HDRLENGTH) info += stringformat(" %08lx", m->msgInDeliver.cbHdrLength; // @field length of header in bytes //if (m->dwParams&RIL_PARAM_M_MSGLENGTH) info += stringformat(" %08lx", m->msgInDeliver.cchMsgLength; // @field length of body in bytes if (m->dwParams&RIL_PARAM_M_HDR) info += std::string(" hdr=")+hexdump(m->msgInDeliver.rgbHdr, m->msgInDeliver.cbHdrLength); if (m->dwParams&RIL_PARAM_M_MSG) info += std::string(" msg=")+hexdump(m->msgInDeliver.rgbMsg, char_size(&m->msgInDeliver.rmdDataCoding)*m->msgInDeliver.cchMsgLength); return info; } std::string msgInStatusString(RILMESSAGE *m) { std::string info; if (m->dwParams&RIL_PARAM_M_TGTMSGREFERENCE) info += stringformat(" msgref=%08lx", m->msgInStatus.dwTgtMsgReference); // @field target message reference if (m->dwParams&RIL_PARAM_M_TGTRECIPADDRESS) info += stringformat(" %s", GetRilAddressString(&m->msgInStatus.raTgtRecipAddress).c_str()); if (m->dwParams&RIL_PARAM_M_TGTSCRECEIVETIME) info += stringformat(" SYSTEMTIME"); //, m->msgInStatus.stTgtSCReceiveTime; // @field receipient receive time (UTC) if (m->dwParams&RIL_PARAM_M_TGTDISCHARGETIME) info += stringformat(" SYSTEMTIME"); //, m->msgInStatus.stTgtDischargeTime; // @field receipient dischage time (UTC) if (m->dwParams&RIL_PARAM_M_TGTDLVSTATUS) info += stringformat(" dlvstat=%s", MsgDeliveryStatusString(m->msgInStatus.dwTgtDlvStatus).c_str()); if (m->dwParams&RIL_PARAM_M_PROTOCOLID) info += stringformat(" protocol=%s", MsgProtocolString(m->msgInStatus.dwProtocolID).c_str()); if (m->dwParams&RIL_PARAM_M_DATACODING) info += stringformat(" %s", GetDataEncodingSchemeString(&m->msgInStatus.rmdDataCoding).c_str()); //if (m->dwParams&RIL_PARAM_M_HDRLENGTH) info += stringformat(" %08lx", m->msgInStatus.cbHdrLength); // @field length of header in bytes //if (m->dwParams&RIL_PARAM_M_MSGLENGTH) info += stringformat(" %08lx", m->msgInStatus.cchMsgLength); // @field length of body in bytes if (m->dwParams&RIL_PARAM_M_HDR) info += std::string(" hdr=")+hexdump(m->msgInStatus.rgbHdr, m->msgInStatus.cbHdrLength); if (m->dwParams&RIL_PARAM_M_MSG) info += std::string(" msg=")+hexdump(m->msgInStatus.rgbMsg, char_size(&m->msgInStatus.rmdDataCoding)*m->msgInStatus.cchMsgLength); return info; } std::string msgOutSubmitString(RILMESSAGE *m) { std::string info; if (m->dwParams&RIL_PARAM_M_DESTADDRESS) info += stringformat(" %s", GetRilAddressString(&m->msgOutSubmit.raDestAddress).c_str()); if (m->dwParams&RIL_PARAM_M_PROTOCOLID) info += stringformat(" protocol=%s", MsgProtocolString(m->msgOutSubmit.dwProtocolID).c_str()); if (m->dwParams&RIL_PARAM_M_DATACODING) info += stringformat(" %s", GetDataEncodingSchemeString(&m->msgOutSubmit.rmdDataCoding).c_str()); if (m->dwParams&RIL_PARAM_M_VPFORMAT) info += stringformat(" fmt=%s", MsgVPFormatString(m->msgOutSubmit.dwVPFormat).c_str()); if (m->dwParams&RIL_PARAM_M_VP) info += stringformat(" SYSTEMTIME"); //, m->msgOutSubmit.stVP; // @field relative validity period (values are expressed relative to the current time) //if (m->dwParams&RIL_PARAM_M_HDRLENGTH) info += stringformat(" %08lx", m->msgOutSubmit.cbHdrLength); // @field length of header in bytes //if (m->dwParams&RIL_PARAM_M_MSGLENGTH) info += stringformat(" %08lx", m->msgOutSubmit.cchMsgLength); // @field length of body in bytes if (m->dwParams&RIL_PARAM_M_HDR) info += std::string(" hdr=")+hexdump(m->msgOutSubmit.rgbHdr, m->msgOutSubmit.cbHdrLength); if (m->dwParams&RIL_PARAM_M_MSG) info += std::string(" msg=")+hexdump(m->msgOutSubmit.rgbMsg, char_size(&m->msgOutSubmit.rmdDataCoding)*m->msgOutSubmit.cchMsgLength); return info; } std::string msgOutCommandString(RILMESSAGE *m) { std::string info; if (m->dwParams&RIL_PARAM_M_PROTOCOLID) info += stringformat(" protocol=%s", MsgProtocolString(m->msgOutCommand.dwProtocolID).c_str()); if (m->dwParams&RIL_PARAM_M_COMMANDTYPE) info += stringformat(" cmdtype=%s", MsgCommandTypeString(m->msgOutCommand.dwCommandType).c_str()); if (m->dwParams&RIL_PARAM_M_TGTMSGREFERENCE) info += stringformat(" msgref=%08lx", m->msgOutCommand.dwTgtMsgReference); // @field target message reference if (m->dwParams&RIL_PARAM_M_DESTADDRESS) info += stringformat(" %s", GetRilAddressString(&m->msgOutCommand.raDestAddress).c_str()); //if (m->dwParams&RIL_PARAM_M_CMDLENGTH) info += stringformat(" %08lx", m->msgOutCommand.cbCmdLength); // @field length of command in bytes if (m->dwParams&RIL_PARAM_M_CMD) info += std::string(" cmd=")+hexdump(m->msgOutCommand.rgbCmd, m->msgOutCommand.cbCmdLength); return info; } std::string msgOutRawString(RILMESSAGE *m) { std::string info; //if (m->dwParams&RIL_PARAM_M_MSGLENGTH) info += stringformat(" %08lx", m->msgOutRaw.cchMsgLength); // @field length of body in bytes if (m->dwParams&RIL_PARAM_M_MSG) info += std::string(" msg=")+hexdump(m->msgOutRaw.rgbMsg, m->msgOutRaw.cchMsgLength); return info; } std::string GeoScopeString(DWORD dw) { switch(dw) { case RIL_GEOSCOPE_CELL_IMMEDIATE: return "CELL_IMMEDIATE"; case RIL_GEOSCOPE_CELL: return "CELL"; case RIL_GEOSCOPE_PLMN: return "PLMN"; case RIL_GEOSCOPE_LOCATIONAREA: return "LOCATIONAREA"; default: return stringformat("geoscope-%d", dw); } } std::string msgBcGeneralString(RILMESSAGE *m) { std::string info; if (m->dwParams&RIL_PARAM_M_GEOSCOPE) info += stringformat(" scope=%s", GeoScopeString(m->msgBcGeneral.dwGeoScope).c_str()); if (m->dwParams&RIL_PARAM_M_MSGCODE) info += stringformat(" code=%", m->msgBcGeneral.dwMsgCode); // @field message code if (m->dwParams&RIL_PARAM_M_UPDATENUMBER) info += stringformat(" update=%d", m->msgBcGeneral.dwUpdateNumber); // @field update number if (m->dwParams&RIL_PARAM_M_ID) info += stringformat(" id=%d", m->msgBcGeneral.dwID); // @field identity if (m->dwParams&RIL_PARAM_M_DATACODING) info += stringformat(" %s", GetDataEncodingSchemeString(&m->msgBcGeneral.rmdDataCoding).c_str()); if (m->dwParams&RIL_PARAM_M_TOTALPAGES) info += stringformat(" total=%d", m->msgBcGeneral.dwTotalPages); // @field total number of pages if (m->dwParams&RIL_PARAM_M_PAGENUMBER) info += stringformat(" pagenr=%d", m->msgBcGeneral.dwPageNumber); // @field current page number //if (m->dwParams&RIL_PARAM_M_MSGLENGTH) info += stringformat(" %08lx", m->msgBcGeneral.cchMsgLength); // @field length of message in bytes if (m->dwParams&RIL_PARAM_M_MSG) info += std::string(" msg=")+hexdump(m->msgBcGeneral.rgbMsg, char_size(&m->msgBcGeneral.rmdDataCoding)*m->msgBcGeneral.cchMsgLength); return info; } std::string GetRilMessageString(RILMESSAGE* m) { std::string info= "RILMESSAGE: "; if (m->dwParams&RIL_PARAM_M_SVCCTRADDRESS) info += stringformat(" servicecenter=%hs", GetRilAddressString(&m->raSvcCtrAddress).c_str()); if (m->dwParams&RIL_PARAM_M_FLAGS ) info += stringformat(" flags=%08lx", m->dwFlags); DWORD dwKnown= RIL_PARAM_M_SVCCTRADDRESS|RIL_PARAM_M_FLAGS|RIL_PARAM_M_TYPE; if (m->dwParams&RIL_PARAM_M_TYPE) switch(m->dwType) { case RIL_MSGTYPE_IN_DELIVER : info += stringformat(" msgInDeliver %s", msgInDeliverString(m).c_str()); dwKnown |= RIL_PARAM_M_ALL_IN_DELIVER;break; case RIL_MSGTYPE_IN_STATUS : info += stringformat(" msgInStatus %s", msgInStatusString(m).c_str()); dwKnown |= RIL_PARAM_M_ALL_IN_STATUS;break; case RIL_MSGTYPE_OUT_SUBMIT : info += stringformat(" msgOutSubmit %s", msgOutSubmitString(m).c_str()); dwKnown |= RIL_PARAM_M_ALL_OUT_SUBMIT;break; case RIL_MSGTYPE_OUT_COMMAND: info += stringformat(" msgOutCommand %s",msgOutCommandString(m).c_str());dwKnown |= RIL_PARAM_M_ALL_OUT_COMMAND;break; case RIL_MSGTYPE_OUT_RAW : info += stringformat(" msgOutRaw %s", msgOutRawString(m).c_str()); dwKnown |= RIL_PARAM_M_ALL_OUT_RAW;break; case RIL_MSGTYPE_BC_GENERAL : info += stringformat(" msgBcGeneral %s", msgBcGeneralString(m).c_str()); dwKnown |= RIL_PARAM_M_ALL_BC_GENERAL;break; default: info += stringformat("UNKNOWN RILMSGTYPE: %d", m->dwType); } else { info += " !!! NO TYPE !!!"; } if (m->dwParams&~dwKnown) info += stringformat(" unknownparams-%08lx", m->dwParams&~dwKnown); return info; } bool RilClass::HandleCellIdMessageEvent(RILCELLID *cellid) { debug("ril - lac=%08lx cellid=%08lx\n", cellid->lac, cellid->cellid); return true; } std::string GetRestrictedSimCmdString(RILSIMRESPONSE* simrsp, DWORD cbdata) { std::string answer= "RILSIMRESPONSE:"; // sw1 sw2 // 90 00 - ok // 94 02 - out of range / invalid address // 98 04 - access denied if (simrsp->dwParams&RIL_PARAM_SR_STATUSWORD1) answer += stringformat(" sw1=%08lx " ,simrsp->dwStatusWord1); if (simrsp->dwParams&RIL_PARAM_SR_STATUSWORD2) answer += stringformat(" sw2=%08lx " ,simrsp->dwStatusWord2); if (simrsp->dwParams&RIL_PARAM_SR_RESPONSE ) answer += hexdump(simrsp->pbResponse, simrsp->cbSize-4*sizeof(DWORD)); DWORD dwKnown= RIL_PARAM_SR_STATUSWORD1|RIL_PARAM_SR_STATUSWORD2|RIL_PARAM_SR_RESPONSE; if (simrsp->dwParams&~dwKnown) answer += stringformat(" unknownparams-%08lx", simrsp->dwParams&~dwKnown); return answer; } void RilClass::HandleRestrictedSimCmdAnswer(RILSIMRESPONSE* simrsp, DWORD cbdata) { debug("ril - simanswer size=%d .. %d - %s\n", cbdata, simrsp->cbSize, GetRestrictedSimCmdString(simrsp, cbdata).c_str()); } bool HandleMessageMessageEvent(RILMESSAGE* m, DWORD cbdata) { if (m->cbSize!=cbdata) { debug("ril-HandleMessageMessageEvent: size mismatch ( rec:%d not:%d )\n", m->cbSize, cbdata); } debug("RilMessage: %hs\n", GetRilMessageString(m).c_str()); return true; } bool HandleCallStateChangedEvent(void *p, DWORD cbdata) { if (cbdata!=0) { debug("ril-HandleCallStateChangedEvent with cbdata(%d)!=0\n", cbdata); } debug("ril-HandleCallStateChangedEvent\n"); if (g_ril) g_ril->RequestCallList(); return true; } bool HandleCallProgressInfoEvent(RILCALLINFO*p, DWORD cbdata) { if (cbdata!=sizeof(RILCALLINFO) && cbdata!=sizeof(RILCALLINFO)+sizeof(DWORD)) { debug("ril-HandleCallProgressInfoEvent with cbdata(%d)!=%d{+4}\n", cbdata, sizeof(RILCALLINFO)); } debug("ril-HandleCallProgressInfoEvent: %s [ %08lx ]\n", GetCallInfoString(p).c_str(), cbdata==sizeof(RILCALLINFO)+sizeof(DWORD) ? *(DWORD*)(((BYTE*)p)+sizeof(RILCALLINFO)) : 0); return true; } bool HandlePhonebookStorageChangedEvent(DWORD dwPbLoc) { debug("ril-HandlePhonebookStorageChangedEvent %hs\n", GetPbLocString(dwPbLoc).c_str()); return true; } bool HandleCurrentLineChangedEvent(DWORD dwAddressId) { debug("ril-HandleCurrentLineChangedEvent curaddressid=%d\n", dwAddressId); return true; } bool HandleSignalQualityEvent(RILSIGNALQUALITY *sq, DWORD cbdata) { if (cbdata!=sq->cbSize) { debug("ril-HandleSignalQualityEvent: size mismatch ( rec:%d not:%d )\n", sq->cbSize, cbdata); } debug("ril-HandleSignalQualityEvent: %hs\n", GetRilSignalQuality(sq).c_str()); return true; } bool HandleCallWaitingEvent(RILCALLWAITINGINFO *cw, DWORD cbdata) { if (cbdata!=cw->cbSize) { debug("ril-HandleCallWaitingEvent: size mismatch ( rec:%d not:%d )\n", cw->cbSize, cbdata); } debug("ril-HandleCallWaitingEvent: %hs\n", GetCallWaitingInfo(cw).c_str()); return true; } bool HandleSupplementalServiceDataEvent(RILSUPSERVICEDATA*lpData, DWORD cbdata) { std::string s= "SUPSVCDATA"; if (lpData->dwParams&RIL_PARAM_SSDI_STATUS) s+= stringformat(" %08lx", lpData->dwStatus); if (lpData->dwParams&RIL_PARAM_SSDI_DATA) s+= std::string(" ") + hexdump(lpData->pbData, lpData->cbSize-12); debug("ril-supplementalservicedataevent: %s\n", s.c_str()); return true; } void RilClass::HandleNotify(DWORD dwCode, const void *lpData, DWORD cbdata) { debugt("RIL_Notification: %hs %d bytes\n", RilResultString(dwCode).c_str(), cbdata); bool bDumpRawPacket= false; switch(dwCode) { case RIL_NOTIFY_RING: bDumpRawPacket=!HandleCallControlRingEvent((RILRINGINFO*)lpData, cbdata); break; case RIL_NOTIFY_CONNECT: bDumpRawPacket=!HandleCallControlConnectEvent((RILCONNECTINFO*)lpData, cbdata); break; case RIL_NOTIFY_DISCONNECT: bDumpRawPacket=!HandleCallControlDisconnectEvent((DWORD*)lpData, cbdata); break; case RIL_NOTIFY_DATASVCNEGOTIATED: bDumpRawPacket=!HandleCallControlDataServiceNegotiatedEvent((RILSERVICEINFO*)lpData, cbdata); break; case RIL_NOTIFY_CALLSTATECHANGED: bDumpRawPacket=!HandleCallStateChangedEvent((void*)lpData, cbdata); break; case RIL_NOTIFY_CALLPROGRESSINFO: bDumpRawPacket=!HandleCallProgressInfoEvent((RILCALLINFO*)lpData, cbdata); break; case RIL_NOTIFY_CALLERID: bDumpRawPacket=!HandleSupServiceCallerIdEvent((RILREMOTEPARTYINFO*)lpData, cbdata); break; case RIL_NOTIFY_SIMTOOLKITCMD: bDumpRawPacket=!HandleSimtoolkitCommandEvent((BYTE*)lpData, cbdata); break; case RIL_NOTIFY_GPRSREGSTATUSCHANGED: bDumpRawPacket=!HandleNetworkGprsStatusChangedEvent((DWORD*)lpData, cbdata); break; case RIL_NOTIFY_SYSTEMCHANGED: bDumpRawPacket=!HandleNetworkSystemChangedEvent((DWORD*)lpData, cbdata); break; case RIL_NOTIFY_REGSTATUSCHANGED: bDumpRawPacket=!HandleNetworkRegistrationStatusChangedEvent((DWORD*)lpData, cbdata); break; case RIL_NOTIFY_RADIOEQUIPMENTSTATECHANGED: bDumpRawPacket=!HandleRadioStateChangedEvent((RILEQUIPMENTSTATE*)lpData, cbdata); break; case RIL_NOTIFY_RADIOPRESENCECHANGED: bDumpRawPacket=!HandleRadioPresenceChangedEvent((DWORD*)lpData, cbdata); break; case RIL_NOTIFY_MESSAGE: bDumpRawPacket=!HandleMessageMessageEvent((RILMESSAGE*)lpData, cbdata); break; case RIL_NOTIFY_CELLID: bDumpRawPacket=!HandleCellIdMessageEvent((RILCELLID*)lpData); break; case RIL_NOTIFY_PHONEBOOKSTORAGECHANGED: bDumpRawPacket=!HandlePhonebookStorageChangedEvent(*(DWORD*)lpData); break; case RIL_NOTIFY_CURRENTLINECHANGED: bDumpRawPacket=!HandleCurrentLineChangedEvent(*(DWORD*)lpData); break; case RIL_NOTIFY_SIGNALQUALITY: bDumpRawPacket=!HandleSignalQualityEvent((RILSIGNALQUALITY *)lpData, cbdata); break; case RIL_NOTIFY_CALLWAITING: bDumpRawPacket=!HandleCallWaitingEvent((RILCALLWAITINGINFO *)lpData, cbdata); break; case RIL_NOTIFY_SUPSERVICEDATA: bDumpRawPacket=!HandleSupplementalServiceDataEvent((RILSUPSERVICEDATA*)lpData, cbdata); break; default: debug("ril- unknown notification: %08lx\n", dwCode); bDumpRawPacket= true; } if (bDumpRawPacket) debug("rawnot: %hs\n", hexdump((BYTE*)lpData, cbdata/4, 4).c_str()); } bool RilClass::RequestSignalQuality() { #ifdef _HAVE_RIL if (m_hRil==NULL) { debug("ril-ERROR: ril not initialized\n"); return false; } if (m_hrSignalQualityRequest) { debug("ril-RequestSignalQuality: still busy\n"); return true; } m_hrSignalQualityRequest= RIL_GetSignalQuality(m_hRil); if (IS_ERROR(m_hrSignalQualityRequest)) { error(m_hrSignalQualityRequest, "RIL_GetSignalQuality"); m_hrSignalQualityRequest= 0; return false; } #endif return true; } bool RilClass::RequestSimRecordStatus(DWORD dwFile) { #ifdef _HAVE_RIL if (m_hRil==NULL) { debug("ril-ERROR: ril not initialized\n"); return false; } if (m_hrSimRecordStatusRequest) { debug("ril-RequestSimRecordStatus: still busy - %08lx\n", m_hrSimRecordStatusRequest); return true; } m_hrSimRecordStatusRequest= RIL_GetSimRecordStatus(m_hRil, dwFile); if (IS_ERROR(m_hrSimRecordStatusRequest)) { error(m_hrSimRecordStatusRequest, "RIL_GetSimRecordStatus"); m_hrSimRecordStatusRequest= 0; return false; } else { m_dwCurSimRecFile= dwFile; debugt("simrecstatus(%08lx) result=%08lx\n", dwFile, m_hrSimRecordStatusRequest); } #endif return true; } bool RilClass::RequestEquipmentInfo() { #ifdef _HAVE_RIL if (m_hrEquipmentInfoRq) { debug("ril-RequestEquipmentInfo: still busy\n"); return true; } m_hrEquipmentInfoRq= RIL_GetEquipmentInfo(m_hRil); if (IS_ERROR(m_hrEquipmentInfoRq)) { error(m_hrEquipmentInfoRq, "RIL_GetEquipmentInfo"); m_hrEquipmentInfoRq= 0; return false; } #endif return true; } bool RilClass::RequestCallList() { #ifdef _HAVE_RIL if (m_hrCallListRequest) { debug("ril-RequestCallList: still busy\n"); return true; } m_hrCallListRequest= RIL_GetCallList(m_hRil); if (IS_ERROR(m_hrCallListRequest)) { error(m_hrCallListRequest, "RIL_GetCallList"); m_hrCallListRequest= 0; return false; } #endif return true; } bool RilClass::RequestAudioDevices() { #ifdef _HAVE_RIL if (m_hrAudioDevicesRequest) { debug("ril-RequestAudioDevices: still busy\n"); return true; } m_hrAudioDevicesRequest= RIL_GetAudioDevices(m_hRil); if (IS_ERROR(m_hrAudioDevicesRequest)) { error(m_hrAudioDevicesRequest, "RIL_GetAudioDevices"); m_hrAudioDevicesRequest= 0; return false; } #endif return true; } bool RilClass::RequestLockedState() { #ifdef _HAVE_RIL if (m_hrLockedStateRequest) { debug("ril-RequestLockedState: still busy\n"); return true; } m_hrLockedStateRequest= RIL_GetPhoneLockedState(m_hRil); if (IS_ERROR(m_hrLockedStateRequest)) { error(m_hrLockedStateRequest, "RIL_GetPhoneLockedState"); m_hrLockedStateRequest= 0; return false; } #endif return true; } bool RilClass::RequestCurrentAddressId() { #ifdef _HAVE_RIL if (m_hrCurrentAddressIdRequest) { debug("ril-RequestCurrentAddressId: still busy\n"); return true; } m_hrCurrentAddressIdRequest= RIL_GetCurrentAddressId(m_hRil); if (IS_ERROR(m_hrCurrentAddressIdRequest)) { error(m_hrCurrentAddressIdRequest, "RIL_GetCurrentAddressId"); m_hrCurrentAddressIdRequest= 0; return false; } #endif return true; } bool RilClass::RequestEquipmentState() { #ifdef _HAVE_RIL if (m_hrEquipmentStateRequest) { debug("ril-RequestEquipmentState: still busy\n"); return true; } m_hrEquipmentStateRequest= RIL_GetEquipmentState(m_hRil); if (IS_ERROR(m_hrEquipmentStateRequest)) { error(m_hrEquipmentStateRequest, "RIL_GetEquipmentState"); m_hrEquipmentStateRequest= 0; return false; } #endif return true; } bool RilClass::RequestSubscriberNumbers() { #ifdef _HAVE_RIL if (m_hrSubscriberNumbersRequest) { debug("ril-RequestSubscriberNumbers: still busy\n"); return true; } m_hrSubscriberNumbersRequest= RIL_GetSubscriberNumbers(m_hRil); if (IS_ERROR(m_hrSubscriberNumbersRequest)) { error(m_hrSubscriberNumbersRequest, "RIL_GetSubscriberInfo"); m_hrSubscriberNumbersRequest= 0; return false; } else debug("celltowerinfo request result=%08lx\n", m_hrCellTowerInfoRequest); #endif return true; } bool RilClass::RequestCellTowerInfo() { #ifdef _HAVE_RIL if (m_hrCellTowerInfoRequest) { debug("ril-RequestCellTowerInfo: still busy\n"); return true; } m_hrCellTowerInfoRequest= RIL_GetCellTowerInfo(m_hRil); if (IS_ERROR(m_hrCellTowerInfoRequest)) { error(m_hrCellTowerInfoRequest, "RIL_GetCellTowerInfo"); m_hrCellTowerInfoRequest= 0; return false; } else debug("celltowerinfo request result=%08lx\n", m_hrCellTowerInfoRequest); #endif return true; } bool RilClass::RequestAudioMuting() { #ifdef _HAVE_RIL if (m_hrAudioMutingRequest) { debug("ril-RequestAudioMuting: still busy\n"); return true; } m_hrAudioMutingRequest= RIL_GetAudioMuting(m_hRil); if (IS_ERROR(m_hrAudioMutingRequest)) { error(m_hrAudioMutingRequest, "RIL_GetAudioMuting"); m_hrAudioMutingRequest= 0; return false; } else debug("mute request result=%08lx\n", m_hrAudioMutingRequest); #endif return true; } bool RilClass::SetAudioMuting(bool bFlag) { #ifdef _HAVE_RIL if (m_hrSetAudioMutingRequest) { debug("RilClass::SetAudioMuting: still busy\n"); return true; } m_hrSetAudioMutingRequest= RIL_SetAudioMuting(m_hRil, bFlag); if (IS_ERROR(m_hrSetAudioMutingRequest)) { error(m_hrSetAudioMutingRequest, "RIL_SetAudioMuting"); m_hrSetAudioMutingRequest= 0; return false; } else debug("set mute request result=%08lx\n", m_hrSetAudioMutingRequest); #endif return true; } bool RilClass::GetCallWaiting(DWORD dwClass) { #ifdef _HAVE_RIL if (m_hrGetCallWaitingRequest) { debug("RilClass::GetCallWaiting: still busy\n"); return true; } m_hrGetCallWaitingRequest= RIL_GetCallWaitingSettings(m_hRil, dwClass); if (IS_ERROR(m_hrGetCallWaitingRequest)) { error(m_hrGetCallWaitingRequest, "RIL_GetCallWaitingSettings"); m_hrGetCallWaitingRequest= 0; return false; } else debug("get call waiting(%08lx) result=%08lx\n", m_hrGetCallWaitingRequest); #endif return true; } bool RilClass::SetCallWaiting(DWORD dwClass, DWORD dwStatus) { #ifdef _HAVE_RIL if (m_hrSetCallWaitingRequest) { debug("RilClass::SetCallWaiting: still busy\n"); return true; } m_hrSetCallWaitingRequest= RIL_SetCallWaitingStatus(m_hRil, dwClass, dwStatus); if (IS_ERROR(m_hrSetCallWaitingRequest)) { error(m_hrSetCallWaitingRequest, "RIL_SetCallWaitingSettings"); m_hrSetCallWaitingRequest= 0; return false; } else debug("set call waiting(%08lx,%08lx) result=%08lx\n", dwClass, dwStatus, m_hrSetCallWaitingRequest); #endif return true; } // wait for up to 5 seconds for answer from ril. bool WaitForRilAnswer(HRESULT &hrCmdId) { DWORD t0= GetTickCount(); while (hrCmdId && GetTickCount()-t0 < 5000) { Sleep(100); } if (hrCmdId) { hrCmdId= 0; return false; } return true; } bool RilClass::EnableCellBroadcasts(bool bFlag) { #ifdef _HAVE_RIL if (m_hrCBSRequest) { debug("RilClass::EnableCellBroadcasts: CBSRequest: still busy\n"); return true; } DWORD req= bFlag? 24 : 25; m_hrCBSRequest= RIL_DevSpecific(m_hRil, (BYTE*)&req, sizeof(req)); if (IS_ERROR(m_hrCBSRequest)) { error(m_hrCBSRequest, "RIL_DevSpecific(%d)", req); m_hrCBSRequest= 0; return false; } else debug("cbs request result=%08lx\n", m_hrCBSRequest); if (!WaitForRilAnswer(m_hrCBSRequest)) { debug("ril-ERROR: RIL_DevSpecific(%d) timeout\n", req); return false; } #endif return true; } bool RilClass::EnableCellId(bool bFlag) { #ifdef _HAVE_RIL if (m_hrCellIdRequest) { debug("RilClass::EnableCellId: CellIdRequest: still busy\n"); } DWORD req= bFlag? 26 : 27; m_hrCellIdRequest= RIL_DevSpecific(m_hRil, (BYTE*)&req, sizeof(req)); if (IS_ERROR(m_hrCellIdRequest)) { error(m_hrCellIdRequest, "RIL_DevSpecific(%d)", req); m_hrCellIdRequest= 0; return false; } else debug("cellid request result=%08lx\n", m_hrCellIdRequest); if (!WaitForRilAnswer(m_hrCellIdRequest)) { debug("ril-ERROR: RIL_DevSpecific(%d) timeout\n", req); return false; } #endif return true; } bool RilClass::SetEqState(DWORD dwState) { HRESULT hr= RIL_SetEquipmentState(m_hRil, dwState); if (IS_ERROR(hr)) { error(hr, "RIL_SetEquipmentState"); return false; } debug("seteqstate->%08lx\n", hr); return true; } bool RilClass::Hangup() { HRESULT hr= RIL_Hangup(m_hRil); if (IS_ERROR(hr)) { error(hr, "RIL_Hangup"); return false; } debug("hangup->%08lx\n", hr); return true; } bool RilClass::SetBearerServiceOptions(DWORD dwSpeed, DWORD dwName, DWORD dwCe) { RILBEARERSVCINFO bsi; bsi.cbSize= sizeof(RILBEARERSVCINFO); bsi.dwParams= RIL_PARAM_BSI_ALL; bsi.dwSpeed= dwSpeed; bsi.dwServiceName= dwName; bsi.dwConnectionElement= dwCe; HRESULT hr= RIL_SetBearerServiceOptions(m_hRil, &bsi); if (IS_ERROR(hr)) { error(hr, "RIL_SetBearerServiceOptions"); return false; } debug("setbeareroptions->%08lx\n", hr); return true; } bool RilClass::RegisterOnNetwork() { HRESULT hr= RIL_RegisterOnNetwork(m_hRil, RIL_OPSELMODE_AUTOMATIC, NULL); if (IS_ERROR(hr)) { error(hr, "RIL_RegisterOnNetwork"); return false; } debug("regnetwork->%08lx\n", hr); return true; } // transparent EF -> READBINARY : class=0xa0, p1.bit8=0, p1.b7-1 = offset, p3=size // linfix+cycl EF -> READRECORD : class=0xa0, p1=recnr, p2='02'(next),'03'(prev),'04'(abs), p3=size // see 51.011, which refers to TS 102 221 // bool RilClass::SendRestrictedSimCmd(DWORD dwCommand, DWORD dwFileId, const BYTE* lpbData, DWORD dwSize, DWORD nParams, ...) { #ifdef _HAVE_RIL if (m_hrRestrictedSimCmdRequest) { debug("RilClass::SendRestrictedSimCmd: still busy\n"); return true; } RILSIMCMDPARAMETERS simcmd; memset(&simcmd, 0, sizeof(RILSIMCMDPARAMETERS)); simcmd.cbSize= sizeof(RILSIMCMDPARAMETERS); simcmd.dwParams= RIL_PARAM_SCP_FILEID; simcmd.dwFileID= dwFileId; va_list ap; va_start(ap, nParams); if (nParams>0) { simcmd.dwParameter1= va_arg(ap, DWORD); simcmd.dwParams |= RIL_PARAM_SCP_PARAM1; } if (nParams>1) { simcmd.dwParameter2= va_arg(ap, DWORD); simcmd.dwParams |= RIL_PARAM_SCP_PARAM2; } if (nParams>2) { simcmd.dwParameter3= va_arg(ap, DWORD); simcmd.dwParams |= RIL_PARAM_SCP_PARAM3; } va_end(ap); m_hrRestrictedSimCmdRequest= RIL_SendRestrictedSimCmd(m_hRil, dwCommand, &simcmd, lpbData, dwSize); if (IS_ERROR(m_hrRestrictedSimCmdRequest)) { error(m_hrRestrictedSimCmdRequest, "RIL_SendRestrictedSimCmd"); m_hrRestrictedSimCmdRequest= 0; return false; } else debugt("restrictedcmd result=%08lx\n", m_hrRestrictedSimCmdRequest); #endif return true; } /* * ril functions not yet implemented: RIL_DevSpecific(HRIL hRil, const BYTE* lpbParams, DWORD dwSize); -> BYTE* RIL_GetDevCaps(HRIL hRil, DWORD dwCapsType); RIL_CAPSTYPE_DIAL points to an structure RIL_CAPSTYPE_DTMFDURATIONRANGE points to an structure (values in milliseconds) RIL_CAPSTYPE_BEARERSERVICE points to an structure RIL_CAPSTYPE_PBINDEXRANGE points to an structure RIL_CAPSTYPE_PBENTRYLENGTH points to an strcuture RIL_CAPSTYPE_MSGMEMORYLOCATIONS points to an structure RIL_CAPSTYPE_MSGCONFIGINDEXRANGE points to an structure RIL_CAPSTYPE_PREFOPINDEXRANGE points to an structure RIL_CAPSTYPE_SIMTOOLKITNOTIFICATIONS points to an SIMTOOLKIT structure RIL_CAPSTYPE_HSCSD points to an structure RIL_CAPSTYPE_GPRS points to an structure RIL_CAPSTYPE_RLP points to an array of structures RIL_CAPSTYPE_LOCKINGPWDLENGTHS points to an array of structures RIL_CAPSTYPE_BARRINGPWDLENGTHS points to an array of structures RIL_CAPSTYPE_CALLMGTCMDS points to containing a combination of constants RIL_CAPSTYPE_EQUIPMENTSTATES points to containing a combination of constants RIL_CAPSTYPE_PBSTORELOCATIONS points to containing a combination of constants RIL_CAPSTYPE_MSGSERVICETYPES points to containing a combination of constants RIL_CAPSTYPE_BROADCASTMSGLANGS points to containing a combination of constants RIL_CAPSTYPE_MSGSTATUSVALUES points to containing a combination of constants RIL_CAPSTYPE_LOCKFACILITIES points to containing a combination of constants RIL_CAPSTYPE_BARRTYPES points to containing a combination of constants RIL_CAPSTYPE_FORWARDINGREASONS points to containing a combination of constants RIL_CAPSTYPE_INFOCLASSES points to containing a combination of constants RIL_GetGPRSAddress(HRIL hRil, DWORD dwContextID); -> WCHAR* RIL_GetCCBSStatus(HRIL hRil, DWORD dwCCBSIndex); -> char* RIL_GetCallBarringStatus(HRIL hRil, DWORD dwType, DWORD dwInfoClass, LPCSTR lpszPassword); -> RIL_BARRINGSTATUS RIL_GetCallForwardingSettings(HRIL hRil, DWORD dwReason, DWORD dwInfoClass); -> RILCALLFORWARDINGSETTINGS RIL_GetCallWaitingSettings(HRIL hRil, DWORD dwInfoClass); -> RIL_INFOCLASS_ RIL_GetCurrentOperator(HRIL hRil, DWORD dwFormat); -> RILOPERATORNAMES RIL_GetLockingStatus(HRIL hRil, DWORD dwFacility, LPCSTR lpszPassword); -> RIL_LOCKINGSTATUS_ RIL_GetPreferredOperatorList(HRIL hRil, DWORD dwFormat); -> RILOPERATORINFO RIL_ReadMsg(HRIL hRil, DWORD dwIndex); -> RILMESSAGEINFO RIL_ReadPhonebookEntries(HRIL hRil, DWORD dwStartIndex, DWORD dwEndIndex); -> RILPHONEBOOKENTRY RIL_GetCellBroadcastMsgConfig(HRIL hRil); -> RILCBMSGCONFIG RIL_GetAudioGain(HRIL hRil); -> RILGAININFO RIL_GetBearerServiceOptions(HRIL hRil); -> RILBEARERSVCINFO RIL_GetCallerIdSettings(HRIL hRil); -> RILCALLERIDSETTINGS RIL_GetCellTowerInfo(HRIL hRil); -> RILCELLTOWERINFO RIL_GetCostInfo(HRIL hRil); -> RILCOSTINFO RIL_GetDataCompression(HRIL hRil); -> RILDATACOMPINFO RIL_GetDialedIdSettings(HRIL hRil); -> RILDIALEDIDSETTINGS RIL_GetErrorCorrection(HRIL hRil); -> RILERRORCORRECTIONINFO RIL_GetClosedGroupSettings(HRIL hRil); RIL_GetMsgConfig(HRIL hRil); -> RILMSGCONFIG RIL_GetMsgServiceOptions(HRIL hRil); -> RILMSGSERVICEINFO RIL_GetRLPOptions(HRIL hRil); -> RILRLPINFO RIL_GetSystemTime(HRIL hRil); -> SYSTEMTIME RIL_GetUserIdentity(HRIL hRil); -> char* RIL_GetLineStatus(HRIL hRil); -> RIL_LINESTAT_ RIL_GetHideIdSettings(HRIL hRil); -> RILHIDEIDSETTINGS RIL_GetHideConnectedIdSettings(HRIL hRil); -> RILHIDECONNECTEDIDSETTINGS RIL_GetGPRSAttached(HRIL hRil); -> BOOL RIL_GetGPRSClass(HRIL hRil); -> RIL_GPRSCLASS_ RIL_GetGPRSContextActivatedList(HRIL hRil); -> RILGPRSCONTEXTACTIVATED RIL_GetGPRSContextList(HRIL hRil); -> RILGPRSCONTEXT RIL_GetGPRSRegistrationStatus(HRIL hRil); -> RIL_REGSTAT_ RIL_GetHSCSDCallSettings(HRIL hRil); -> RILCALLHSCSDINFO RIL_GetHSCSDOptions(HRIL hRil); -> RILHSCSDINFO RIL_GetMOSMSService(HRIL hRil); -> RIL_MOSMSSERVICE_ RIL_GetOperatorList(HRIL hRil); -> RILOPERATORINFO RIL_GetPhonebookOptions(HRIL hRil); -> RILPHONEBOOKINFO RIL_GetRegistrationStatus(HRIL hRil); -> RIL_REGSTAT_ RIL_GetSimToolkitProfile(HRIL hRil); -> BYTE* RIL_GetMinimumQualityOfServiceList(HRIL hRil); -> RILGPRSQOSPROFILE RIL_GetRequestedQualityOfServiceList(HRIL hRil); -> RILGPRSQOSPROFILE */