Telematics SDK - Interface Specification  v1.38.19
telux::tel Namespace Reference

Data Structures

struct  CardReaderStatus
 
class  CdmaCellIdentity
 
class  CdmaCellInfo
 
class  CdmaSignalStrengthInfo
 
struct  CellBroadcastFilter
 
class  CellBroadcastMessage
 Cell Broadcast message. More...
 
class  CellInfo
 
struct  CellularCapabilityInfo
 
class  Circle
 
class  CmasInfo
 
struct  DcStatus
 
struct  ECallHlapTimerEvents
 
struct  ECallHlapTimerStatus
 
struct  ECallModeInfo
 
struct  ECallMsdControlBits
 
struct  ECallMsdData
 
struct  ECallMsdOptionals
 
struct  ECallOptionalPdu
 
struct  ECallVehicleIdentificationNumber
 
struct  ECallVehicleLocation
 
struct  ECallVehicleLocationDelta
 
struct  ECallVehiclePropulsionStorageType
 
class  EtwsInfo
 
class  Geometry
 
class  GsmCellIdentity
 
class  GsmCellInfo
 
class  GsmSignalStrengthInfo
 
class  IAtrResponseCallback
 
class  ICall
 ICall represents a call in progress. An ICall cannot be directly created by the client, rather it is returned as a result of instantiating a call or from the PhoneListener when receiving an incoming call. More...
 
class  ICallListener
 A listener class for monitoring changes in call, including call state change and ECall state change. Override the methods for the state that you wish to receive updates for. More...
 
class  ICallManager
 Call Manager is the primary interface for call related operations Allows to conference calls, swap calls, make normal voice call and emergency call, send and update MSD pdu. More...
 
class  ICard
 ICard represents currently inserted UICC or eUICC. More...
 
class  ICardApp
 Represents a single card application. More...
 
class  ICardChannelCallback
 
class  ICardCommandCallback
 
class  ICardListener
 
class  ICardManager
 
class  ICardReaderCallback
 
struct  IccResult
 
class  ICellBroadcastListener
 A listener class which monitors cell broadcast messages. More...
 
class  ICellBroadcastManager
 CellBroadcastManager class is primary interface to configure and activate emergency broadcast messages and receive broadcast messages. More...
 
class  ICellularCapabilityCallback
 
class  IMakeCallCallback
 Interface for Make Call callback object. Client needs to implement this interface to get single shot responses for commands like make call. More...
 
class  IMultiSimListener
 Listener class for getting high capability change notification. The listener method can be invoked from multiple different threads. Client needs to make sure that implementation is thread-safe. More...
 
class  IMultiSimManager
 MultiSimManager allows to perform operation pertaining to devices which have more than one SIM/UICC card. Clients should check if the subsystem is ready before invoking any of the APIs as follows. More...
 
class  INetworkSelectionListener
 Listener class for getting network selection mode change notification. More...
 
class  INetworkSelectionManager
 Network Selection Manager class provides the interface to get and set network selection mode, preferred network list and scan available networks. More...
 
class  IOperatingModeCallback
 
class  IPhone
 This class allows getting system information and registering for system events. Each Phone instance is associated with a single SIM. So on a dual SIM device you would have 2 Phone instances. More...
 
class  IPhoneListener
 A listener class for monitoring changes in specific telephony states on the device, including service state and signal strength. Override the methods for the state that you wish to receive updates for. More...
 
class  IPhoneManager
 Phone Manager creates one or more phones based on SIM slot count, it allows clients to register for notification of system events. Clients should check if the subsystem is ready before invoking any of the APIs. More...
 
class  IRemoteSimListener
 A listener class for getting remote SIM notifications. More...
 
class  IRemoteSimManager
 IRemoteSimManager provides APIs for remote SIM related operations. This allows a device to use a SIM card on another device for its WWAN modem functionality. The SIM provider service is the endpoint that interfaces with the SIM card (e.g. over bluetooth) and sends/receives data to the other endpoint, the modem. The modem sends requests to the SIM provider service to interact with the SIM card (e.g. power up, transmit APDU, etc.), and is notified of events (e.g. card errors, resets, etc.). This API is used by the SIM provider endpoint to provide a SIM card to the modem. More...
 
class  ISapCardCommandCallback
 
class  ISapCardListener
 
class  ISapCardManager
 ISapCardManager provide APIs for SAP related operations. More...
 
class  IServingSystemListener
 Listener class for getting radio access technology mode preference change notification. More...
 
class  IServingSystemManager
 Serving System Manager class provides the API to request and set service domain preference and RAT preference. More...
 
class  ISignalStrengthCallback
 Interface for Signal strength callback object. Client needs to implement this interface to get single shot responses for commands like get signal strength. More...
 
class  ISimProfileListener
 The interface listens for profile download indication and keep track of download and install progress of profile. More...
 
class  ISimProfileManager
 ISimProfileManager is a primary interface for remote eUICCs (eSIMs or embedded SIMs) provisioning.This interface provides APIs to add, delete, set profile, update nickname, provide user consent, get Eid on the eUICC. More...
 
class  ISmscAddressCallback
 
class  ISmsListener
 A listener class for monitoring incoming SMS and notify subsystem status changes. Override the methods for the state that you wish to receive updates for. More...
 
class  ISmsManager
 SMS Manager class is the primary interface to send and receive SMS messages. It allows to send an SMS in several formats and sizes. More...
 
