ConnectionService

Kotlin |Java

abstract class ConnectionService : Service

kotlin.Any
↳	android.content.Context
	↳	android.content.ContextWrapper
		↳	android.app.Service
			↳	android.telecom.ConnectionService

An abstract service that should be implemented by any apps which either:

Can make phone calls (VoIP or otherwise) and want those calls to be integrated into the built-in phone app. Referred to as a system managed ConnectionService.
Are a standalone calling app and don't want their calls to be integrated into the built-in phone app. Referred to as a self managed ConnectionService.

Once implemented, the ConnectionService needs to take the following steps so that Telecom will bind to it:

1. Registration in AndroidManifest.xml

<service android:name="com.example.package.MyConnectionService"
     android:label="@string/some_label_for_my_connection_service"
     android:permission="android.permission.BIND_TELECOM_CONNECTION_SERVICE">
   <intent-filter>
    <action android:name="android.telecom.ConnectionService" />
   </intent-filter>
  </service>

2. Registration of PhoneAccount with TelecomManager.
See PhoneAccount and TelecomManager#registerPhoneAccount for more information.

System managed ConnectionServices must be enabled by the user in the phone app settings before Telecom will bind to them. Self-managed ConnectionServices must be granted the appropriate permission before Telecom will bind to them.

Once registered and enabled by the user in the phone app settings or granted permission, telecom will bind to a ConnectionService implementation when it wants that ConnectionService to place a call or the service has indicated that is has an incoming call through TelecomManager#addNewIncomingCall. The ConnectionService can then expect a call to onCreateIncomingConnection or onCreateOutgoingConnection wherein it should provide a new instance of a Connection object. It is through this Connection object that telecom receives state updates and the ConnectionService receives call-commands such as answer, reject, hold and disconnect.

When there are no more live calls, telecom will unbind from the ConnectionService.

Summary

Constants
static String	`SERVICE_INTERFACE` The `Intent` that must be declared as handled by the service.

Inherited constants

From class Context

