{ This file is part of the Free Pascal run time library. Copyright (c) 2007 Free Pascal development team. See the file COPYING.FPC, included in this distribution, for details about the copyright. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. **********************************************************************} { Declarations for tapi WinCE API, note than on WinCE simmgr functions originally based in coredll.dll SIM Manager is an API set that allows access to information stored on the SIM Card This port based on Windows Mobile 5 Smartphone Edition SDK contact S0vNark0m for more information snk_post@mail.ru (en, ru) } {$ifdef read_interface} //***************************************************************************** // consts //***************************************************************************** const SIM_ERRORCLASS_SIM = $02; // Problem with the SIM SIM_ERRORCLASS_PASSWORD = $01; // Unspecified phone failure SIM_ERRORCLASS_STORAGE = $03; // Error relating to storage SIM_ERRORCLASS_NONE = $00; // Misc error FACILITY_SIM = $800; ERROR_BASE = Longword(SEVERITY_ERROR) shl 31 or Longword(FACILITY_SIM) shl 16; // C Macros conversion, internal def // Internal def = errclass shl 8 MSE_ERRORCLASS_SIM = ERROR_BASE or Word(SIM_ERRORCLASS_SIM) shl 8; MSE_ERRORCLASS_PASSWORD = ERROR_BASE or Word(SIM_ERRORCLASS_PASSWORD) shl 8; MSE_ERRORCLASS_STORAGE = ERROR_BASE or Word(SIM_ERRORCLASS_STORAGE) shl 8; MSE_ERRERRORCLASS_NONE = ERROR_BASE or Word(SIM_ERRORCLASS_NONE) shl 8; // Error | Various errors SIM_E_SIMFAILURE = MSE_ERRORCLASS_SIM or $01; // SIM failure was detected SIM_E_SIMBUSY = MSE_ERRORCLASS_SIM or $02; // SIM is busy SIM_E_SIMWRONG = MSE_ERRORCLASS_SIM or $03; // Inorrect SIM was inserted SIM_E_NOSIMMSGSTORAGE = MSE_ERRORCLASS_SIM or $04; // SIM isn't capable of storing messages SIM_E_SIMTOOLKITBUSY = MSE_ERRORCLASS_SIM or $05; // SIM Application Toolkit is busy SIM_E_SIMDOWNLOADERROR = MSE_ERRORCLASS_SIM or $06; // SIM data download error SIM_E_SIMNOTINSERTED = MSE_ERRORCLASS_SIM or $07; // SIM isn't inserted into the phone SIM_E_PHSIMPINREQUIRED = MSE_ERRORCLASS_PASSWORD or $20; // PH-SIM PIN is required to perform this operation SIM_E_PHFSIMPINREQUIRED = MSE_ERRORCLASS_PASSWORD or $21; // PH-FSIM PIN is required to perform this operation SIM_E_PHFSIMPUKREQUIRED = MSE_ERRORCLASS_PASSWORD or $22; // PH-FSIM PUK is required to perform this operation SIM_E_SIMPINREQUIRED = MSE_ERRORCLASS_PASSWORD or $23; // SIM PIN is required to perform this operation SIM_E_SIMPUKREQUIRED = MSE_ERRORCLASS_PASSWORD or $24; // SIM PUK is required to perform this operation SIM_E_INCORRECTPASSWORD = MSE_ERRORCLASS_PASSWORD or $25; // Incorrect password was supplied SIM_E_SIMPIN2REQUIRED = MSE_ERRORCLASS_PASSWORD or $26; // SIM PIN2 is required to perform this operation SIM_E_SIMPUK2REQUIRED = MSE_ERRORCLASS_PASSWORD or $27; // SIM PUK2 is required to perform this operation SIM_E_NETWKPINREQUIRED = MSE_ERRORCLASS_PASSWORD or $28; // Network Personalization PIN is required to perform this operation SIM_E_NETWKPUKREQUIRED = MSE_ERRORCLASS_PASSWORD or $29; // Network Personalization PUK is required to perform this operation SIM_E_SUBSETPINREQUIRED = MSE_ERRORCLASS_PASSWORD or $2A; // Network Subset Personalization PIN is required to perform this operation SIM_E_SUBSETPUKREQUIRED = MSE_ERRORCLASS_PASSWORD or $2B; // Network Subset Personalization PUK is required to perform this operation SIM_E_SVCPINREQUIRED = MSE_ERRORCLASS_PASSWORD or $2C; // Service Provider Personalization PIN is required to perform this operation SIM_E_SVCPUKREQUIRED = MSE_ERRORCLASS_PASSWORD or $2D; // Service Provider Personalization PUK is required to perform this operation SIM_E_CORPPINREQUIRED = MSE_ERRORCLASS_PASSWORD or $2E; // Corporate Personalization PIN is required to perform this operation SIM_E_CORPPUKREQUIRED = MSE_ERRORCLASS_PASSWORD or $2F; // Corporate Personalization PUK is required to perform this operation SIM_E_MEMORYFULL = MSE_ERRORCLASS_STORAGE or $40; // Storage memory is full SIM_E_INVALIDINDEX = MSE_ERRORCLASS_STORAGE or $41; // Invalid storage index was supplied SIM_E_NOTFOUND = MSE_ERRORCLASS_STORAGE or $42; // A requested storage entry was not found SIM_E_MEMORYFAILURE = MSE_ERRORCLASS_STORAGE or $43; // Storage memory failure SIM_E_SIMMSGSTORAGEFULL = MSE_ERRORCLASS_STORAGE or $44; // Message storage on the SIM is full SIM_E_EMPTYINDEX = MSE_ERRORCLASS_STORAGE or $45; // Storage location is empty SIM_E_NOTREADY = MSE_ERRERRORCLASS_NONE or $60; // SIM isn't yet ready to perform the requested operation SIM_E_SECURITYFAILURE = MSE_ERRERRORCLASS_NONE or $61; // SIM isn't yet ready to perform the requested operation SIM_E_BUFFERTOOSMALL = MSE_ERRERRORCLASS_NONE or $62; // Buffer too small SIM_E_NOTTEXTMESSAGE = MSE_ERRERRORCLASS_NONE or $63; // Requested SMS message is not a text message SIM_E_NOSIM = MSE_ERRERRORCLASS_NONE or $64; // Device doesn't have a SIM SIM_E_NETWORKERROR = MSE_ERRERRORCLASS_NONE or $65; // There was a network error SIM_E_MOBILEERROR = MSE_ERRERRORCLASS_NONE or $66; // Mobile error SIM_E_UNSUPPORTED = MSE_ERRERRORCLASS_NONE or $67; // The command is unsupported SIM_E_BADPARAM = MSE_ERRERRORCLASS_NONE or $68; // Bad parameter SIM_E_UNDETERMINED = MSE_ERRERRORCLASS_NONE or $69; // Undetermined error SIM_E_RADIONOTPRESENT = MSE_ERRERRORCLASS_NONE or $6A; // The Radio is not present SIM_E_RADIOOFF = MSE_ERRERRORCLASS_NONE or $6B; // The Radio is off // Callback | Various notifications that are passed to the callback SIM_NOTIFY_CARD_REMOVED = $100; // SIM card was removed; lpData is NULL SIM_NOTIFY_FILE_REFRESH = $101; // Files on the SIM were refreshed; lpData points to a SIMFILEREFRESH structure SIM_NOTIFY_MSG_STORED = $102; // A message was stored to the SIM; lpData points to a SIMMESSAGECHANGE structure SIM_NOTIFY_MSG_DELETED = $103; // A message was removed from the SIM; lpData points to a SIMMESSAGECHANGE structure SIM_NOTIFY_PBE_STORED = $104; // A phone book entry was stored to the SIM; lpData points to a SIMPBECHANGE structure SIM_NOTIFY_PBE_DELETED = $105; // A phone book entry was removed from the SIM; lpData points to a SIMPBECHANGE structure SIM_NOTIFY_MSG_RECEIVED = $106; // Class 2 SMS was sent directly to the SIM; lpData points to a SIMMESSAGECHANGE structure SIM_NOTIFY_RADIOOFF = $107; // The Radio has been turned off but AT interpreter is still on; lpData is NULL SIM_NOTIFY_RADIOON = $108; // The Radio is present and is now on; lpData is NULL SIM_NOTIFY_RADIOPRESENT = $109; // A Radio Module/Driver has been installed; lpData is points to a DWORD which is 0 if the radio is OFF and 1 if the radio is ON SIM_NOTIFY_RADIOREMOVED = $10A; // A Radio Module/Driver has been removed; lpData is NULL } // Parameter flags for SimInitialize SIM_INIT_NONE = $00000000; // Do not send any notifications SIM_INIT_SIMCARD_NOTIFICATIONS = $00000001; // Send SIM card related notifications // SIMPHONEBOOKENTRY SIM_PARAM_PBE_ADDRESS = $00000001; // lpszAddress field is valid SIM_PARAM_PBE_ADDRESS_TYPE = $00000002; // dwAddressType field is valid SIM_PARAM_PBE_NUMPLAN = $00000004; // dwNumPlan field is valid SIM_PARAM_PBE_TEXT = $00000008; // lpszText field is valid SIM_PARAM_PBE_ALL = $0000000f; // All fields are valid // SIMMESSAGE SIM_PARAM_MSG_ADDRESS = $00000001; // lpszAddress field is valid SIM_PARAM_MSG_ADDRESS_TYPE = $00000002; // dwAddressType field is valid SIM_PARAM_MSG_NUMPLAN = $00000004; // dwNumPlan field is valid SIM_PARAM_MSG_RECEIVE_TIME = $00000008; // stReceiveTime field is valid SIM_PARAM_MSG_HEADER = $00000010; // rgbHeader field is valid SIM_PARAM_MSG_HEADER_LENGTH = $00000020; // cbHdrLength field is valid SIM_PARAM_MSG_MESSAGE = $00000040; // lpszMessage field is valid SIM_PARAM_MSG_ALL = $0000007f; // All fields are valid // SIMCAPS } SIM_PARAM_CAPS_PBSTORAGES = $00000001; // dwPBStorages field is valid SIM_PARAM_CAPS_PBEMAXADDRESSLENGTH = $00000002; // dwPBEMaxAddressLength field is valid SIM_PARAM_CAPS_PBEMAXTEXTLENGTH = $00000004; // dwPBEMaxTextLength field is valid SIM_PARAM_CAPS_PBEMININDEX = $00000008; // dwMinPBIndex field is valid SIM_PARAM_CAPS_PBEMAXINDEX = $00000010; // dwMaxPBIndex field is valid SIM_PARAM_CAPS_LOCKFACILITIES = $00000020; // dwLockFacilities field is valid SIM_PARAM_CAPS_LOCKINGPWDLENGTH = $00000040; // dwNumLockingPwdLengths and rgLockingPwdLengths fields are valid SIM_PARAM_CAPS_READMSGSTORAGES = $00000080; // dwReadMsgStorages field is valid SIM_PARAM_CAPS_WRITEMSGSTORAGES = $00000100; // dwWriteMsgStorages field is valid SIM_PARAM_CAPS_ALL = $000001ff; // All fields are valid // SIMRECORDINFO SIM_PARAM_RECORDINFO_RECORDTYPE = $00000001; // dwRecordType field is valid SIM_PARAM_RECORDINFO_ITEMCOUNT = $00000002; // dwItemCount field is valid SIM_PARAM_RECORDINFO_SIZE = $00000004; // dwSize field is valid SIM_PARAM_RECORDINFO_ALL = $00000007; // All fields are valid // SIMFILEREFRESH } SIM_PARAM_FILEREFRESH_FLAGS = $00000001; // dwFlags field is valid SIM_PARAM_FILEREFRESH_FILECOUNT = $00000002; // dwFileCount field is valid SIM_PARAM_FILEREFRESH_FILEARRAY = $00000004; // rgdwAddress field is valid SIM_PARAM_FILEREFRESH_ALL = $00000007; // All fields are valid // Phonebook Storage | Phone book storage locations } SIM_PBSTORAGE_EMERGENCY = $00000001; // Emergency dial list SIM_PBSTORAGE_FIXEDDIALING = $00000002; // SIM fixed dialing list SIM_PBSTORAGE_LASTDIALING = $00000004; // SIM last dialing list SIM_PBSTORAGE_OWNNUMBERS = $00000008; // SIM ownnumbers lists SIM_PBSTORAGE_SIM = $00000010; // General SIM Storage SIM_NUMPBSTORAGES = 5; // Number of phonebook storages // SIM DevCaps | Device Capabilities } SIM_CAPSTYPE_PBENTRYLENGTH = $00000001; // Phonebook entry lengths SIM_CAPSTYPE_PBSTORELOCATIONS = $00000002; // Phonebook storage locations SIM_CAPSTYPE_LOCKFACILITIES = $00000004; // Lock facilities SIM_CAPSTYPE_PBINDEXRANGE = $00000008; // Valid phonebook entry indexes SIM_CAPSTYPE_LOCKINGPWDLENGTHS = $00000010; // Locking password lengths SIM_CAPSTYPE_MSGMEMORYLOCATIONS = $00000020; // Message memory locations SIM_CAPSTYPE_ALL = $0000003F; // All of the above // SMS Storage | SMS storage locations } SIM_SMSSTORAGE_BROADCAST = $00000001; // Broadcast message storage location SIM_SMSSTORAGE_SIM = $00000002; // SIM storage location SIM_NUMSMSSTORAGES = 2; // Number of message storage locations // Address Type | Defines different address types } SIM_ADDRTYPE_UNKNOWN = $00000000; // Unknown SIM_ADDRTYPE_INTERNATIONAL = $00000001; // International number SIM_ADDRTYPE_NATIONAL = $00000002; // National number SIM_ADDRTYPE_NETWKSPECIFIC = $00000003; // Network specific number SIM_ADDRTYPE_SUBSCRIBER = $00000004; // Subscriber number (protocol-specific) SIM_ADDRTYPE_ALPHANUM = $00000005; // Alphanumeric address SIM_ADDRTYPE_ABBREV = $00000006; // Abbreviated number // Numbering Plan | Defines different numbering plans for SIM_ADDRTYPE_UNKNOWN, // SIM_ADDRTYPE_INTERNATIONAL, and SIM_ADDRTYPE_NATIONAL SIM_NUMPLAN_UNKNOWN = $00000000; // Unknown SIM_NUMPLAN_TELEPHONE = $00000001; // ISDN/telephone numbering plan (E.164/E.163) SIM_NUMPLAN_DATA = $00000002; // Data numbering plan (X.121) SIM_NUMPLAN_TELEX = $00000003; // Telex numbering plan SIM_NUMPLAN_NATIONAL = $00000004; // National numbering plan SIM_NUMPLAN_PRIVATE = $00000005; // Private numbering plan SIM_NUMPLAN_ERMES = $00000006; // ERMES numbering plan (ETSI DE/PS 3 01-3) // Phone Locked | Indicates if the phone is currently locked (i.e. // awaiting password) and what password to enter SIM_LOCKEDSTATE_UNKNOWN = $00000000; // Locking state is unknown SIM_LOCKEDSTATE_READY = $00000001; // Not awaiting a password (unlocked) SIM_LOCKEDSTATE_SIM_PIN = $00000002; // Awaiting the SIM PIN SIM_LOCKEDSTATE_SIM_PUK = $00000003; // Awaiting the SIM PUK SIM_LOCKEDSTATE_PH_SIM_PIN = $00000004; // Awaiting the Phone to SIM Personalization PIN SIM_LOCKEDSTATE_PH_FSIM_PIN = $00000005; // Awaiting the Phone to first SIM Personalization PIN SIM_LOCKEDSTATE_PH_FSIM_PUK = $00000006; // Awaiting the Phone to first SIM Personalization PUK SIM_LOCKEDSTATE_SIM_PIN2 = $00000007; // Awaiting the SIM PIN2 SIM_LOCKEDSTATE_SIM_PUK2 = $00000008; // Awaiting the SIM PUK2 SIM_LOCKEDSTATE_PH_NET_PIN = $00000009; // Awaiting the Network Personalization PIN SIM_LOCKEDSTATE_PH_NET_PUK = $0000000a; // Awaiting the Network Personalization PUK SIM_LOCKEDSTATE_PH_NETSUB_PIN = $0000000b; // Awaiting the Network Subset Personalization PIN SIM_LOCKEDSTATE_PH_NETSUB_PUK = $0000000c; // Awaiting the Network Subset Personalization PUK SIM_LOCKEDSTATE_PH_SP_PIN = $0000000d; // Awaiting the Service Provider Personalization PIN SIM_LOCKEDSTATE_PH_SP_PUK = $0000000e; // Awaiting the Service Provider Personalization PUK SIM_LOCKEDSTATE_PH_CORP_PIN = $0000000f; // Awaiting the Corporate Personalization PIN SIM_LOCKEDSTATE_PH_CORP_PUK = $00000010; // Awaiting the Corporate Personalization PUK // Phonebook Misc | Special phonebook constants } SIM_PBINDEX_FIRSTAVAILABLE = $ffffffff; // Use first phonebook storage entry available // Phone Locking | Indicates the phone's locking behavior } SIM_LOCKFACILITY_CNTRL = $00000001; // Lock control curface SIM_LOCKFACILITY_PH_SIM = $00000002; // Lock phone to SIM card SIM_LOCKFACILITY_PH_FSIM = $00000004; // Lock phone to first SIM card SIM_LOCKFACILITY_SIM = $00000008; // Lock SIM card SIM_LOCKFACILITY_SIM_PIN2 = $00000010; // Lock SIM card SIM_LOCKFACILITY_SIM_FIXEDIALING = $00000020; // SIM fixed dialing memory SIM_LOCKFACILITY_NETWORKPERS = $00000040; // Network personalization SIM_LOCKFACILITY_NETWORKSUBPERS = $00000080; // Network subset personalization SIM_LOCKFACILITY_SERVICEPROVPERS = $00000100; // Service provider personalization SIM_LOCKFACILITY_CORPPERS = $00000200; // Corporate personalization SIM_NUMLOCKFACILITIES = 10; // Number of locking facilities // SIM Record | Different SIM file types SIM_RECORDTYPE_UNKNOWN = $00000000; // An unknown file type SIM_RECORDTYPE_TRANSPARENT = $00000001; // A single veriable lengthed record SIM_RECORDTYPE_CYCLIC = $00000002; // A cyclic set of records, each of the same length SIM_RECORDTYPE_LINEAR = $00000003; // A linear set of records, each of the same length SIM_RECORDTYPE_MASTER = $00000004; // Every SIM has a single master record, effectively the head node SIM_RECORDTYPE_DEDICATED = $00000005; // Effectively a "directory" file which is a parent of other records // SIM Record Refresh | Different ways of being notified that SIM // have been updated SIMFILE_FULLFILECHANGE = $00000001; // All files have been changed SIMFILE_FILECHANGE = $00000002; // Only a few files have been changed SIMFILE_SIMINIT = $00000004; // SIM Initiailization SIMFILE_SIMRESET = $00000008; // Reset the SIM // Max_Length | Maximum length constants } MAX_LENGTH_ADDRESS = 256; // Maximum length of an address MAX_LENGTH_PHONEBOOKENTRYTEXT = 256; // Maximum length of text in a phonebook entry MAX_LENGTH_HEADER = 256; // Maximum length of a SMS header MAX_LENGTH_MESSAGE = 256; // Maximum length of a SMS message MAX_FILES = 32; // Maximum number of files in a file change list //***************************************************************************** // types //***************************************************************************** type // HSIM | Handle to a SIM } HSIM = HANDLE; LPHSIM = ^HSIM; // SIMPHONEBOOKENTRY | A SIM phonebook entry simphonebookentry_tag = record cbSize : DWORD; // Size of the structure in bytes dwParams : DWORD; // Indicates valid parameter values lpszAddress : array[0..(MAX_LENGTH_ADDRESS)-1] of TCHAR; // The actual phone number dwAddressType : DWORD; // A SIM_ADDRTYPE_* constant dwNumPlan : DWORD; // A SIM_NUMPLAN_* constant lpszText : array[0..(MAX_LENGTH_PHONEBOOKENTRYTEXT)-1] of TCHAR; // Text assocaited with the entry end; TSIMPHONEBOOKENTRY = simphonebookentry_tag; LPSIMPHONEBOOKENTRY = ^simphonebookentry_tag; // SIMMESSAGE | A SIM message entry simmessage_tag = record cbSize : DWORD; // Size of the structure in bytes dwParams : DWORD; // Indicates valid parameter values lpszAddress : array[0..(MAX_LENGTH_ADDRESS)-1] of TCHAR; // The actual phone number dwAddressType : DWORD; // A SIM_ADDRTYPE_* constant dwNumPlan : DWORD; // A SIM_NUMPLAN_* constant stReceiveTime : SYSTEMTIME; // Timestamp for the incoming message cbHdrLength : DWORD; // Header length in bytes rgbHeader : array[0..(MAX_LENGTH_HEADER)-1] of BYTE; // The actual header data lpszMessage : array[0..(MAX_LENGTH_MESSAGE)-1] of TCHAR; // The actual message data end; TSIMMESSAGE = simmessage_tag; LPSIMMESSAGE = ^simmessage_tag; // SIMLOCKINGPWDLENGTH | Minimum password length } simlockingpwdlength = record dwFacility : DWORD; // The locking facility dwPasswordLength : DWORD; // The minimum password length end; LPSIMLOCKINGPWDLENGTH = ^simlockingpwdlength; // SIMCAPS | Capabilities of the SIM simcaps_tag = record cbSize : DWORD; // Size of the structure in bytes dwParams : DWORD; // Indicates valid parameter values dwPBStorages : DWORD; // Supported phonebook storages dwMinPBIndex : DWORD; // Minimum phonebook storages dwMaxPBIndex : DWORD; // Maximum phonebook storages dwMaxPBEAddressLength : DWORD; // Maximum address length of phonebook entries dwMaxPBETextLength : DWORD; // Maximum text length of phonebook entries dwLockFacilities : DWORD; // Supported locking facilities dwReadMsgStorages : DWORD; // Supported read message stores dwWriteMsgStorages : DWORD; // Supported write message stores dwNumLockingPwdLengths : DWORD; // Number of entries in rgLockingPwdLengths rgLockingPwdLengths : array[0..(SIM_NUMLOCKFACILITIES)-1] of SIMLOCKINGPWDLENGTH; // Password lengths for each facility end; TSIMCAPS = simcaps_tag; LPSIMCAPS = ^simcaps_tag; // SIMRECORDINFO | Information about a particular SIM file simrecordinfo_tag = record cbSize : DWORD; // Size of the structure in bytes dwParams : DWORD; // Indicates valid parameter values dwRecordType : DWORD; // SIM_RECORDTYPE_* Constant dwItemCount : DWORD; // Number of items in the record dwSize : DWORD; // Size in bytes of each item end; TSIMRECORDINFO = simrecordinfo_tag; LPSIMRECORDINFO = ^simrecordinfo_tag; // SIMFILEREFRESH | Information about which file(s) have been updated simfilerefresh_tag = record cbSize : DWORD; // Size of the structure in bytes dwParams : DWORD; // Indicates valid parameter values dwFlags : DWORD; // Combination of SIMFILE_* constants dwFileCount : DWORD; // Number of files in the update list rgdwAddress : array[0..(MAX_FILES)-1] of DWORD; // Array of files end; TSIMFILEREFRESH = simfilerefresh_tag; LPSIMFILEREFRESH = ^simfilerefresh_tag; // SIMPBECHANGE | Information about which SIM Phonebook entries have changed simpbechange_tag = record dwEntry : DWORD; // The index of the entry that has changed dwStorage : DWORD; // SIM_PBSTORAGE_* constant detailing which phonebook this entry is in end; TSIMPBECHANGE = simpbechange_tag; LPSIMPBECHANGE = ^simpbechange_tag; // SIMMESSAGECHANGE | Information about which SMS messages on the SIM have changed } simmessagechange_tag = record dwEntry : DWORD; // The index of the entry that has changed dwStorage : DWORD; // SIM_SMSSTORAGE_* constant details which storage location this entry is in end; TSIMMESSAGECHANGE = simmessagechange_tag; LPSIMMESSAGECHANGE = ^simmessagechange_tag; // This is the callback function prototype used by SIM Manager when // sending notifications. // - // Indicates type of notification received // Points to data structure specific to the notification // Size of data structure in bytes // Parameter passed to simInititialize TSIMCALLBACK = procedure (dwNotifyCode:DWORD; const pData:pointer; dwDataSize:DWORD; dwParam:DWORD); //***************************************************************************** // functions //***************************************************************************** // This function must be called by applications in order to use any of the // functions in this API. // Passing in a function callback is required only for applications that // wish to obtain notifications. // - // Indicates which notifications to receive // Function callback for notifications, may be NULL if notifications are not desired // Parameter to pass on each notification function call, may be NULL // Points to a HSIM handle to use on subsequent function calls function SimInitialize(dwFlags:DWORD; lpfnCallBack:TSIMCALLBACK; dwParam:DWORD; lphSim:LPHSIM):HRESULT;external KernelDLL name 'SimInitialize'; // This function deinitializes an HSIM handle. // - // A valid HSIM handle to deinitialize function SimDeinitialize(hSim:HSIM):HRESULT;external KernelDLL name 'SimDeinitialize'; // Gets the device capabilities of the SIM. // - // Points to a valid HSIM handle // Which device capabilities are we interested in? // Capabilities structure function SimGetDevCaps(hSim:HSIM; dwCapsType:DWORD; lpSimCaps:LPSIMCAPS):HRESULT;external KernelDLL name 'SimGetDevCaps'; // Reads a phonebook entry off the SIM card. // - // Points to a valid HSIM handle // A SIMPBSTORAGE_* Constant // Index of the entry to retrieve // Points to a phonebook entry structure function SimReadPhonebookEntry(hSim:HSIM; dwLocation:DWORD; dwIndex:DWORD; lpPhonebookEntry:LPSIMPHONEBOOKENTRY):HRESULT;external KernelDLL name 'SimReadPhonebookEntry'; // Gets the status of a phonebook location. // - // Points to a valid HSIM handle // A SIMPBSTORAGE_* Constant // Nubmer of used locations // Total number of locations function SimGetPhonebookStatus(hSim:HSIM; dwLocation:DWORD; lpdwUsed:LPDWORD; lpdwTotal:LPDWORD):HRESULT;external KernelDLL name 'SimGetPhonebookStatus'; // Writes a phonebook entry to the SIM card. // - // Points to a valid HSIM handle // A SIMPBSTORAGE_* Constant // Index of the entry to retrieve (may be SIM_PBINDEX_FIRSTAVAILABLE) // Points to a phonebook entry structure function SimWritePhonebookEntry(hSim:HSIM; dwLocation:DWORD; dwIndex:DWORD; lpPhonebookEntry:LPSIMPHONEBOOKENTRY):HRESULT;external KernelDLL name 'SimWritePhonebookEntry'; // Deletes a phonebook entry from the SIM card. // - // Points to a valid HSIM handle // A SIMPBSTORAGE_* Constant // Index of the entry to retrieve function SimDeletePhonebookEntry(hSim:HSIM; dwLocation:DWORD; dwIndex:DWORD):HRESULT;external KernelDLL name 'SimDeletePhonebookEntry'; // Checks if the SIM is currently awaiting a password. // This is called when powering on the phone. // - // Points to a valid HSIM handle // Points to a SIM_LOCKEDSTATE_* constant function SimGetPhoneLockedState(hSim:HSIM; lpdwLockedState:LPDWORD):HRESULT;external KernelDLL name 'SimGetPhoneLockedState'; // Sends a password to unlock the phone. // - // Points to a valid HSIM handle // Points to password string // Some locked states require a second password (e.g. PUK requires a new PIN to replace the old, presumably forgotten PIN) function SimUnlockPhone(hSim:HSIM; lpszPassword:LPTSTR; lpszNewPin:LPTSTR):HRESULT;external KernelDLL name 'SimUnlockPhone'; // Gets the locking status of the phone. // - // Points to a valid HSIM handle // A SIMLOCKFACILITY_* constant // Some facilities require a password // Enabled or diabled function SimGetLockingStatus(hSim:HSIM; dwLockingFacility:DWORD; lpszPassword:LPTSTR; var pfEnabled:BOOL):HRESULT;external KernelDLL name 'SimGetLockingStatus'; // Sets the locking status of the phone. // - // Points to a valid HSIM handle // A SIMLOCKFACILITY_* constant // Some facilities require a password // Enable or diable function SimSetLockingStatus(hSim:HSIM; dwLockingFacility:DWORD; lpszPassword:LPTSTR; fEnabled:BOOL):HRESULT;external KernelDLL name 'SimSetLockingStatus'; // Changes a locking password. // - // Points to a valid HSIM handle // A SIMLOCKFACILITY_* constant // The old password // The new password function SimChangeLockingPassword(hSim:HSIM; dwLockingFacility:DWORD; lpszOldPassword:LPTSTR; lpszNewPassword:LPTSTR):HRESULT;external KernelDLL name 'SimChangeLockingPassword'; // Gets the status of a SMS storage location. // - // Points to a valid HSIM handle // A SIM_SMSSTORAGE_* constant // Nubmer of used locations // Total number of locations function SimGetSmsStorageStatus(hSim:HSIM; dwStorage:DWORD; lpdwUsed:LPDWORD; lpdwTotal:LPDWORD):HRESULT;external KernelDLL name 'SimGetSmsStorageStatus'; // Reads an SMS from a particular storage location. // - // Points to a valid HSIM handle // A SIM_SMSSTORAGE_* constant // Index of the entry to retrieve // Points to an SMS message structure function SimReadMessage(hSim:HSIM; dwStorage:DWORD; dwIndex:DWORD; lpSimMessage:LPSIMMESSAGE):HRESULT;external KernelDLL name 'SimReadMessage'; // Writes an SMS to a particular storage location. // Note that SMS messages are always written to the first available storage location // - // lpdwIndex will be set to the index to which the message was written // Points to a valid HSIM handle // A SIM_SMSSTORAGE_* constant // Set to the index where the message was written // Points to an SMS message structure function SimWriteMessage(hSim:HSIM; dwStorage:DWORD; lpdwIndex:LPDWORD; lpSimMessage:LPSIMMESSAGE):HRESULT;external KernelDLL name 'SimWriteMessage'; // Deletes an SMS from a particular storage location. // - // Points to a valid HSIM handle // A SIM_SMSSTORAGE_* constant // Index of the entry to retrieve function SimDeleteMessage(hSim:HSIM; dwStorage:DWORD; dwIndex:DWORD):HRESULT;external KernelDLL name 'SimDeleteMessage'; // Reads a file form the SIM. // - // Points to a valid HSIM handle // SIM address // A SIM_RECORDTYPE_* constant // Applies only to SIM_RECORDTYPE_CYCLIC and SIM_RECORDTYPE_LINEAR, otherwise ignored // Data buffer // Size of data buffer // Number of bytes read function SimReadRecord(hSim:HSIM; dwAddress:DWORD; dwRecordType:DWORD; dwIndex:DWORD; lpData: LPBYTE; dwBufferSize: DWORD; lpdwBytesRead: LPDWORD):HRESULT;external KernelDLL name 'SimReadRecord'; // Writes a file to the SIM. // - // Points to a valid HSIM handle // SIM address // A SIM_RECORDTYPE_* constant // Applies only to SIM_RECORDTYPE_CYCLIC and SIM_RECORDTYPE_LINEAR, otherwise ignored function SimWriteRecord(hSim:HSIM; dwAddress:DWORD; dwRecordType:DWORD; dwIndex:DWORD; lpData: LPBYTE; dwByteCount: DWORD):HRESULT;external KernelDLL name 'SimWriteRecord'; // Gets information about a particular record. // - // Points to a valid HSIM handle // SIM address // Points to a SIM record information structure function SimGetRecordInfo(hSim:HSIM; dwAddress:DWORD; lpSimRecordInfo:LPSIMRECORDINFO):HRESULT;external KernelDLL name 'SimGetRecordInfo'; {$endif read_interface} {$ifdef read_implementation} {$endif read_implementation}