class  ISubscription
 Subscription returns information about network operator subscription details pertaining to a SIM card. More...
 
class  ISubscriptionListener
 A listener class for receiving device subscription information. The methods in listener can be invoked from multiple different threads. The implementation should be thread safe. More...
 
class  ISubscriptionManager
 
class  IVoiceServiceStateCallback
 Interface for voice service state callback object. Client needs to implement this interface to get single shot responses for commands like request voice radio technology. More...
 
class  LteCellIdentity
 
class  LteCellInfo
 
class  LteSignalStrengthInfo
 
struct  MessageAttributes
 Contains structure of message attributes like encoding type, number of segments, characters left in last segment. More...
 
class  Nr5gSignalStrengthInfo
 
class  OperatorInfo
 
struct  OperatorStatus
 
class  PhoneFactory
 PhoneFactory is the central factory to create all Telephony SDK Classes and services. More...
 
struct  Point
 
class  Polygon
 
struct  PreferredNetworkInfo
 
class  SignalStrength
 
class  SimProfile
 SimProfile class represents single eUICC profile on the card. More...
 
struct  SimRatCapability
 
struct  SlotStatus
 
class  SmsMessage
 A Short Message Service message. More...
 
class  TdscdmaCellIdentity
 
class  TdscdmaCellInfo
 
class  TdscdmaSignalStrengthInfo
 
class  VoiceServiceInfo
 
class  WarningAreaInfo
 
class  WcdmaCellIdentity
 
class  WcdmaCellInfo
 
class  WcdmaSignalStrengthInfo
 

Typedefs

using MakeCallCallback = std::function< void(telux::common::ErrorCode error, std::shared_ptr< ICall > call)>
 
using ECallHlapTimerStatusCallback = std::function< void(telux::common::ErrorCode error, int phoneId, ECallHlapTimerStatus timersStatus)>
 
using PinOperationResponseCb = std::function< void(int retryCount, telux::common::ErrorCode error)>
 
using QueryFdnLockResponseCb = std::function< void(bool isAvailable, bool isEnabled, telux::common::ErrorCode error)>
 
using QueryPin1LockResponseCb = std::function< void(bool state, telux::common::ErrorCode error)>
 
using EidResponseCallback = std::function< void(const std::string &eid, telux::common::ErrorCode error)>
 
using RequestFiltersResponseCallback = std::function< void(std::vector< CellBroadcastFilter > filters, telux::common::ErrorCode error)>
 
using RequestActivationStatusResponseCallback = std::function< void(bool isActivated, telux::common::ErrorCode error)>
 
using HighCapabilityCallback = std::function< void(int slotId, telux::common::ErrorCode error)>
 
using SlotStatusCallback = std::function< void(std::map< SlotId, SlotStatus > slotStatus, telux::common::ErrorCode error)>
 
using RatMask = std::bitset< 16 >
 
using SelectionModeResponseCallback = std::function< void(NetworkSelectionMode mode, telux::common::ErrorCode error)>
 
using PreferredNetworksCallback = std::function< void(std::vector< PreferredNetworkInfo > info, std::vector< PreferredNetworkInfo > staticInfo, telux::common::ErrorCode error)>
 
using NetworkScanCallback = std::function< void(std::vector< OperatorInfo > operatorInfos, telux::common::ErrorCode error)>
 
using VoiceRadioTechResponseCb = std::function< void(telux::tel::RadioTechnology radioTech, telux::common::ErrorCode error)>
 
using CellInfoCallback = std::function< void(std::vector< std::shared_ptr< CellInfo >> cellInfoList, telux::common::ErrorCode error)>
 
using ECallGetOperatingModeCallback = std::function< void(ECallMode eCallMode, telux::common::ErrorCode error)>
 
using RATCapabilitiesMask = std::bitset< 16 >
 
using VoiceServiceTechnologiesMask = std::bitset< 16 >
 
using SapStateResponseCallback = std::function< void(SapState sapState, telux::common::ErrorCode error)>
 
using RatPreference = std::bitset< 16 >
 
using RatPreferenceCallback = std::function< void(RatPreference preference, telux::common::ErrorCode error)>
 
using ServiceDomainPreferenceCallback = std::function< void(ServiceDomainPreference preference, telux::common::ErrorCode error)>
 
using PolicyRuleMask = std::bitset< 16 >
 
using ProfileListResponseCb = std::function< void(const std::vector< std::shared_ptr< SimProfile >> &profiles, telux::common::ErrorCode error)>
 
using EidResponseCb = std::function< void(std::string eid, telux::common::ErrorCode error)>
 

Enumerations

enum  CardState {
  CardState::CARDSTATE_UNKNOWN = -1, CardState::CARDSTATE_ABSENT = 0, CardState::CARDSTATE_PRESENT = 1, CardState::CARDSTATE_ERROR = 2,
  CardState::CARDSTATE_RESTRICTED = 3
}
 
enum  CardError {
  CardError::UNKNOWN, CardError::POWER_DOWN, CardError::POLL_ERROR, CardError::NO_ATR_RECEIVED,
  CardError::VOLT_MISMATCH, CardError::PARITY_ERROR, CardError::POSSIBLY_REMOVED, CardError::TECHNICAL_PROBLEMS,
  CardError::NULL_BYTES, CardError::SAP_CONNECTED, CardError::CMD_TIMEOUT
}
 