`String`	`ACCESSIBILITY_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.view.accessibility.AccessibilityManager` for giving the user feedback for UI events through the registered event listeners.
`String`	`ACCOUNT_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.accounts.AccountManager` for receiving intents at a time of your choosing.
`String`	`ACTIVITY_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.app.ActivityManager` for interacting with the global system state.
`String`	`ALARM_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.app.AlarmManager` for receiving intents at a time of your choosing.
`String`	`APPWIDGET_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.appwidget.AppWidgetManager` for accessing AppWidgets.
`String`	`APP_OPS_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.app.AppOpsManager` for tracking application operations on the device.
`String`	`AUDIO_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.media.AudioManager` for handling management of volume, ringer modes and audio routing.
`String`	`BATTERY_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.os.BatteryManager` for managing battery state.
`Int`	`BIND_ABOVE_CLIENT` Flag for `bindService`: indicates that the client application binding to this service considers the service to be more important than the app itself. When set, the platform will try to have the out of memory killer kill the app before it kills the service it is bound to, though this is not guaranteed to be the case.
`Int`	`BIND_ADJUST_WITH_ACTIVITY` Flag for `bindService`: If binding from an activity, allow the target service's process importance to be raised based on whether the activity is visible to the user, regardless whether another flag is used to reduce the amount that the client process's overall importance is used to impact it.
`Int`	`BIND_ALLOW_OOM_MANAGEMENT` Flag for `bindService`: allow the process hosting the bound service to go through its normal memory management. It will be treated more like a running service, allowing the system to (temporarily) expunge the process if low on memory or for some other whim it may have, and being more aggressive about making it a candidate to be killed (and restarted) if running for a long time.
`Int`	`BIND_AUTO_CREATE` Flag for `bindService`: automatically create the service as long as the binding exists. Note that while this will create the service, its `android.app.Service#onStartCommand` method will still only be called due to an explicit call to `startService`. Even without that, though, this still provides you with access to the service object while the service is created. Note that prior to `android.os.Build.VERSION_CODES#ICE_CREAM_SANDWICH`, not supplying this flag would also impact how important the system consider's the target service's process to be. When set, the only way for it to be raised was by binding from a service in which case it will only be important when that activity is in the foreground. Now to achieve this behavior you must explicitly supply the new flag `BIND_ADJUST_WITH_ACTIVITY`. For compatibility, old applications that don't specify `BIND_AUTO_CREATE` will automatically have the flags `BIND_WAIVE_PRIORITY` and `BIND_ADJUST_WITH_ACTIVITY` set for them in order to achieve the same result.
`Int`	`BIND_DEBUG_UNBIND` Flag for `bindService`: include debugging help for mismatched calls to unbind. When this flag is set, the callstack of the following `unbindService` call is retained, to be printed if a later incorrect unbind call is made. Note that doing this requires retaining information about the binding that was made for the lifetime of the app, resulting in a leak -- this should only be used for debugging.
`Int`	`BIND_EXTERNAL_SERVICE` Flag for `bindService`: The service being bound is an `isolated`, `external` service. This binds the service into the calling application's package, rather than the package in which the service is declared. When using this flag, the code for the service being bound will execute under the calling application's package name and user ID. Because the service must be an isolated process, it will not have direct access to the application's data, though. The purpose of this flag is to allow applications to provide services that are attributed to the app using the service, rather than the application providing the service.
`Int`	`BIND_IMPORTANT` Flag for `bindService`: this service is very important to the client, so should be brought to the foreground process level when the client is. Normally a process can only be raised to the visibility level by a client, even if that client is in the foreground.
`Int`	`BIND_INCLUDE_CAPABILITIES` Flag for `bindService`: If binding from an app that has specific capabilities due to its foreground state such as an activity or foreground service, then this flag will allow the bound app to get the same capabilities, as long as it has the required permissions as well.
`Int`	`BIND_NOT_FOREGROUND` Flag for `bindService`: don't allow this binding to raise the target service's process to the foreground scheduling priority. It will still be raised to at least the same memory priority as the client (so that its process will not be killable in any situation where the client is not killable), but for CPU scheduling purposes it may be left in the background. This only has an impact in the situation where the binding client is a foreground process and the target service is in a background process.
`Int`	`BIND_NOT_PERCEPTIBLE` Flag for `bindService`: If binding from an app that is visible or user-perceptible, lower the target service's importance to below the perceptible level. This allows the system to (temporarily) expunge the bound process from memory to make room for more important user-perceptible processes.
`Int`	`BIND_WAIVE_PRIORITY` Flag for `bindService`: don't impact the scheduling or memory management priority of the target service's hosting process. Allows the service's process to be managed on the background LRU list just like a regular application process in the background.
`String`	`BIOMETRIC_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.hardware.biometrics.BiometricManager` for handling biometric and PIN/pattern/password authentication.
`String`	`BLOB_STORE_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a for contributing and accessing data blobs from the blob store maintained by the system.
`String`	`BLUETOOTH_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.bluetooth.BluetoothManager` for using Bluetooth.
`String`	`CAMERA_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.hardware.camera2.CameraManager` for interacting with camera devices.
`String`	`CAPTIONING_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.view.accessibility.CaptioningManager` for obtaining captioning properties and listening for changes in captioning preferences.
`String`	`CARRIER_CONFIG_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.telephony.CarrierConfigManager` for reading carrier configuration values.
`String`	`CLIPBOARD_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.content.ClipboardManager` for accessing and modifying the contents of the global clipboard.
`String`	`COMPANION_DEVICE_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.companion.CompanionDeviceManager` for managing companion devices
`String`	`CONNECTIVITY_DIAGNOSTICS_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a for performing network connectivity diagnostics as well as receiving network connectivity information from the system.
`String`	`CONNECTIVITY_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a for handling management of network connections.
`String`	`CONSUMER_IR_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.hardware.ConsumerIrManager` for transmitting infrared signals from the device.
`Int`	`CONTEXT_IGNORE_SECURITY` Flag for use with `createPackageContext`: ignore any security restrictions on the Context being requested, allowing it to always be loaded. For use with `CONTEXT_INCLUDE_CODE` to allow code to be loaded into a process even when it isn't safe to do so. Use with extreme care!
`Int`	`CONTEXT_INCLUDE_CODE` Flag for use with `createPackageContext`: include the application code with the context. This means loading code into the caller's process, so that `getClassLoader()` can be used to instantiate the application's classes. Setting this flags imposes security restrictions on what application context you can access; if the requested application can not be safely loaded into your process, java.lang.SecurityException will be thrown. If this flag is not set, there will be no restrictions on the packages that can be loaded, but `getClassLoader` will always return the default system class loader.
`Int`	`CONTEXT_RESTRICTED` Flag for use with `createPackageContext`: a restricted context may disable specific features. For instance, a View associated with a restricted context would ignore particular XML attributes.
`String`	`CROSS_PROFILE_APPS_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.content.pm.CrossProfileApps` for cross profile operations.
`String`	`DEVICE_POLICY_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.app.admin.DevicePolicyManager` for working with global device policy management.
`String`	`DISPLAY_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.hardware.display.DisplayManager` for interacting with display devices.
`String`	`DOWNLOAD_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.app.DownloadManager` for requesting HTTP downloads.
`String`	`DROPBOX_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.os.DropBoxManager` instance for recording diagnostic logs.
`String`	`EUICC_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.telephony.euicc.EuiccManager` to manage the device eUICC (embedded SIM).
`String`	`FILE_INTEGRITY_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve an `android.security.FileIntegrityManager`.
`String`	`FINGERPRINT_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.hardware.fingerprint.FingerprintManager` for handling management of fingerprints.
`String`	`HARDWARE_PROPERTIES_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.os.HardwarePropertiesManager` for accessing the hardware properties service.
`String`	`INPUT_METHOD_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.view.inputmethod.InputMethodManager` for accessing input methods.
`String`	`INPUT_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.hardware.input.InputManager` for interacting with input devices.
`String`	`IPSEC_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.net.IpSecManager` for encrypting Sockets or Networks with IPSec.
`String`	`JOB_SCHEDULER_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a instance for managing occasional background tasks.
`String`	`KEYGUARD_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.app.KeyguardManager` for controlling keyguard.
`String`	`LAUNCHER_APPS_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.content.pm.LauncherApps` for querying and monitoring launchable apps across profiles of a user.
`String`	`LAYOUT_INFLATER_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.view.LayoutInflater` for inflating layout resources in this context.
`String`	`LOCATION_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a for controlling location updates.
`String`	`MEDIA_PROJECTION_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a instance for managing media projection sessions.
`String`	`MEDIA_ROUTER_SERVICE` Use with `getSystemService` to retrieve a `android.media.MediaRouter` for controlling and managing routing of media.
`String`	`MEDIA_SESSION_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.media.session.MediaSessionManager` for managing media Sessions.
`String`	`MIDI_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.media.midi.MidiManager` for accessing the MIDI service.
`Int`	`MODE_APPEND` File creation mode: for use with `openFileOutput`, if the file already exists then write data to the end of the existing file instead of erasing it.
`Int`	`MODE_ENABLE_WRITE_AHEAD_LOGGING` Database open flag: when set, the database is opened with write-ahead logging enabled by default.
`Int`	`MODE_MULTI_PROCESS` SharedPreference loading flag: when set, the file on disk will be checked for modification even if the shared preferences instance is already loaded in this process. This behavior is sometimes desired in cases where the application has multiple processes, all writing to the same SharedPreferences file. Generally there are better forms of communication between processes, though. This was the legacy (but undocumented) behavior in and before Gingerbread (Android 2.3) and this flag is implied when targeting such releases. For applications targeting SDK versions greater than Android 2.3, this flag must be explicitly set if desired.
`Int`	`MODE_NO_LOCALIZED_COLLATORS` Database open flag: when set, the database is opened without support for localized collators.
`Int`	`MODE_PRIVATE` File creation mode: the default mode, where the created file can only be accessed by the calling application (or all applications sharing the same user ID).
`Int`	`MODE_WORLD_READABLE` File creation mode: allow all other applications to have read access to the created file. Starting from `android.os.Build.VERSION_CODES#N`, attempting to use this mode throws a `SecurityException`.
`Int`	`MODE_WORLD_WRITEABLE` File creation mode: allow all other applications to have write access to the created file. Starting from `android.os.Build.VERSION_CODES#N`, attempting to use this mode will throw a `SecurityException`.
`String`	`NETWORK_STATS_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a for querying network usage stats.
`String`	`NFC_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.nfc.NfcManager` for using NFC.
`String`	`NOTIFICATION_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.app.NotificationManager` for informing the user of background events.
`String`	`NSD_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a for handling management of network service discovery
`String`	`POWER_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.os.PowerManager` for controlling power management, including "wake locks," which let you keep the device on while you're running long tasks.
`String`	`PRINT_SERVICE` `android.print.PrintManager` for printing and managing printers and print tasks.
`Int`	`RECEIVER_VISIBLE_TO_INSTANT_APPS` Flag for `registerReceiver`: The receiver can receive broadcasts from Instant Apps.
`String`	`RESTRICTIONS_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.content.RestrictionsManager` for retrieving application restrictions and requesting permissions for restricted operations.
`String`	`ROLE_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.app.role.RoleManager` for managing roles.
`String`	`SEARCH_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a for handling searches. `Configuration#UI_MODE_TYPE_WATCH` does not support `android.app.SearchManager`.
`String`	`SENSOR_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a for accessing sensors.
`String`	`SHORTCUT_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.content.pm.ShortcutManager` for accessing the launcher shortcut service.
`String`	`STORAGE_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a for accessing system storage functions.
`String`	`STORAGE_STATS_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a for accessing system storage statistics.
`String`	`SYSTEM_HEALTH_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.os.health.SystemHealthManager` for accessing system health (battery, power, memory, etc) metrics.
`String`	`TELECOM_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.telecom.TelecomManager` to manage telecom-related features of the device.
`String`	`TELEPHONY_IMS_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve an `android.telephony.ims.ImsManager`.
`String`	`TELEPHONY_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.telephony.TelephonyManager` for handling management the telephony features of the device.
`String`	`TELEPHONY_SUBSCRIPTION_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.telephony.SubscriptionManager` for handling management the telephony subscriptions of the device.
`String`	`TEXT_CLASSIFICATION_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `TextClassificationManager` for text classification services.
`String`	`TEXT_SERVICES_MANAGER_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.view.textservice.TextServicesManager` for accessing text services.
`String`	`TV_INPUT_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.media.tv.TvInputManager` for interacting with TV inputs on the device.
`String`	`UI_MODE_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.app.UiModeManager` for controlling UI modes.
`String`	`USAGE_STATS_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a for querying device usage stats.
`String`	`USB_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a for access to USB devices (as a USB host) and for controlling this device's behavior as a USB device.
`String`	`USER_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.os.UserManager` for managing users on devices that support multiple users.
`String`	`VIBRATOR_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a for interacting with the vibration hardware.
`String`	`VPN_MANAGEMENT_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.net.VpnManager` to manage profiles for the platform built-in VPN.
`String`	`WALLPAPER_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a com.android.server.WallpaperService for accessing wallpapers.
`String`	`WIFI_AWARE_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.net.wifi.aware.WifiAwareManager` for handling management of Wi-Fi Aware.
`String`	`WIFI_P2P_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a for handling management of Wi-Fi peer-to-peer connections.
`String`	`WIFI_RTT_RANGING_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a for ranging devices with wifi.
`String`	`WIFI_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a for handling management of Wi-Fi access.
`String`	`WINDOW_SERVICE` Use with `getSystemService(java.lang.String)` to retrieve a `android.view.WindowManager` for accessing the system's window manager.

From class Service

