SocketKeepalive
abstract class SocketKeepalive : AutoCloseable
| kotlin.Any | |
| ↳ | android.net.SocketKeepalive |
Allows applications to request that the system periodically send specific packets on their behalf, using hardware offload to save battery power. To request that the system send keepalives, call one of the methods that return a SocketKeepalive object, such as ConnectivityManager#createSocketKeepalive, passing in a non-null callback. If the SocketKeepalive is successfully started, the callback's onStarted method will be called. If an error occurs, onError will be called, specifying one of the ERROR_* constants in this class. To stop an existing keepalive, call SocketKeepalive#stop. The system will call SocketKeepalive.Callback#onStopped if the operation was successful or SocketKeepalive.Callback#onError if an error occurred. For cellular, the device MUST support at least 1 keepalive slot. For WiFi, the device SHOULD support keepalive offload. If it does not, it MUST reply with SocketKeepalive.Callback#onError with ERROR_UNSUPPORTED to any keepalive offload request. If it does, it MUST support at least 3 concurrent keepalive slots.
Summary
| Nested classes | |
|---|---|
| open |
The callback which app can use to learn the status changes of |
| Constants | |
|---|---|
| static Int |
There was a hardware error. |
| static Int |
Resources are insufficient (e.g. all hardware slots are in use). |
| static Int |
The interval is invalid (e.g. too short). |
| static Int |
The invalid IP addresses. |
| static Int |
The length is invalid (e.g. too long). |
| static Int |
The invalid network. |
| static Int |
The port is invalid. |
| static Int |
The socket is invalid. |
| static Int |
The socket is not idle. |
| static Int |
The request is unsupported. |
| Public methods | |
|---|---|
| Unit |
close()Deactivate this |
| Unit |
Request that keepalive be started with the given |
| Unit |
stop()Requests that keepalive be stopped. |
Constants
ERROR_HARDWARE_ERROR
static val ERROR_HARDWARE_ERROR: Int
There was a hardware error.
Value: -31
ERROR_INSUFFICIENT_RESOURCES
static val ERROR_INSUFFICIENT_RESOURCES: Int
Resources are insufficient (e.g. all hardware slots are in use).
Value: -32
ERROR_INVALID_INTERVAL
static val ERROR_INVALID_INTERVAL: Int
The interval is invalid (e.g. too short).
Value: -24
ERROR_INVALID_IP_ADDRESS
static val ERROR_INVALID_IP_ADDRESS: Int
The invalid IP addresses. Indicates the specified IP addresses are invalid. For example, the specified source IP address is not configured on the specified Network.
Value: -21
ERROR_INVALID_LENGTH
static val ERROR_INVALID_LENGTH: Int
The length is invalid (e.g. too long).
Value: -23
ERROR_INVALID_NETWORK
static val ERROR_INVALID_NETWORK: Int
The invalid network. It indicates the specified Network is not connected.
Value: -20
ERROR_INVALID_PORT
static val ERROR_INVALID_PORT: Int
The port is invalid.
Value: -22
ERROR_INVALID_SOCKET
static val ERROR_INVALID_SOCKET: Int
The socket is invalid.
Value: -25
ERROR_SOCKET_NOT_IDLE
static val ERROR_SOCKET_NOT_IDLE: Int
The socket is not idle.
Value: -26
ERROR_UNSUPPORTED
static val ERROR_UNSUPPORTED: Int
The request is unsupported.
Value: -30
Public methods
close
fun close(): Unit
Deactivate this SocketKeepalive and free allocated resources. The instance won't be usable again if close() is called.
| Exceptions | |
|---|---|
java.lang.Exception |
if this resource cannot be closed |
start
fun start(intervalSec: Int): Unit
Request that keepalive be started with the given intervalSec. See SocketKeepalive. If the remote binder dies, or the binder call throws an exception when invoking start or stop of the SocketKeepalive, a RuntimeException caused by a RemoteException will be thrown into the Executor. This is typically not important to catch because the remote party is the system, so if it is not in shape to communicate through binder the system is going down anyway. If the caller still cares, it can use a custom Executor to catch the RuntimeException.
| Parameters | |
|---|---|
intervalSec |
Int: The target interval in seconds between keepalive packet transmissions. The interval should be between 10 seconds and 3600 seconds, otherwise ERROR_INVALID_INTERVAL will be returned. Value is between MIN_INTERVAL_SEC and MAX_INTERVAL_SEC inclusive |
stop
fun stop(): Unit
Requests that keepalive be stopped. The application must wait for Callback#onStopped before using the object. See SocketKeepalive.