enum  CardLockType {
  CardLockType::PIN1 = 0, CardLockType::PIN2 = 1, CardLockType::PUK1 = 2, CardLockType::PUK2 = 3,
  CardLockType::FDN = 4
}
 
enum  AppType {
  APPTYPE_UNKNOWN = 0, APPTYPE_SIM = 1, APPTYPE_USIM = 2, APPTYPE_RUIM = 3,
  APPTYPE_CSIM = 4, APPTYPE_ISIM = 5
}
 
enum  AppState {
  APPSTATE_UNKNOWN = 0, APPSTATE_DETECTED = 1, APPSTATE_PIN = 2, APPSTATE_PUK = 3,
  APPSTATE_SUBSCRIPTION_PERSO = 4, APPSTATE_READY = 5
}
 
enum  GeographicalScope { GeographicalScope::CELL_WIDE_IMMEDIATE = 0, GeographicalScope::PLMN_WIDE = 1, GeographicalScope::LA_WIDE = 2, GeographicalScope::CELL_WIDE = 3 }
 
enum  MessagePriority { MessagePriority::UNKNOWN = -1, MessagePriority::NORMAL = 0, MessagePriority::EMERGENCY = 1 }
 
enum  MessageType { MessageType::UNKNOWN = -1, MessageType::ETWS = 0, MessageType::CMAS = 1 }
 
enum  EtwsWarningType {
  EtwsWarningType::UNKNOWN = -1, EtwsWarningType::EARTHQUAKE = 0, EtwsWarningType::TSUNAMI = 1, EtwsWarningType::EARTHQUAKE_AND_TSUNAMI = 2,
  EtwsWarningType::TEST_MESSAGE = 3, EtwsWarningType::OTHER_EMERGENCY = 4
}
 
enum  CmasMessageClass {
  CmasMessageClass::UNKNOWN = -1, CmasMessageClass::PRESIDENTIAL_LEVEL_ALERT = 0, CmasMessageClass::EXTREME_THREAT = 1, CmasMessageClass::SEVERE_THREAT = 2,
  CmasMessageClass::CHILD_ABDUCTION_EMERGENCY = 3, CmasMessageClass::REQUIRED_MONTHLY_TEST = 4, CmasMessageClass::CMAS_EXERCISE = 5, CmasMessageClass::OPERATOR_DEFINED_USE = 6
}
 
enum  CmasSeverity { CmasSeverity::UNKNOWN = -1, CmasSeverity::EXTREME = 0, CmasSeverity::SEVERE = 1 }
 
enum  CmasUrgency { CmasUrgency::UNKNOWN = -1, CmasUrgency::IMMEDIATE = 0, CmasUrgency::EXPECTED = 1 }
 
enum  CmasCertainty { CmasCertainty::UNKNOWN = -1, CmasCertainty::OBSERVED = 0, CmasCertainty::LIKELY = 1 }
 
enum  GeometryType { GeometryType::UNKNOWN = -1, GeometryType::POLYGON = 0, GeometryType::CIRCLE = 1 }
 
enum  CellType {
  GSM = 1, CellType::CDMA = 2, LTE = 3, CellType::WCDMA = 4,
  CellType::TDSCDMA = 5
}
 
enum  ECallVariant { ECallVariant::ECALL_TEST = 1, ECallVariant::ECALL_EMERGENCY = 2, ECallVariant::ECALL_VOICE = 4 }
 
enum  EmergencyCallType { EmergencyCallType::CALL_TYPE_ECALL = 12 }
 
enum  ECallMsdTransmissionStatus {
  ECallMsdTransmissionStatus::SUCCESS = 0, ECallMsdTransmissionStatus::FAILURE = 1, ECallMsdTransmissionStatus::MSD_TRANSMISSION_STARTED = 2, ECallMsdTransmissionStatus::NACK_OUT_OF_ORDER = 3,
  ECallMsdTransmissionStatus::ACK_OUT_OF_ORDER = 4, ECallMsdTransmissionStatus::START_RECEIVED = 5, ECallMsdTransmissionStatus::LL_ACK_RECEIVED = 6, ECallMsdTransmissionStatus::OUTBAND_MSD_TRANSMISSION_STARTED = 10,
  ECallMsdTransmissionStatus::OUTBAND_MSD_TRANSMISSION_SUCCESS = 11, ECallMsdTransmissionStatus::OUTBAND_MSD_TRANSMISSION_FAILURE = 12
}
 
enum  ECallCategory { ECallCategory::VOICE_EMER_CAT_AUTO_ECALL = 64, ECallCategory::VOICE_EMER_CAT_MANUAL = 32 }
 
enum  ECallVehicleType {
  PASSENGER_VEHICLE_CLASS_M1, BUSES_AND_COACHES_CLASS_M2, BUSES_AND_COACHES_CLASS_M3, LIGHT_COMMERCIAL_VEHICLES_CLASS_N1,
  HEAVY_DUTY_VEHICLES_CLASS_N2, HEAVY_DUTY_VEHICLES_CLASS_N3, MOTOR_CYCLES_CLASS_L1E, MOTOR_CYCLES_CLASS_L2E,
  MOTOR_CYCLES_CLASS_L3E, MOTOR_CYCLES_CLASS_L4E, MOTOR_CYCLES_CLASS_L5E, MOTOR_CYCLES_CLASS_L6E,
  MOTOR_CYCLES_CLASS_L7E
}
 