`Int`	`START_CONTINUATION_MASK` Bits returned by `onStartCommand` describing how to continue the service if it is killed. May be `START_STICKY`, `START_NOT_STICKY`, `START_REDELIVER_INTENT`, or `START_STICKY_COMPATIBILITY`.
`Int`	`START_FLAG_REDELIVERY` This flag is set in `onStartCommand` if the Intent is a re-delivery of a previously delivered intent, because the service had previously returned `START_REDELIVER_INTENT` but had been killed before calling `stopSelf(int)` for that Intent.
`Int`	`START_FLAG_RETRY` This flag is set in `onStartCommand` if the Intent is a retry because the original attempt never got to or returned from `onStartCommand(android.content.Intent,int,int)`.
`Int`	`START_NOT_STICKY` Constant to return from `onStartCommand`: if this service's process is killed while it is started (after returning from `onStartCommand`), and there are no new start intents to deliver to it, then take the service out of the started state and don't recreate until a future explicit call to `Context#startService`. The service will not receive a `onStartCommand(android.content.Intent,int,int)` call with a null Intent because it will not be restarted if there are no pending Intents to deliver. This mode makes sense for things that want to do some work as a result of being started, but can be stopped when under memory pressure and will explicit start themselves again later to do more work. An example of such a service would be one that polls for data from a server: it could schedule an alarm to poll every N minutes by having the alarm start its service. When its `onStartCommand` is called from the alarm, it schedules a new alarm for N minutes later, and spawns a thread to do its networking. If its process is killed while doing that check, the service will not be restarted until the alarm goes off.
`Int`	`START_REDELIVER_INTENT` Constant to return from `onStartCommand`: if this service's process is killed while it is started (after returning from `onStartCommand`), then it will be scheduled for a restart and the last delivered Intent re-delivered to it again via `onStartCommand`. This Intent will remain scheduled for redelivery until the service calls `stopSelf(int)` with the start ID provided to `onStartCommand`. The service will not receive a `onStartCommand(android.content.Intent,int,int)` call with a null Intent because it will only be restarted if it is not finished processing all Intents sent to it (and any such pending events will be delivered at the point of restart).
`Int`	`START_STICKY` Constant to return from `onStartCommand`: if this service's process is killed while it is started (after returning from `onStartCommand`), then leave it in the started state but don't retain this delivered intent. Later the system will try to re-create the service. Because it is in the started state, it will guarantee to call `onStartCommand` after creating the new service instance; if there are not any pending start commands to be delivered to the service, it will be called with a null intent object, so you must take care to check for this. This mode makes sense for things that will be explicitly started and stopped to run for arbitrary periods of time, such as a service performing background music playback.
`Int`	`START_STICKY_COMPATIBILITY` Constant to return from `onStartCommand`: compatibility version of `START_STICKY` that does not guarantee that `onStartCommand` will be called again after being killed.
`Int`	`STOP_FOREGROUND_DETACH` Flag for `stopForeground(int)`: if set, the notification previously provided to `startForeground` will be detached from the service. Only makes sense when `STOP_FOREGROUND_REMOVE` is not set -- in this case, the notification will remain shown, but be completely detached from the service and so no longer changed except through direct calls to the notification manager.
`Int`	`STOP_FOREGROUND_REMOVE` Flag for `stopForeground(int)`: if set, the notification previously provided to `startForeground` will be removed. Otherwise it will remain until a later call (to `startForeground(int,android.app.Notification)` or `stopForeground(int)` removes it, or the service is destroyed.

From class ComponentCallbacks2

`Int`	`TRIM_MEMORY_BACKGROUND` Level for `onTrimMemory(int)`: the process has gone on to the LRU list. This is a good opportunity to clean up resources that can efficiently and quickly be re-built if the user returns to the app.
`Int`	`TRIM_MEMORY_COMPLETE` Level for `onTrimMemory(int)`: the process is nearing the end of the background LRU list, and if more memory isn't found soon it will be killed.
`Int`	`TRIM_MEMORY_MODERATE` Level for `onTrimMemory(int)`: the process is around the middle of the background LRU list; freeing memory can help the system keep other processes running later in the list for better overall performance.
`Int`	`TRIM_MEMORY_RUNNING_CRITICAL` Level for `onTrimMemory(int)`: the process is not an expendable background process, but the device is running extremely low on memory and is about to not be able to keep any background processes running. Your running process should free up as many non-critical resources as it can to allow that memory to be used elsewhere. The next thing that will happen after this is `onLowMemory()` called to report that nothing at all can be kept in the background, a situation that can start to notably impact the user.
`Int`	`TRIM_MEMORY_RUNNING_LOW` Level for `onTrimMemory(int)`: the process is not an expendable background process, but the device is running low on memory. Your running process should free up unneeded resources to allow that memory to be used elsewhere.
`Int`	`TRIM_MEMORY_RUNNING_MODERATE` Level for `onTrimMemory(int)`: the process is not an expendable background process, but the device is running moderately low on memory. Your running process may want to release some unneeded resources for use elsewhere.
`Int`	`TRIM_MEMORY_UI_HIDDEN` Level for `onTrimMemory(int)`: the process had been showing a user interface, and is no longer doing so. Large allocations with the UI should be released at this point to allow memory to be better managed.

Public constructors
`<init>()`

Public methods
Unit	`addConference(conference: Conference!)` Adds a new conference call.
Unit	`addExistingConnection(phoneAccountHandle: PhoneAccountHandle!, connection: Connection!)` Adds a connection created by the `ConnectionService` and informs telecom of the new connection.
Unit	`conferenceRemoteConnections(remoteConnection1: RemoteConnection!, remoteConnection2: RemoteConnection!)` Indicates to the relevant `RemoteConnectionService` that the specified `RemoteConnection`s should be merged into a conference call.
Unit	`connectionServiceFocusReleased()` Call to inform Telecom that your `ConnectionService` has released call resources (e.g microphone, camera).
RemoteConnection!	`createRemoteIncomingConnection(connectionManagerPhoneAccount: PhoneAccountHandle!, request: ConnectionRequest!)` Ask some other `ConnectionService` to create a `RemoteConnection` given an incoming request.
RemoteConnection!	`createRemoteOutgoingConnection(connectionManagerPhoneAccount: PhoneAccountHandle!, request: ConnectionRequest!)` Ask some other `ConnectionService` to create a `RemoteConnection` given an outgoing request.
MutableCollection<Conference!>!	`getAllConferences()` Returns all the active `Conference`s for which this `ConnectionService` has taken responsibility.
MutableCollection<Connection!>!	`getAllConnections()` Returns all the active `Connection`s for which this `ConnectionService` has taken responsibility.
IBinder?	`onBind(intent: Intent!)` Return the communication channel to the service.
open Unit	`onConference(connection1: Connection!, connection2: Connection!)` Conference two specified connections.
open Unit	`onConnectionServiceFocusGained()` Called when the `ConnectionService` has gained the call focus.
open Unit	`onConnectionServiceFocusLost()` Called when the `ConnectionService` has lost the call focus.
open Connection!	`onCreateIncomingConnection(connectionManagerPhoneAccount: PhoneAccountHandle!, request: ConnectionRequest!)` Create a `Connection` given an incoming request.
open Unit	`onCreateIncomingConnectionFailed(connectionManagerPhoneAccount: PhoneAccountHandle!, request: ConnectionRequest!)` Called by Telecom to inform the `ConnectionService` that its request to create a new incoming `Connection` was denied.
open Connection!	`onCreateIncomingHandoverConnection(fromPhoneAccountHandle: PhoneAccountHandle!, request: ConnectionRequest!)` Called by Telecom to request that a `ConnectionService` creates an instance of an incoming handover `Connection`.
open Connection!	`onCreateOutgoingConnection(connectionManagerPhoneAccount: PhoneAccountHandle!, request: ConnectionRequest!)` Create a `Connection` given an outgoing request.
open Unit	`onCreateOutgoingConnectionFailed(connectionManagerPhoneAccount: PhoneAccountHandle!, request: ConnectionRequest!)` Called by Telecom to inform the `ConnectionService` that its request to create a new outgoing `Connection` was denied.
open Connection!	`onCreateOutgoingHandoverConnection(fromPhoneAccountHandle: PhoneAccountHandle!, request: ConnectionRequest!)` Called by Telecom to request that a `ConnectionService` creates an instance of an outgoing handover `Connection`.
open Unit	`onHandoverFailed(request: ConnectionRequest!, error: Int)` Called by Telecom in response to a `TelecomManager#acceptHandover()` invocation which failed.
open Unit	`onRemoteConferenceAdded(conference: RemoteConference!)` Indicates that a remote conference has been created for existing `RemoteConnection`s.
open Unit	`onRemoteExistingConnectionAdded(connection: RemoteConnection!)` Called when an existing connection is added remotely.
open Boolean	`onUnbind(intent: Intent!)` Called when all clients have disconnected from a particular interface published by the service.

Inherited functions

From class Service

`Unit`	`attachBaseContext(newBase: Context!)`
`Unit`	`dump(fd: FileDescriptor!, writer: PrintWriter!, args: Array<String!>!)` Print the Service's state into the given stream. This gets invoked if you run "adb shell dumpsys activity service <yourservicename>" (note that for this command to work, the service must be running, and you must specify a fully-qualified service name). This is distinct from "dumpsys <servicename>", which only works for named system services and which invokes the `IBinder#dump` method on the `IBinder` interface registered with ServiceManager.
`Application!`	`getApplication()` Return the application that owns this service.
`Int`	`getForegroundServiceType()` If the service has become a foreground service by calling `startForeground(int,android.app.Notification)` or `startForeground(int,android.app.Notification,int)`, `getForegroundServiceType()` returns the current foreground service type. If there is no foregroundServiceType specified in manifest, `ServiceInfo#FOREGROUND_SERVICE_TYPE_NONE` is returned. If the service is not a foreground service, `ServiceInfo#FOREGROUND_SERVICE_TYPE_NONE` is returned.
`Unit`	`onConfigurationChanged(newConfig: Configuration)`
`Unit`	`onCreate()` Called by the system when the service is first created. Do not call this method directly.
`Unit`	`onDestroy()` Called by the system to notify a Service that it is no longer used and is being removed. The service should clean up any resources it holds (threads, registered receivers, etc) at this point. Upon return, there will be no more calls in to this Service object and it is effectively dead. Do not call this method directly.
`Unit`	`onLowMemory()`
`Unit`	`onRebind(intent: Intent!)` Called when new clients have connected to the service, after it had previously been notified that all had disconnected in its `onUnbind`. This will only be called if the implementation of `onUnbind` was overridden to return true.
`Unit`	`onStart(intent: Intent!, startId: Int)`
`Int`	`onStartCommand(intent: Intent!, flags: Int, startId: Int)` Called by the system every time a client explicitly starts the service by calling `android.content.Context#startService`, providing the arguments it supplied and a unique integer token representing the start request. Do not call this method directly. For backwards compatibility, the default implementation calls `onStart` and returns either `START_STICKY` or `START_STICKY_COMPATIBILITY`. Note that the system calls this on your service's main thread. A service's main thread is the same thread where UI operations take place for Activities running in the same process. You should always avoid stalling the main thread's event loop. When doing long-running operations, network calls, or heavy disk I/O, you should kick off a new thread, or use `android.os.AsyncTask`.
`Unit`	`onTaskRemoved(rootIntent: Intent!)` This is called if the service is currently running and the user has removed a task that comes from the service's application. If you have set `ServiceInfo.FLAG_STOP_WITH_TASK` then you will not receive this callback; instead, the service will simply be stopped.
`Unit`	`onTrimMemory(level: Int)`
`Unit`	`startForeground(id: Int, notification: Notification!)` If your service is started (running through `Context#startService(Intent)`), then also make this service run in the foreground, supplying the ongoing notification to be shown to the user while in this state. By default started services are background, meaning that their process won't be given foreground CPU scheduling (unless something else in that process is foreground) and, if the system needs to kill them to reclaim more memory (such as to display a large page in a web browser), they can be killed without too much harm. You use `startForeground` if killing your service would be disruptive to the user, such as if your service is performing background music playback, so the user would notice if their music stopped playing. Note that calling this method does not put the service in the started state itself, even though the name sounds like it. You must always call `startService(android.content.Intent)` first to tell the system it should keep the service running, and then use this method to tell it to keep it running harder. Apps targeting API `android.os.Build.VERSION_CODES#P` or later must request the permission `android.Manifest.permission#FOREGROUND_SERVICE` in order to use this API. Apps built with SDK version `android.os.Build.VERSION_CODES#Q` or later can specify the foreground service types using attribute `android.R.attr#foregroundServiceType` in service element of manifest file. The value of attribute `android.R.attr#foregroundServiceType` can be multiple flags ORed together.
`Unit`	`startForeground(id: Int, notification: Notification, foregroundServiceType: Int)` An overloaded version of `startForeground(int,android.app.Notification)` with additional foregroundServiceType parameter. Apps built with SDK version `android.os.Build.VERSION_CODES#Q` or later can specify the foreground service types using attribute `android.R.attr#foregroundServiceType` in service element of manifest file. The value of attribute `android.R.attr#foregroundServiceType` can be multiple flags ORed together. The foregroundServiceType parameter must be a subset flags of what is specified in manifest attribute `android.R.attr#foregroundServiceType`, if not, an IllegalArgumentException is thrown. Specify foregroundServiceType parameter as `android.content.pm.ServiceInfo#FOREGROUND_SERVICE_TYPE_MANIFEST` to use all flags that is specified in manifest attribute foregroundServiceType.
`Unit`	`stopForeground(removeNotification: Boolean)` Synonym for `stopForeground(int)`.
`Unit`	`stopForeground(flags: Int)` Remove this service from foreground state, allowing it to be killed if more memory is needed. This does not stop the service from running (for that you use `stopSelf()` or related methods), just takes it out of the foreground state.
`Unit`	`stopSelf()` Stop the service, if it was previously started. This is the same as calling `android.content.Context#stopService` for this particular service.
`Unit`	`stopSelf(startId: Int)` Old version of `stopSelfResult` that doesn't return a result.
`Boolean`	`stopSelfResult(startId: Int)` Stop the service if the most recent time it was started was startId. This is the same as calling for this particular service but allows you to safely avoid stopping if there is a start request from a client that you haven't yet seen in `onStart`. Be careful about ordering of your calls to this function.. If you call this function with the most-recently received ID before you have called it for previously received IDs, the service will be immediately stopped anyway. If you may end up processing IDs out of order (such as by dispatching them on separate threads), then you are responsible for stopping them in the same order you received them.

From class ContextWrapper

`Boolean`	`bindIsolatedService(service: Intent, flags: Int, instanceName: String, executor: Executor, conn: ServiceConnection)`
`Boolean`	`bindService(service: Intent!, conn: ServiceConnection, flags: Int)`
`Boolean`	`bindService(service: Intent, flags: Int, executor: Executor, conn: ServiceConnection)`
`Int`	`checkCallingOrSelfPermission(permission: String)`
`Int`	`checkCallingOrSelfUriPermission(uri: Uri!, modeFlags: Int)`
`Int`	`checkCallingPermission(permission: String)`
`Int`	`checkCallingUriPermission(uri: Uri!, modeFlags: Int)`
`Int`	`checkPermission(permission: String, pid: Int, uid: Int)`
`Int`	`checkSelfPermission(permission: String)`
`Int`	`checkUriPermission(uri: Uri!, pid: Int, uid: Int, modeFlags: Int)`
`Int`	`checkUriPermission(uri: Uri?, readPermission: String?, writePermission: String?, pid: Int, uid: Int, modeFlags: Int)`
`Unit`	`clearWallpaper()`
`Context`	`createAttributionContext(attributionTag: String?)` Return a new Context object for the current Context but attribute to a different tag. In complex apps attribution tagging can be used to distinguish between separate logical parts.
`Context!`	`createConfigurationContext(overrideConfiguration: Configuration)`
`Context!`	`createDeviceProtectedStorageContext()`
`Context!`	`createDisplayContext(display: Display)`
`Context!`	`createPackageContext(packageName: String!, flags: Int)`
`Context`	`createWindowContext(type: Int, options: Bundle?)` Creates a Context for a non-activity window. A window context is a context that can be used to add non-activity windows, such as `android.view.WindowManager.LayoutParams#TYPE_APPLICATION_OVERLAY`. A window context must be created from a context that has an associated `Display`, such as `Activity` or a context created with `createDisplayContext(android.view.Display)`. The window context is created with the appropriate `Configuration` for the area of the display that the windows created with it can occupy; it must be used when `inflating` views, such that they can be inflated with proper `Resources`. Below is a sample code to add an application overlay window on the primary display: ... final DisplayManager dm = anyContext.getSystemService(DisplayManager.class); final Display primaryDisplay = dm.getDisplay(DEFAULT_DISPLAY); final Context windowContext = anyContext.createDisplayContext(primaryDisplay) .createWindowContext(TYPE_APPLICATION_OVERLAY, null); final View overlayView = Inflater.from(windowContext).inflate(someLayoutXml, null); // WindowManager.LayoutParams initialization ... mParams.type = TYPE_APPLICATION_OVERLAY; ... mWindowContext.getSystemService(WindowManager.class).addView(overlayView, mParams); This context's configuration and resources are adjusted to a display area where the windows with provided type will be added. Note that all windows associated with the same context will have an affinity and can only be moved together between different displays or areas on a display. If there is a need to add different window types, or non-associated windows, separate Contexts should be used. Creating a window context is an expensive operation. Misuse of this API may lead to a huge performance drop. The best practice is to use the same window context when possible. An approach is to create one window context with specific window type and display and use it everywhere it's needed..
`Array<String!>!`	`databaseList()`
`Boolean`	`deleteDatabase(name: String!)`
`Boolean`	`deleteFile(name: String!)`
`Boolean`	`deleteSharedPreferences(name: String!)`
`Unit`	`enforceCallingOrSelfPermission(permission: String, message: String?)`
`Unit`	`enforceCallingOrSelfUriPermission(uri: Uri!, modeFlags: Int, message: String!)`
`Unit`	`enforceCallingPermission(permission: String, message: String?)`
`Unit`	`enforceCallingUriPermission(uri: Uri!, modeFlags: Int, message: String!)`
`Unit`	`enforcePermission(permission: String, pid: Int, uid: Int, message: String?)`
`Unit`	`enforceUriPermission(uri: Uri!, pid: Int, uid: Int, modeFlags: Int, message: String!)`
`Unit`	`enforceUriPermission(uri: Uri?, readPermission: String?, writePermission: String?, pid: Int, uid: Int, modeFlags: Int, message: String?)`
`Array<String!>!`	`fileList()`
`Context!`	`getApplicationContext()`
`ApplicationInfo!`	`getApplicationInfo()`
`AssetManager!`	`getAssets()`
`Context!`	`getBaseContext()`
`File!`	`getCacheDir()`
`ClassLoader!`	`getClassLoader()`
`File!`	`getCodeCacheDir()`
`ContentResolver!`	`getContentResolver()`
`File!`	`getDataDir()`
`File!`	`getDatabasePath(name: String!)`
`File!`	`getDir(name: String!, mode: Int)`
`Display?`	`getDisplay()` Get the display this context is associated with. Applications should use this method with `android.app.Activity` or a context associated with a `Display` via `createDisplayContext(android.view.Display)` to get a display object associated with a Context, or `android.hardware.display.DisplayManager#getDisplay` to get a display object by id.
`File?`	`getExternalCacheDir()`
`Array<File!>!`	`getExternalCacheDirs()`
`File?`	`getExternalFilesDir(type: String?)`
`Array<File!>!`	`getExternalFilesDirs(type: String!)`
`Array<File!>!`	`getExternalMediaDirs()`
`File!`	`getFileStreamPath(name: String!)`
`File!`	`getFilesDir()`
`Executor!`	`getMainExecutor()`
`Looper!`	`getMainLooper()`
`File!`	`getNoBackupFilesDir()`
`File!`	`getObbDir()`
`Array<File!>!`	`getObbDirs()`
`String!`	`getPackageCodePath()`
`PackageManager!`	`getPackageManager()`
`String!`	`getPackageName()`
`String!`	`getPackageResourcePath()`
`Resources!`	`getResources()`
`SharedPreferences!`	`getSharedPreferences(name: String!, mode: Int)`
`Any!`	`getSystemService(name: String)`
`String?`	`getSystemServiceName(serviceClass: Class<*>)`
`Resources.Theme!`	`getTheme()`
`Drawable!`	`getWallpaper()`
`Int`	`getWallpaperDesiredMinimumHeight()`
`Int`	`getWallpaperDesiredMinimumWidth()`
`Unit`	`grantUriPermission(toPackage: String!, uri: Uri!, modeFlags: Int)`
`Boolean`	`isDeviceProtectedStorage()`
`Boolean`	`isRestricted()`
`Boolean`	`moveDatabaseFrom(sourceContext: Context!, name: String!)`
`Boolean`	`moveSharedPreferencesFrom(sourceContext: Context!, name: String!)`
`FileInputStream!`	`openFileInput(name: String!)`
`FileOutputStream!`	`openFileOutput(name: String!, mode: Int)`
`SQLiteDatabase!`	`openOrCreateDatabase(name: String!, mode: Int, factory: SQLiteDatabase.CursorFactory!)`
`SQLiteDatabase!`	`openOrCreateDatabase(name: String!, mode: Int, factory: SQLiteDatabase.CursorFactory!, errorHandler: DatabaseErrorHandler?)`
`Drawable!`	`peekWallpaper()`
`Intent?`	`registerReceiver(receiver: BroadcastReceiver?, filter: IntentFilter!)`
`Intent?`	`registerReceiver(receiver: BroadcastReceiver?, filter: IntentFilter!, flags: Int)`
`Intent?`	`registerReceiver(receiver: BroadcastReceiver!, filter: IntentFilter!, broadcastPermission: String?, scheduler: Handler?)`
`Intent?`	`registerReceiver(receiver: BroadcastReceiver!, filter: IntentFilter!, broadcastPermission: String?, scheduler: Handler?, flags: Int)`
`Unit`	`removeStickyBroadcast(intent: Intent!)`
`Unit`	`removeStickyBroadcastAsUser(intent: Intent!, user: UserHandle!)`
`Unit`	`revokeUriPermission(uri: Uri!, modeFlags: Int)`
`Unit`	`revokeUriPermission(targetPackage: String!, uri: Uri!, modeFlags: Int)`
`Unit`	`sendBroadcast(intent: Intent!)`
`Unit`	`sendBroadcast(intent: Intent!, receiverPermission: String?)`
`Unit`	`sendBroadcastAsUser(intent: Intent!, user: UserHandle!)`
`Unit`	`sendBroadcastAsUser(intent: Intent!, user: UserHandle!, receiverPermission: String?)`
`Unit`	`sendOrderedBroadcast(intent: Intent!, receiverPermission: String?)`
`Unit`	`sendOrderedBroadcast(intent: Intent, receiverPermission: String?, resultReceiver: BroadcastReceiver?, scheduler: Handler?, initialCode: Int, initialData: String?, initialExtras: Bundle?)`
`Unit`	`sendOrderedBroadcast(intent: Intent, receiverPermission: String?, receiverAppOp: String?, resultReceiver: BroadcastReceiver?, scheduler: Handler?, initialCode: Int, initialData: String?, initialExtras: Bundle?)` Version of `sendOrderedBroadcast(android.content.Intent,java.lang.String,android.content.BroadcastReceiver,android.os.Handler,int,java.lang.String,android.os.Bundle)` that allows you to specify the App Op to enforce restrictions on which receivers the broadcast will be sent to. See `BroadcastReceiver` for more information on Intent broadcasts.
`Unit`	`sendOrderedBroadcast(intent: Intent, initialCode: Int, receiverPermission: String?, receiverAppOp: String?, resultReceiver: BroadcastReceiver?, scheduler: Handler?, initialData: String?, initialExtras: Bundle?, options: Bundle?)`
`Unit`	`sendOrderedBroadcastAsUser(intent: Intent!, user: UserHandle!, receiverPermission: String?, resultReceiver: BroadcastReceiver!, scheduler: Handler?, initialCode: Int, initialData: String?, initialExtras: Bundle?)`
`Unit`	`sendStickyBroadcast(intent: Intent!)`
`Unit`	`sendStickyBroadcastAsUser(intent: Intent!, user: UserHandle!)`
`Unit`	`sendStickyOrderedBroadcast(intent: Intent!, resultReceiver: BroadcastReceiver!, scheduler: Handler?, initialCode: Int, initialData: String?, initialExtras: Bundle?)`
`Unit`	`sendStickyOrderedBroadcastAsUser(intent: Intent!, user: UserHandle!, resultReceiver: BroadcastReceiver!, scheduler: Handler?, initialCode: Int, initialData: String?, initialExtras: Bundle?)`
`Unit`	`setTheme(resid: Int)`
`Unit`	`setWallpaper(bitmap: Bitmap!)`
`Unit`	`setWallpaper(data: InputStream!)`
`Unit`	`startActivities(intents: Array<Intent!>!)`
`Unit`	`startActivities(intents: Array<Intent!>!, options: Bundle!)`
`Unit`	`startActivity(intent: Intent!)`
`Unit`	`startActivity(intent: Intent!, options: Bundle?)`
`ComponentName?`	`startForegroundService(service: Intent!)`
`Boolean`	`startInstrumentation(className: ComponentName, profileFile: String?, arguments: Bundle?)`
`Unit`	`startIntentSender(intent: IntentSender!, fillInIntent: Intent?, flagsMask: Int, flagsValues: Int, extraFlags: Int)`
`Unit`	`startIntentSender(intent: IntentSender!, fillInIntent: Intent?, flagsMask: Int, flagsValues: Int, extraFlags: Int, options: Bundle?)`
`ComponentName?`	`startService(service: Intent!)`
`Boolean`	`stopService(name: Intent!)`
`Unit`	`unbindService(conn: ServiceConnection)`
`Unit`	`unregisterReceiver(receiver: BroadcastReceiver!)`
`Unit`	`updateServiceGroup(conn: ServiceConnection, group: Int, importance: Int)`

From class Context

`Int`	`getColor(id: Int)` Returns a color associated with a particular resource ID and styled for the current theme.
`ColorStateList`	`getColorStateList(id: Int)` Returns a color state list associated with a particular resource ID and styled for the current theme.
`Drawable?`	`getDrawable(id: Int)` Returns a drawable object associated with a particular resource ID and styled for the current theme.
`String`	`getString(resId: Int)` Returns a localized string from the application's package's default string table.
`String`	`getString(resId: Int, vararg formatArgs: Any!)` Returns a localized formatted string from the application's package's default string table, substituting the format arguments as defined in `java.util.Formatter` and `java.lang.String#format`.
`T`	`getSystemService(serviceClass: Class<T>)` Return the handle to a system-level service by class. Currently available classes are: `android.view.WindowManager`, `android.view.LayoutInflater`, `android.app.ActivityManager`, `android.os.PowerManager`, `android.app.AlarmManager`, `android.app.NotificationManager`, `android.app.KeyguardManager`, `android.location.LocationManager`, `android.app.SearchManager`, `android.os.Vibrator`, `android.net.ConnectivityManager`, `android.net.wifi.WifiManager`, `android.media.AudioManager`, `android.media.MediaRouter`, `android.telephony.TelephonyManager`, `android.telephony.SubscriptionManager`, `android.view.inputmethod.InputMethodManager`, `android.app.UiModeManager`, `android.app.DownloadManager`, `android.os.BatteryManager`, `android.app.job.JobScheduler`, `android.app.usage.NetworkStatsManager`. Note: System services obtained via this API may be closely associated with the Context in which they are obtained from. In general, do not share the service objects between various different contexts (Activities, Applications, Services, Providers, etc.) Note: Instant apps, for which `PackageManager#isInstantApp()` returns true, don't have access to the following system services: `DEVICE_POLICY_SERVICE`, `FINGERPRINT_SERVICE`, `KEYGUARD_SERVICE`, `SHORTCUT_SERVICE`, `USB_SERVICE`, `WALLPAPER_SERVICE`, `WIFI_P2P_SERVICE`, `WIFI_SERVICE`, `WIFI_AWARE_SERVICE`. For these services this method will return `null`. Generally, if you are running as an instant app you should always check whether the result of this method is `null`.
`CharSequence`	`getText(resId: Int)` Return a localized, styled CharSequence from the application's package's default string table.
`TypedArray`	`obtainStyledAttributes(attrs: IntArray)` Retrieve styled attribute information in this Context's theme. See `android.content.res.Resources.Theme#obtainStyledAttributes(int[])` for more information.
`TypedArray`	`obtainStyledAttributes(resid: Int, attrs: IntArray)` Retrieve styled attribute information in this Context's theme. See `android.content.res.Resources.Theme#obtainStyledAttributes(int, int[])` for more information.
`TypedArray`	`obtainStyledAttributes(set: AttributeSet?, attrs: IntArray)` Retrieve styled attribute information in this Context's theme. See `android.content.res.Resources.Theme#obtainStyledAttributes(AttributeSet, int[], int, int)` for more information.
`TypedArray`	`obtainStyledAttributes(set: AttributeSet?, attrs: IntArray, defStyleAttr: Int, defStyleRes: Int)` Retrieve styled attribute information in this Context's theme. See `android.content.res.Resources.Theme#obtainStyledAttributes(AttributeSet, int[], int, int)` for more information.
`Unit`	`registerComponentCallbacks(callback: ComponentCallbacks!)` Add a new `ComponentCallbacks` to the base application of the Context, which will be called at the same times as the ComponentCallbacks methods of activities and other components are called. Note that you must be sure to use `unregisterComponentCallbacks` when appropriate in the future; this will not be removed for you.
`Unit`	`sendBroadcastWithMultiplePermissions(intent: Intent, receiverPermissions: Array<String!>)` Broadcast the given intent to all interested BroadcastReceivers, allowing an array of required permissions to be enforced. This call is asynchronous; it returns immediately, and you will continue executing while the receivers are run. No results are propagated from receivers and receivers can not abort the broadcast. If you want to allow receivers to propagate results or abort the broadcast, you must send an ordered broadcast using `sendOrderedBroadcast(android.content.Intent,java.lang.String)`. See `BroadcastReceiver` for more information on Intent broadcasts.
`Unit`	`unregisterComponentCallbacks(callback: ComponentCallbacks!)` Remove a `ComponentCallbacks` object that was previously registered with `registerComponentCallbacks(android.content.ComponentCallbacks)`.

From class ComponentCallbacks

Unit

onConfigurationChanged(newConfig: Configuration)

Called by the system when the device configuration changes while your component is running. Note that, unlike activities, other components are never restarted when a configuration changes: they must always deal with the results of the change, such as by re-retrieving resources.

At the time that this function has been called, your Resources object will have been updated to return resource values matching the new configuration.

For more information, read Handling Runtime Changes.

Unit

onLowMemory()

This is called when the overall system is running low on memory, and actively running processes should trim their memory usage. While the exact point at which this will be called is not defined, generally it will happen when all background process have been killed. That is, before reaching the point of killing processes hosting service and foreground UI that we would like to avoid killing.

You should implement this method to release any caches or other unnecessary resources you may be holding on to. The system will perform a garbage collection for you after returning from this method.

Preferably, you should implement ComponentCallbacks2#onTrimMemory from ComponentCallbacks2 to incrementally unload your resources based on various levels of memory demands. That API is available for API level 14 and higher, so you should only use this onLowMemory method as a fallback for older versions, which can be treated the same as ComponentCallbacks2#onTrimMemory with the ComponentCallbacks2#TRIM_MEMORY_COMPLETE level.

Constants

SERVICE_INTERFACE

Added in API level 23

static val SERVICE_INTERFACE: String

The Intent that must be declared as handled by the service.

Value: "android.telecom.ConnectionService"

Public constructors

<init>

ConnectionService()

Public methods

addConference

Added in API level 23

fun addConference(conference: Conference!): Unit

Adds a new conference call. When a conference call is created either as a result of an explicit request via onConference or otherwise, the connection service should supply an instance of Conference by invoking this method. A conference call provided by this method will persist until Conference#destroy is invoked on the conference instance.

Parameters
`conference`	Conference!: The new conference object.

addExistingConnection

Added in API level 23

fun addExistingConnection(
    phoneAccountHandle: PhoneAccountHandle!, 
    connection: Connection!
): Unit

Adds a connection created by the ConnectionService and informs telecom of the new connection.

Parameters
`phoneAccountHandle`	PhoneAccountHandle!: The phone account handle for the connection.
`connection`	Connection!: The connection to add.

conferenceRemoteConnections

Added in API level 23

fun conferenceRemoteConnections(
    remoteConnection1: RemoteConnection!, 
    remoteConnection2: RemoteConnection!
): Unit

Indicates to the relevant RemoteConnectionService that the specified RemoteConnections should be merged into a conference call.

If the conference request is successful, the method onRemoteConferenceAdded will be invoked.

Parameters
`remoteConnection1`	RemoteConnection!: The first of the remote connections to conference.
`remoteConnection2`	RemoteConnection!: The second of the remote connections to conference.

connectionServiceFocusReleased

Added in API level 28

fun connectionServiceFocusReleased(): Unit

Call to inform Telecom that your ConnectionService has released call resources (e.g microphone, camera).

The ConnectionService will be disconnected when it failed to call this method within 5 seconds after onConnectionServiceFocusLost() is called.

See Also

android.telecom.ConnectionService#onConnectionServiceFocusLost()

createRemoteIncomingConnection

Added in API level 23

fun createRemoteIncomingConnection(
    connectionManagerPhoneAccount: PhoneAccountHandle!, 
    request: ConnectionRequest!
): RemoteConnection!

Ask some other ConnectionService to create a RemoteConnection given an incoming request. This is used by ConnectionServices that are registered with PhoneAccount#CAPABILITY_CONNECTION_MANAGER and want to be able to manage SIM-based incoming calls.

Parameters
`connectionManagerPhoneAccount`	PhoneAccountHandle!: See description at `onCreateOutgoingConnection(android.telecom.PhoneAccountHandle,android.telecom.ConnectionRequest)`.
`request`	ConnectionRequest!: Details about the incoming call.

Return
`RemoteConnection!`	The `Connection` object to satisfy this call, or `null` to not handle the call.

createRemoteOutgoingConnection

Added in API level 23

fun createRemoteOutgoingConnection(
    connectionManagerPhoneAccount: PhoneAccountHandle!, 
    request: ConnectionRequest!
): RemoteConnection!

Ask some other ConnectionService to create a RemoteConnection given an outgoing request. This is used by ConnectionServices that are registered with PhoneAccount#CAPABILITY_CONNECTION_MANAGER and want to be able to use the SIM-based ConnectionService to place its outgoing calls.

Parameters
`connectionManagerPhoneAccount`	PhoneAccountHandle!: See description at `onCreateOutgoingConnection(android.telecom.PhoneAccountHandle,android.telecom.ConnectionRequest)`.
`request`	ConnectionRequest!: Details about the outgoing call.

Return
`RemoteConnection!`	The `Connection` object to satisfy this call, or `null` to not handle the call.

getAllConferences

Added in API level 24

fun getAllConferences(): MutableCollection<Conference!>!

Returns all the active Conferences for which this ConnectionService has taken responsibility.

Return
`MutableCollection<Conference!>!`	A collection of `Conference`s created by this `ConnectionService`.

getAllConnections

Added in API level 23

fun getAllConnections(): MutableCollection<Connection!>!

Returns all the active Connections for which this ConnectionService has taken responsibility.

Return
`MutableCollection<Connection!>!`	A collection of `Connection`s created by this `ConnectionService`.

onBind

Added in API level 23

fun onBind(intent: Intent!): IBinder?

Return the communication channel to the service. May return null if clients can not bind to the service. The returned android.os.IBinder is usually for a complex interface that has been described using aidl.

Note that unlike other application components, calls on to the IBinder interface returned here may not happen on the main thread of the process. More information about the main thread can be found in Processes and Threads.

Parameters
`intent`	Intent!: The Intent that was used to bind to this service, as given to `Context.bindService`. Note that any extras that were included with the Intent at that point will not be seen here.

Return
`IBinder?`	Return an IBinder through which clients can call on to the service.

onConference

Added in API level 23

open fun onConference(
    connection1: Connection!, 
    connection2: Connection!
): Unit

Conference two specified connections. Invoked when the user has made a request to merge the specified connections into a conference call. In response, the connection service should create an instance of Conference and pass it into addConference.

Parameters
`connection1`	Connection!: A connection to merge into a conference call.
`connection2`	Connection!: A connection to merge into a conference call.

onConnectionServiceFocusGained

Added in API level 28

open fun onConnectionServiceFocusGained(): Unit

Called when the ConnectionService has gained the call focus. The ConnectionService can acquire the call resources at this time.

onConnectionServiceFocusLost

Added in API level 28

open fun onConnectionServiceFocusLost(): Unit

Called when the ConnectionService has lost the call focus. The ConnectionService should release the call resources and invokes ConnectionService#connectionServiceFocusReleased() to inform telecom that it has released the call resources.

onCreateIncomingConnection

Added in API level 23

open fun onCreateIncomingConnection(
    connectionManagerPhoneAccount: PhoneAccountHandle!, 
    request: ConnectionRequest!
): Connection!

Create a Connection given an incoming request. This is used to attach to existing incoming calls.

Parameters
`connectionManagerPhoneAccount`	PhoneAccountHandle!: See description at `onCreateOutgoingConnection(android.telecom.PhoneAccountHandle,android.telecom.ConnectionRequest)`.
`request`	ConnectionRequest!: Details about the incoming call.

Return
`Connection!`	The `Connection` object to satisfy this call, or `null` to not handle the call.

onCreateIncomingConnectionFailed

Added in API level 26

open fun onCreateIncomingConnectionFailed(
    connectionManagerPhoneAccount: PhoneAccountHandle!, 
    request: ConnectionRequest!
): Unit

Called by Telecom to inform the ConnectionService that its request to create a new incoming Connection was denied.

Used when a self-managed ConnectionService attempts to create a new incoming Connection, but Telecom has determined that the call cannot be allowed at this time. The ConnectionService is responsible for silently rejecting the new incoming Connection.

See TelecomManager#isIncomingCallPermitted(PhoneAccountHandle) for more information.

Parameters
`connectionManagerPhoneAccount`	PhoneAccountHandle!: See description at `onCreateOutgoingConnection(android.telecom.PhoneAccountHandle,android.telecom.ConnectionRequest)`.
`request`	ConnectionRequest!: The incoming connection request.

onCreateIncomingHandoverConnection

Added in API level 28

open fun onCreateIncomingHandoverConnection(
    fromPhoneAccountHandle: PhoneAccountHandle!, 
    request: ConnectionRequest!
): Connection!

Called by Telecom to request that a ConnectionService creates an instance of an incoming handover Connection.

A call handover is the process where an ongoing call is transferred from one app (i.e. ConnectionService to another app. The user could, for example, choose to continue a mobile network call in a video calling app. The mobile network call via the Telephony stack is referred to as the source of the handover, and the video calling app is referred to as the destination.

When considering a handover scenario the initiating device is where a user initiated the handover process (e.g. by calling android.telecom.Call#handoverTo( * PhoneAccountHandle, int, Bundle), and the other device is considered the receiving device.

This method is called on the destination app on the receiving device when the destination app calls TelecomManager#acceptHandover(Uri, int, PhoneAccountHandle) to accept an incoming handover from the initiating device.

For a full discussion of the handover process and the APIs involved, see android.telecom.Call#handoverTo(PhoneAccountHandle, int, Bundle).

Implementations of this method should return an instance of Connection which represents the handover. The code below shows an example of how this is done.

<code>public Connection onCreateIncomingHandoverConnection(PhoneAccountHandle
      fromPhoneAccountHandle, ConnectionRequest request) {
    // Given that your app requested to accept the handover, you should not return null here.
    MyConnection connection = new MyConnection();
    connection.setAddress(request.getAddress(), TelecomManager.PRESENTATION_ALLOWED);
    connection.setVideoState(request.getVideoState());
    return connection;
  }
  </code>

Parameters
`fromPhoneAccountHandle`	PhoneAccountHandle!: `PhoneAccountHandle` associated with the ConnectionService which needs to handover the call.
`request`	ConnectionRequest!: Details about the call which needs to be handover.

Return
`Connection!`	`Connection` instance corresponding to the handover call.

onCreateOutgoingConnection

Added in API level 23

open fun onCreateOutgoingConnection(
    connectionManagerPhoneAccount: PhoneAccountHandle!, 
    request: ConnectionRequest!
): Connection!

Create a Connection given an outgoing request. This is used to initiate new outgoing calls.

Parameters

Parameters
`connectionManagerPhoneAccount`	PhoneAccountHandle!: The connection manager account to use for managing this call. If this parameter is not `null`, it means that this `ConnectionService` has registered one or more `PhoneAccount`s having `PhoneAccount#CAPABILITY_CONNECTION_MANAGER`. This parameter will contain one of these `PhoneAccount`s, while the `request` will contain another (usually but not always distinct) `PhoneAccount` to be used for actually making the connection. If this parameter is `null`, it means that this `ConnectionService` is being asked to make a direct connection. The `ConnectionRequest#getAccountHandle()` of parameter `request` will be a `PhoneAccount` registered by this `ConnectionService` to use for making the connection.
`request`	ConnectionRequest!: Details about the outgoing call.

connectionManagerPhoneAccount

PhoneAccountHandle!: The connection manager account to use for managing this call.

If this parameter is not null, it means that this ConnectionService has registered one or more PhoneAccounts having PhoneAccount#CAPABILITY_CONNECTION_MANAGER. This parameter will contain one of these PhoneAccounts, while the request will contain another (usually but not always distinct) PhoneAccount to be used for actually making the connection.

If this parameter is null, it means that this ConnectionService is being asked to make a direct connection. The ConnectionRequest#getAccountHandle() of parameter request will be a PhoneAccount registered by this ConnectionService to use for making the connection.

request ConnectionRequest!: Details about the outgoing call.

Return
`Connection!`	The `Connection` object to satisfy this call, or the result of an invocation of `Connection#createFailedConnection(DisconnectCause)` to not handle the call.

onCreateOutgoingConnectionFailed

Added in API level 26

open fun onCreateOutgoingConnectionFailed(
    connectionManagerPhoneAccount: PhoneAccountHandle!, 
    request: ConnectionRequest!
): Unit

Called by Telecom to inform the ConnectionService that its request to create a new outgoing Connection was denied.

Used when a self-managed ConnectionService attempts to create a new outgoing Connection, but Telecom has determined that the call cannot be placed at this time. The ConnectionService is responisible for informing the user that the Connection cannot be made at this time.

See TelecomManager#isOutgoingCallPermitted(PhoneAccountHandle) for more information.

Parameters
`connectionManagerPhoneAccount`	PhoneAccountHandle!: See description at `onCreateOutgoingConnection(android.telecom.PhoneAccountHandle,android.telecom.ConnectionRequest)`.
`request`	ConnectionRequest!: The outgoing connection request.

onCreateOutgoingHandoverConnection

Added in API level 28

open fun onCreateOutgoingHandoverConnection(
    fromPhoneAccountHandle: PhoneAccountHandle!, 
    request: ConnectionRequest!
): Connection!

Called by Telecom to request that a ConnectionService creates an instance of an outgoing handover Connection.

This method is called on the destination ConnectionService on initiating device when the user initiates a handover request from one app to another. The user request originates in the InCallService via android.telecom.Call#handoverTo(PhoneAccountHandle, int, Bundle).

For a full discussion of the handover process and the APIs involved, see android.telecom.Call#handoverTo(PhoneAccountHandle, int, Bundle).

Implementations of this method should return an instance of Connection which represents the handover. If your app does not wish to accept a handover to it at this time, you can return null. The code below shows an example of how this is done.

<code>public Connection onCreateIncomingHandoverConnection(PhoneAccountHandle
      fromPhoneAccountHandle, ConnectionRequest request) {
    if (!isHandoverAvailable()) {
        return null;
    }
    MyConnection connection = new MyConnection();
    connection.setAddress(request.getAddress(), TelecomManager.PRESENTATION_ALLOWED);
    connection.setVideoState(request.getVideoState());
    return connection;
  }
  </code>

Parameters
`fromPhoneAccountHandle`	PhoneAccountHandle!: `PhoneAccountHandle` associated with the ConnectionService which needs to handover the call.
`request`	ConnectionRequest!: Details about the call to handover.

Return
`Connection!`	`Connection` instance corresponding to the handover call.

onHandoverFailed

Added in API level 28

open fun onHandoverFailed(
    request: ConnectionRequest!, 
    error: Int
): Unit

Called by Telecom in response to a TelecomManager#acceptHandover() invocation which failed.

For a full discussion of the handover process and the APIs involved, see android.telecom.Call#handoverTo(PhoneAccountHandle, int, Bundle)

Parameters
`request`	ConnectionRequest!: Details about the call which failed to handover.
`error`	Int: Reason for handover failure. Will be one of the Value is `android.telecom.Call.Callback#HANDOVER_FAILURE_DEST_APP_REJECTED`, `android.telecom.Call.Callback#HANDOVER_FAILURE_NOT_SUPPORTED`, `android.telecom.Call.Callback#HANDOVER_FAILURE_USER_REJECTED`, `android.telecom.Call.Callback#HANDOVER_FAILURE_ONGOING_EMERGENCY_CALL`, or `android.telecom.Call.Callback#HANDOVER_FAILURE_UNKNOWN`

onRemoteConferenceAdded

Added in API level 23

open fun onRemoteConferenceAdded(conference: RemoteConference!): Unit

Indicates that a remote conference has been created for existing RemoteConnections. When this method is invoked, this ConnectionService should create its own representation of the conference call and send it to telecom using addConference.

This is only relevant to ConnectionServices which are registered with PhoneAccount#CAPABILITY_CONNECTION_MANAGER.

Parameters
`conference`	RemoteConference!: The remote conference call.

onRemoteExistingConnectionAdded

Added in API level 23

open fun onRemoteExistingConnectionAdded(connection: RemoteConnection!): Unit

Called when an existing connection is added remotely.

Parameters
`connection`	RemoteConnection!: The existing connection which was added.

onUnbind

Added in API level 23

open fun onUnbind(intent: Intent!): Boolean

Called when all clients have disconnected from a particular interface published by the service. The default implementation does nothing and returns false.

Parameters
`intent`	Intent!: The Intent that was used to bind to this service, as given to `Context.bindService`. Note that any extras that were included with the Intent at that point will not be seen here.

Return
`Boolean`	Return true if you would like to have the service's `onRebind` method later called when new clients bind to it.