enum  ECallOptionalDataType { ECallOptionalDataType::ECALL_DEFAULT }
 
enum  ECallMode { ECallMode::NORMAL = 0, ECallMode::ECALL_ONLY = 1, ECallMode::NONE = 2 }
 
enum  ECallModeReason { ECallModeReason::NORMAL = 0, ECallModeReason::ERA_GLONASS = 1 }
 
enum  HlapTimerStatus { HlapTimerStatus::UNKNOWN = -1, HlapTimerStatus::INACTIVE, HlapTimerStatus::ACTIVE }
 
enum  HlapTimerEvent {
  HlapTimerEvent::UNKNOWN = -1, HlapTimerEvent::UNCHANGED, HlapTimerEvent::STARTED, HlapTimerEvent::STOPPED,
  HlapTimerEvent::EXPIRED
}
 
enum  SlotState { SlotState::UNKNOWN = -1, SlotState::INACTIVE, SlotState::ACTIVE }
 
enum  RatType {
  UMTS = 15, LTE = 14, LTE = 3, GSM = 7,
  GSM = 1, NR5G = 11
}
 
enum  NetworkScanStatus { NetworkScanStatus::COMPLETE = 0, NetworkScanStatus::PARTIAL = 1, NetworkScanStatus::FAILED = 2 }
 
enum  NetworkSelectionMode { NetworkSelectionMode::UNKNOWN = -1, NetworkSelectionMode::AUTOMATIC = 0, NetworkSelectionMode::MANUAL = 1 }
 
enum  InUseStatus { InUseStatus::UNKNOWN, InUseStatus::CURRENT_SERVING, InUseStatus::AVAILABLE }
 
enum  RoamingStatus { RoamingStatus::UNKNOWN, RoamingStatus::HOME, RoamingStatus::ROAM }
 
enum  ForbiddenStatus { ForbiddenStatus::UNKNOWN, ForbiddenStatus::FORBIDDEN, ForbiddenStatus::NOT_FORBIDDEN }
 
enum  PreferredStatus { PreferredStatus::UNKNOWN, PreferredStatus::PREFERRED, PreferredStatus::NOT_PREFERRED }
 
enum  CallDirection { CallDirection::INCOMING, CallDirection::OUTGOING, CallDirection::NONE }
 
enum  CallState {
  CallState::CALL_IDLE = -1, CallState::CALL_ACTIVE, CallState::CALL_ON_HOLD, CallState::CALL_DIALING,
  CallState::CALL_INCOMING, CallState::CALL_WAITING, CallState::CALL_ALERTING, CallState::CALL_ENDED
}
 
enum  CallEndCause {
  CallEndCause::UNOBTAINABLE_NUMBER = 1, CallEndCause::NO_ROUTE_TO_DESTINATION = 3, CallEndCause::CHANNEL_UNACCEPTABLE = 6, CallEndCause::OPERATOR_DETERMINED_BARRING = 8,
  CallEndCause::NORMAL = 16, CallEndCause::BUSY = 17, CallEndCause::NO_USER_RESPONDING = 18, CallEndCause::NO_ANSWER_FROM_USER = 19,
  CallEndCause::CALL_REJECTED = 21, CallEndCause::NUMBER_CHANGED = 22, CallEndCause::PREEMPTION = 25, CallEndCause::DESTINATION_OUT_OF_ORDER = 27,
  CallEndCause::INVALID_NUMBER_FORMAT = 28, CallEndCause::FACILITY_REJECTED = 29, CallEndCause::RESP_TO_STATUS_ENQUIRY = 30, CallEndCause::NORMAL_UNSPECIFIED = 31,
  CallEndCause::CONGESTION = 34, CallEndCause::NETWORK_OUT_OF_ORDER = 38, CallEndCause::TEMPORARY_FAILURE = 41, CallEndCause::SWITCHING_EQUIPMENT_CONGESTION = 42,
  CallEndCause::ACCESS_INFORMATION_DISCARDED = 43, CallEndCause::REQUESTED_CIRCUIT_OR_CHANNEL_NOT_AVAILABLE = 44, CallEndCause::RESOURCES_UNAVAILABLE_OR_UNSPECIFIED = 47, CallEndCause::QOS_UNAVAILABLE = 49,
  CallEndCause::REQUESTED_FACILITY_NOT_SUBSCRIBED = 50, CallEndCause::INCOMING_CALLS_BARRED_WITHIN_CUG = 55, CallEndCause::BEARER_CAPABILITY_NOT_AUTHORIZED = 57, CallEndCause::BEARER_CAPABILITY_UNAVAILABLE = 58,
  CallEndCause::SERVICE_OPTION_NOT_AVAILABLE = 63, CallEndCause::BEARER_SERVICE_NOT_IMPLEMENTED = 65, CallEndCause::ACM_LIMIT_EXCEEDED = 68, CallEndCause::REQUESTED_FACILITY_NOT_IMPLEMENTED = 69,
  CallEndCause::ONLY_DIGITAL_INFORMATION_BEARER_AVAILABLE = 70, CallEndCause::SERVICE_OR_OPTION_NOT_IMPLEMENTED = 79, CallEndCause::INVALID_TRANSACTION_IDENTIFIER = 81, CallEndCause::USER_NOT_MEMBER_OF_CUG = 87,
  CallEndCause::INCOMPATIBLE_DESTINATION = 88, CallEndCause::INVALID_TRANSIT_NW_SELECTION = 91, CallEndCause::SEMANTICALLY_INCORRECT_MESSAGE = 95, CallEndCause::INVALID_MANDATORY_INFORMATION = 96,
  CallEndCause::MESSAGE_TYPE_NON_IMPLEMENTED = 97, CallEndCause::MESSAGE_TYPE_NOT_COMPATIBLE_WITH_PROTOCOL_STATE = 98, CallEndCause::INFORMATION_ELEMENT_NON_EXISTENT = 99, CallEndCause::CONDITIONAL_IE_ERROR = 100,
  CallEndCause::MESSAGE_NOT_COMPATIBLE_WITH_PROTOCOL_STATE = 101, CallEndCause::RECOVERY_ON_TIMER_EXPIRED = 102, CallEndCause::PROTOCOL_ERROR_UNSPECIFIED = 111, CallEndCause::INTERWORKING_UNSPECIFIED = 127,
  CallEndCause::CALL_BARRED = 240, CallEndCause::FDN_BLOCKED = 241, CallEndCause::IMSI_UNKNOWN_IN_VLR = 242, CallEndCause::IMEI_NOT_ACCEPTED = 243,
  CallEndCause::DIAL_MODIFIED_TO_USSD = 244, CallEndCause::DIAL_MODIFIED_TO_SS = 245, CallEndCause::DIAL_MODIFIED_TO_DIAL = 246, CallEndCause::CDMA_LOCKED_UNTIL_POWER_CYCLE = 1000,
  CallEndCause::CDMA_DROP = 1001, CallEndCause::CDMA_INTERCEPT = 1002, CallEndCause::CDMA_REORDER = 1003, CallEndCause::CDMA_SO_REJECT = 1004,
  CallEndCause::CDMA_RETRY_ORDER = 1005, CallEndCause::CDMA_ACCESS_FAILURE = 1006, CallEndCause::CDMA_PREEMPTED = 1007, CallEndCause::CDMA_NOT_EMERGENCY = 1008,
  CallEndCause::CDMA_ACCESS_BLOCKED = 1009, CallEndCause::ERROR_UNSPECIFIED = 0xffff
}
 
enum  RadioState { RadioState::RADIO_STATE_OFF = 0, RadioState::RADIO_STATE_UNAVAILABLE = 1, RadioState::RADIO_STATE_ON = 10 }
 
enum  ServiceState { ServiceState::EMERGENCY_ONLY, ServiceState::IN_SERVICE, ServiceState::OUT_OF_SERVICE, ServiceState::RADIO_OFF }
 
enum  RadioTechnology {
  RadioTechnology::RADIO_TECH_UNKNOWN, RadioTechnology::RADIO_TECH_GPRS, RadioTechnology::RADIO_TECH_EDGE, RadioTechnology::RADIO_TECH_UMTS,
  RadioTechnology::RADIO_TECH_IS95A, RadioTechnology::RADIO_TECH_IS95B, RadioTechnology::RADIO_TECH_1xRTT, RadioTechnology::RADIO_TECH_EVDO_0,
  RadioTechnology::RADIO_TECH_EVDO_A, RadioTechnology::RADIO_TECH_HSDPA, RadioTechnology::RADIO_TECH_HSUPA, RadioTechnology::RADIO_TECH_HSPA,
  RadioTechnology::RADIO_TECH_EVDO_B, RadioTechnology::RADIO_TECH_EHRPD, RadioTechnology::RADIO_TECH_LTE, RadioTechnology::RADIO_TECH_HSPAP,
  RadioTechnology::RADIO_TECH_GSM, RadioTechnology::RADIO_TECH_TD_SCDMA, RadioTechnology::RADIO_TECH_IWLAN, RadioTechnology::RADIO_TECH_LTE_CA,
  RadioTechnology::RADIO_TECH_NR5G
}
 
enum  RATCapability {
  RATCapability::AMPS, RATCapability::CDMA, RATCapability::HDR, RATCapability::GSM,
  RATCapability::WCDMA, RATCapability::LTE, RATCapability::TDS
}
 
enum  VoiceServiceTechnology { VoiceServiceTechnology::VOICE_TECH_GW_CSFB, VoiceServiceTechnology::VOICE_TECH_1x_CSFB, VoiceServiceTechnology::VOICE_TECH_VOLTE }
 
enum  OperatingMode {
  OperatingMode::ONLINE = 0, OperatingMode::AIRPLANE, OperatingMode::FACTORY_TEST, OperatingMode::OFFLINE,
  OperatingMode::RESETTING, OperatingMode::SHUTTING_DOWN, OperatingMode::PERSISTENT_LOW_POWER
}
 
enum  CardErrorCause {
  CardErrorCause::INVALID = -1, CardErrorCause::UNKNOWN_ERROR = 0, CardErrorCause::NO_LINK_ESTABLISHED = 1, CardErrorCause::COMMAND_TIMEOUT = 2,
  CardErrorCause::POWER_DOWN = 3
}
 
enum  SapState {
  SapState::SAP_STATE_NOT_ENABLED = 0x00, SapState::SAP_STATE_CONNECTING = 0x01, SapState::SAP_STATE_CONNECTED_SUCCESSFULLY = 0x02, SapState::SAP_STATE_CONNECTION_ERROR = 0x03,
  SapState::SAP_STATE_DISCONNECTING = 0x04, SapState::SAP_STATE_DISCONNECTED_SUCCESSFULLY = 0x05
}
 
enum  SapCondition { SapCondition::SAP_CONDITION_BLOCK_VOICE_OR_DATA = 0x00, SapCondition::SAP_CONDITION_BLOCK_DATA = 0x01, SapCondition::SAP_CONDITION_BLOCK_VOICE = 0x02, SapCondition::SAP_CONDITION_BLOCK_NONE = 0x03 }
 
enum  ServiceDomainPreference { ServiceDomainPreference::UNKNOWN = -1, ServiceDomainPreference::CS_ONLY, ServiceDomainPreference::PS_ONLY, ServiceDomainPreference::CS_PS }
 
enum  RatPrefType {
  PREF_CDMA_1X, PREF_CDMA_EVDO, PREF_GSM, PREF_WCDMA,
  PREF_LTE, PREF_TDSCDMA, PREF_NR5G
}
 
enum  EndcAvailability { EndcAvailability::UNKNOWN = -1, EndcAvailability::AVAILABLE, EndcAvailability::UNAVAILABLE }
 
enum  DcnrRestriction { DcnrRestriction::UNKNOWN = -1, DcnrRestriction::RESTRICTED, DcnrRestriction::UNRESTRICTED }
 
enum  SignalStrengthLevel {
  SignalStrengthLevel::LEVEL_1, SignalStrengthLevel::LEVEL_2, SignalStrengthLevel::LEVEL_3, SignalStrengthLevel::LEVEL_4,
  SignalStrengthLevel::LEVEL_5, SignalStrengthLevel::LEVEL_UNKNOWN = -1
}
 
enum  ProfileType { ProfileType::UNKNOWN = -1, ProfileType::REGULAR = 0, ProfileType::EMERGENCY }
 
enum  IconType { IconType::NONE = 0, IconType::JPEG, IconType::PNG }
 
enum  ProfileClass { ProfileClass::UNKNOWN = -1, ProfileClass::TEST = 0, ProfileClass::PROVISIONING, ProfileClass::OPERATIONAL }
 
enum  DownloadStatus {
  DownloadStatus::DOWNLOAD_ERROR = 1, DownloadStatus::DOWNLOAD_IN_PROGRESS, DownloadStatus::DOWNLOAD_COMPLETE_INSTALLATION_IN_PROGRESS, DownloadStatus::INSTALLATION_COMPLETE,
  DownloadStatus::USER_CONSENT_REQUIRED
}
 
enum  DownloadErrorCause { DownloadErrorCause::GENERIC = 1, DownloadErrorCause::SIM, DownloadErrorCause::NETWORK, DownloadErrorCause::MEMORY }
 
enum  PolicyRuleType { PROFILE_DISABLE_NOT_ALLOWED = (1 << 0), PROFILE_DELETE_NOT_ALLOWED = (1 << 1), PROFILE_DELETE_ON_DISABLE = (1 << 2) }
 
enum  SmsEncoding { SmsEncoding::GSM7, SmsEncoding::GSM8, SmsEncoding::UCS2, SmsEncoding::UNKNOWN }
 Specifies the encoding of the SMS message. More...
 
enum  VoiceServiceState {
  VoiceServiceState::NOT_REG_AND_NOT_SEARCHING = 0, VoiceServiceState::REG_HOME = 1, VoiceServiceState::NOT_REG_AND_SEARCHING = 2, VoiceServiceState::REG_DENIED = 3,
  VoiceServiceState::UNKNOWN = 4, VoiceServiceState::REG_ROAMING = 5, VoiceServiceState::NOT_REG_AND_EMERGENCY_AVAILABLE_AND_NOT_SEARCHING = 10, VoiceServiceState::NOT_REG_AND_EMERGENCY_AVAILABLE_AND_SEARCHING = 12,
  VoiceServiceState::REG_DENIED_AND_EMERGENCY_AVAILABLE = 13, VoiceServiceState::UNKNOWN_AND_EMERGENCY_AVAILABLE = 14
}
 
enum  VoiceServiceDenialCause {
  VoiceServiceDenialCause::UNDEFINED = -1, VoiceServiceDenialCause::GENERAL = 0, VoiceServiceDenialCause::AUTH_FAILURE = 1, VoiceServiceDenialCause::IMSI_UNKNOWN = 2,
  VoiceServiceDenialCause::ILLEGAL_MS = 3, VoiceServiceDenialCause::IMSI_UNKNOWN_VLR = 4, VoiceServiceDenialCause::IMEI_NOT_ACCEPTED = 5, VoiceServiceDenialCause::ILLEGAL_ME = 6,
  VoiceServiceDenialCause::GPRS_SERVICES_NOT_ALLOWED = 7, VoiceServiceDenialCause::GPRS_NON_GPRS_NOT_ALLOWED = 8, VoiceServiceDenialCause::MS_IDENTITY_FAILED = 9, VoiceServiceDenialCause::IMPLICITLY_DETACHED = 10,
  VoiceServiceDenialCause::GPRS_NOT_ALLOWED_IN_PLMN = 14, VoiceServiceDenialCause::MSC_TEMPORARILY_NOT_REACHABLE = 16, VoiceServiceDenialCause::SMS_PROVIDED_VIA_GPRS = 28, VoiceServiceDenialCause::NO_PDP_CONTEXT_ACTIVATED = 40,
  VoiceServiceDenialCause::PLMN_NOT_ALLOWED = 11, VoiceServiceDenialCause::LOCATION_AREA_NOT_ALLOWED = 12, VoiceServiceDenialCause::ROAMING_NOT_ALLOWED = 13, VoiceServiceDenialCause::NO_SUITABLE_CELLS = 15,
  VoiceServiceDenialCause::NOT_AUTHORIZED = 25, VoiceServiceDenialCause::NETWORK_FAILURE = 17, VoiceServiceDenialCause::MAC_FAILURE = 20, VoiceServiceDenialCause::SYNC_FAILURE = 21,
  VoiceServiceDenialCause::CONGESTION = 22, VoiceServiceDenialCause::GSM_AUTHENTICATION_UNACCEPTABLE = 23, VoiceServiceDenialCause::SERVICE_OPTION_NOT_SUPPORTED = 32, VoiceServiceDenialCause::SERVICE_OPTION_NOT_SUBCRIBED = 33,
  VoiceServiceDenialCause::SERVICE_OPTION_OUT_OF_ORDER = 34, VoiceServiceDenialCause::CALL_NOT_IDENTIFIED = 38, VoiceServiceDenialCause::RETRY_FOR_NEW_CELL = 48, VoiceServiceDenialCause::INCORRECT_MESSAGE = 95,
  VoiceServiceDenialCause::INVALID_INFO = 96, VoiceServiceDenialCause::MSG_TYPE_NOT_IMPLEMENTED = 97, VoiceServiceDenialCause::MSG_NOT_COMPATIBLE = 98, VoiceServiceDenialCause::INFO_NOT_IMPLEMENTED = 99,
  VoiceServiceDenialCause::CONDITIONAL_IE_ERROR = 100, VoiceServiceDenialCause::PROTOCOL_ERROR_UNSPECIFIED = 111
}
 

Data Structure Documentation

struct telux::tel::Point

Point represented by latitude and longitude.

Data Fields
double latitude
double longitude

Typedef Documentation

using telux::tel::MakeCallCallback = typedef std::function<void(telux::common::ErrorCode error, std::shared_ptr<ICall> call)>

This function is called with the response to make normal call and emergency call.

The callback can be invoked from multiple different threads. The implementation should be thread safe.

Parameters
[out]errorErrorCode
[out]callPointer to Call object or nullptr in case of failure
using telux::tel::ECallHlapTimerStatusCallback = typedef std::function<void(telux::common::ErrorCode error, int phoneId, ECallHlapTimerStatus timersStatus)>

This function is called with response to request for eCall High Level Application Protocol(HLAP) timers status.

The callback can be invoked from multiple different threads. The implementation should be thread safe.

Parameters
[out]errorErrorCode
[out]phoneIdRepresents the phone corresponding to which the response is being reported.
[out]timersStatusECallHlapTimerStatus
using telux::tel::PinOperationResponseCb = typedef std::function<void(int retryCount, telux::common::ErrorCode error)>

This function is called with the response to pin operations like change pin password, unlock card and set card lock.

Parameters
[in]retryCountNo of retry attempts left
[in]errorReturn code for whether the operation succeeded or failed
using telux::tel::QueryFdnLockResponseCb = typedef std::function<void(bool isAvailable, bool isEnabled, telux::common::ErrorCode error)>

This function is called with the response to queryFdnLockState API.

Parameters
[in]isAvailableDetermine FDN lock state availability
[in]isEnabledDetermine FDN lock state i.e enable or disable
[in]errorReturn code for whether the operation succeeded or failed
using telux::tel::QueryPin1LockResponseCb = typedef std::function<void(bool state, telux::common::ErrorCode error)>

This function is called with the response to queryPin1LockState API.

Parameters
[in]stateDetermine state whether enabled or disabled
[in]errorReturn code for whether the operation succeeded or failed
using telux::tel::EidResponseCallback = typedef std::function<void(const std::string &eid, telux::common::ErrorCode error)>

This function is called with the response to requestEid API.

The callback can be invoked from multiple different threads. The implementation should be thread safe.

Parameters
[in]eideUICC identifier.
[in]errorReturn code which indicates whether the operation succeeded or not. ErrorCode
using telux::tel::RequestFiltersResponseCallback = typedef std::function<void(std::vector<CellBroadcastFilter> filters, telux::common::ErrorCode error)>

This function is called with the response to requestMessageIdFilters API.

The callback can be invoked from multiple different threads. The implementation should be thread safe.

Parameters
[in]filtersList of broadcast filters CellBroadcastFilter
[in]errorReturn code which indicates whether the operation succeeded or not ErrorCode
using telux::tel::RequestActivationStatusResponseCallback = typedef std::function<void(bool isActivated, telux::common::ErrorCode error)>

This function is called with the response to requestActivationStatus API.

The callback can be invoked from multiple different threads. The implementation should be thread safe.

Parameters
[in]isActivatedIf true then filters are activated else filters are deactivated
[in]errorReturn code which indicates whether the operation succeeded or not ErrorCode
using telux::tel::HighCapabilityCallback = typedef std::function<void(int slotId, telux::common::ErrorCode error)>

This function is called in the response to requestHighCapability API.

The callback can be invoked from multiple different threads. The implementation should be thread safe.

Parameters
[in]slotIdSIM corresponding to slot identifier has high capability.
[in]errorReturn code which indicates whether the operation succeeded or not ErrorCode
using telux::tel::SlotStatusCallback = typedef std::function<void(std::map<SlotId, SlotStatus> slotStatus, telux::common::ErrorCode error)>

This function is called in response to requestSlotStatus API.

The callback can be invoked from multiple different threads. The implementation should be thread safe.

Parameters
[in]slotStatuslist of slots status SlotStatus
[in]errorReturn code which indicates whether the operation succeeded or not ErrorCode
using telux::tel::RatMask = typedef std::bitset<16>

16 bit mask that denotes which of the radio access technologies defined in RatType enum are used for preferred networks.

This function is called with the response to requestNetworkSelectionMode API.

The callback can be invoked from multiple different threads. The implementation should be thread safe.

Parameters
[in]modeNetworkSelectionMode
[in]errorReturn code which indicates whether the operation succeeded or not ErrorCode
using telux::tel::PreferredNetworksCallback = typedef std::function<void(std::vector<PreferredNetworkInfo> info, std::vector<PreferredNetworkInfo> staticInfo, telux::common::ErrorCode error)>

This function is called with the response to requestPreferredNetworks API.

The callback can be invoked from multiple different threads. The implementation should be thread safe.

Parameters
[in]info3GPP preferred networks list i.e PLMN list.
[in]staticInfoStatic 3GPP preferred networks list i.e OPLMN list.
[in]errorReturn code which indicates whether the operation succeeded or not. ErrorCode
using telux::tel::NetworkScanCallback = typedef std::function<void(std::vector<OperatorInfo> operatorInfos, telux::common::ErrorCode error)>

This function is called with the response to performNetworkScan API.

The callback can be invoked from multiple different threads. The implementation should be thread safe.

Parameters
[in]operatorInfosOperators info with details of network operator name, MCC, MNC and status.
[in]errorReturn code which indicates whether the operation succeeded or not. ErrorCode
using telux::tel::VoiceRadioTechResponseCb = typedef std::function<void(telux::tel::RadioTechnology radioTech, telux::common::ErrorCode error)>

This function is called with the response to requestVoiceRadioTechnology API.

The callback can be invoked from multiple different threads. The implementation should be thread safe.

Parameters
[in]radioTechPointer to radio technology
[in]errorReturn code for whether the operation succeeded or failed
using telux::tel::CellInfoCallback = typedef std::function<void(std::vector<std::shared_ptr<CellInfo>> cellInfoList, telux::common::ErrorCode error)>

This function is called with the response to requestCellInfo API.

The callback can be invoked from multiple different threads. The implementation should be thread safe.

Parameters
[out]cellInfoListvector of shared pointers to cell info object
[out]errorReturn code for whether the operation succeeded or failed
using telux::tel::ECallGetOperatingModeCallback = typedef std::function<void(ECallMode eCallMode, telux::common::ErrorCode error)>

This function is called with the response to requestECallOperatingMode API.

The callback can be invoked from multiple different threads. The implementation should be thread safe.

Parameters
[out]eCallModeECallMode
[out]errorReturn code for whether the operation succeeded or failed
using telux::tel::RATCapabilitiesMask = typedef std::bitset<16>
using telux::tel::VoiceServiceTechnologiesMask = typedef std::bitset<16>
using telux::tel::SapStateResponseCallback = typedef std::function<void(SapState sapState, telux::common::ErrorCode error)>

This function is called with the response to requestSapState API.

The callback can be invoked from multiple different threads. The implementation should be thread safe.

Parameters
[in]sapStateSapState of SIM access profile (SAP) connection
[in]errorReturn code for whether the operation succeeded or failed
using telux::tel::RatPreference = typedef std::bitset<16>

16 bit mask that denotes which of the radio access technology mode preference defined in RatPrefType enum are used to set or get RAT preference.

using telux::tel::RatPreferenceCallback = typedef std::function<void(RatPreference preference, telux::common::ErrorCode error)>

This function is called with the response to requestRatPreference API.

The callback can be invoked from multiple different threads. The implementation should be thread safe.

Parameters
[in]preferenceRatPreference
[in]errorReturn code which indicates whether the operation succeeded or not ErrorCode

This function is called with the response to requestServiceDomainPreference API.

The callback can be invoked from multiple different threads. The implementation should be thread safe.

Parameters
[in]preferenceServiceDomainPreference
[in]errorReturn code which indicates whether the operation succeeded or not ErrorCode
using telux::tel::ProfileListResponseCb = typedef std::function<void( const std::vector<std::shared_ptr<SimProfile>> &profiles, telux::common::ErrorCode error)>

This function is called with the response to requestProfileList API.

The callback can be invoked from multiple different threads. The implementation should be thread safe.

Parameters
[in]infoProfiles information SimProfile.
[in]errorReturn code which indicates whether the operation succeeded or not. ErrorCode.
using telux::tel::EidResponseCb = typedef std::function<void(std::string eid, telux::common::ErrorCode error)>

This function is called with the response to requestEid API.

The callback can be invoked from multiple different threads. The implementation should be thread safe.

Parameters
[in]eideUICC identifier.
[in]errorReturn code which indicates whether the operation succeeded or not. ErrorCode.