It abstracts away the binding and unbinding from the remote implementation, so clients can * call its methods without worrying about when and how to bind/unbind/timeout. * *
All state of this class is modified on a handler thread. * *
NOTE: this class should not be extended directly, you should extend either * {@link AbstractSinglePendingRequestRemoteService} or * {@link AbstractMultiplePendingRequestsRemoteService}. * *
See {@code com.android.server.autofill.RemoteFillService} for a concrete
* (no pun intended) example of how to use it.
*
* @param Just need to be overridden by subclasses that uses sync {@link PendingRequest}s.
*
* @throws UnsupportedOperationException if called when not overridden.
*
*/
protected long getRemoteRequestMillis() {
throw new UnsupportedOperationException("not implemented by " + getClass());
}
/**
* Gets the currently registered service interface or {@code null} if the service is not
* connected.
*/
@Nullable
public final I getServiceInterface() {
return mService;
}
private void handleDestroy() {
if (checkIfDestroyed()) return;
handleOnDestroy();
handleEnsureUnbound();
mDestroyed = true;
}
/**
* Clears the state when this object is destroyed.
*
* Typically used to cancel the pending requests.
*/
protected abstract void handleOnDestroy();
@Override // from DeathRecipient
public void binderDied() {
mHandler.sendMessage(obtainMessage(AbstractRemoteService::handleBinderDied, this));
}
private void handleBinderDied() {
if (checkIfDestroyed()) return;
if (mService != null) {
mService.asBinder().unlinkToDeath(this, 0);
}
updateServicelicationExitInfo(mComponentName, mUserId);
mConnecting = true;
mService = null;
mServiceDied = true;
cancelScheduledUnbind();
@SuppressWarnings("unchecked") // TODO(b/117779333): fix this warning
final S castService = (S) this;
mVultureCallback.onServiceDied(castService);
handleBindFailure();
}
private void updateServicelicationExitInfo(ComponentName componentName, int userId) {
IActivityManager am = ActivityManager.getService();
String packageName = componentName.getPackageName();
ParceledListSlice This request must be responded by the service somehow (typically using a callback),
* othewise it will trigger a {@link PendingRequest#onTimeout(AbstractRemoteService)} if the
* service doesn't respond.
*/
protected void scheduleRequest(@NonNull BasePendingRequest This request is not expecting a callback from the service, hence it's represented by
* a simple {@link Runnable}.
*/
protected void scheduleAsyncRequest(@NonNull AsyncRequest request) {
// TODO(b/117779333): fix generics below
@SuppressWarnings({"unchecked", "rawtypes"})
final MyAsyncPendingRequest This request is not expecting a callback from the service, hence it's represented by
* a simple {@link Runnable}.
*/
protected void executeAsyncRequest(@NonNull AsyncRequest request) {
// TODO(b/117779333): fix generics below
@SuppressWarnings({"unchecked", "rawtypes"})
final MyAsyncPendingRequest Typically used on constructor for implementations that need a permanent connection to
* the remote service.
*/
protected void scheduleBind() {
if (mHandler.hasMessages(MSG_BIND)) {
if (mVerbose) Slog.v(mTag, "scheduleBind(): already scheduled");
return;
}
mHandler.sendMessage(obtainMessage(AbstractRemoteService::handleEnsureBound, this)
.setWhat(MSG_BIND));
}
/**
* Schedules a request to automatically unbind from the service after the
* {@link #getTimeoutIdleBindMillis() idle timeout} expires.
*/
protected void scheduleUnbind() {
scheduleUnbind(true);
}
private void scheduleUnbind(boolean delay) {
long unbindDelay = getTimeoutIdleBindMillis();
if (unbindDelay <= PERMANENT_BOUND_TIMEOUT_MS) {
if (mVerbose) Slog.v(mTag, "not scheduling unbind when value is " + unbindDelay);
return;
}
if (!delay) {
unbindDelay = 0;
}
cancelScheduledUnbind();
// TODO(b/117779333): make sure it's unbound if the service settings changing (right now
// it's not)
mNextUnbind = SystemClock.elapsedRealtime() + unbindDelay;
if (mVerbose) Slog.v(mTag, "unbinding in " + unbindDelay + "ms: " + mNextUnbind);
mHandler.sendMessageDelayed(obtainMessage(AbstractRemoteService::handleUnbind, this)
.setWhat(MSG_UNBIND), unbindDelay);
}
private void handleUnbind() {
if (checkIfDestroyed()) return;
handleEnsureUnbound();
}
/**
* Handles a request, either processing it right now when bound, or saving it to be handled when
* bound.
*/
protected final void handlePendingRequest(@NonNull BasePendingRequest NOTE: this class is not used directly, you should either override
* {@link com.android.internal.infra.AbstractRemoteService.PendingRequest} for sync requests, or
* use {@link AbstractRemoteService#scheduleAsyncRequest(AsyncRequest)} for async requests.
*
* @param NOTE: this class is typically used when the service needs to use a callback to
* communicate back with the system server. For cases where that's not needed, you should use
* {@link AbstractRemoteService#scheduleAsyncRequest(AsyncRequest)} instead.
*
* NOTE: you must override {@link AbstractRemoteService#getRemoteRequestMillis()},
* otherwise the constructor will throw an {@link UnsupportedOperationException}.
*
* @param the concrete remote service class
* @param the interface of the binder service
*
* @deprecated Use {@link ServiceConnector} to manage remote service connections
*
* @hide
*/
//TODO(b/117779333): improve javadoc above instead of using Autofill as an example
@Deprecated
public abstract class AbstractRemoteService,
I extends IInterface> implements DeathRecipient {
private static final int SERVICE_NOT_EXIST = -1;
private static final int MSG_BIND = 1;
private static final int MSG_UNBIND = 2;
public static final long PERMANENT_BOUND_TIMEOUT_MS = 0;
protected static final int LAST_PRIVATE_MSG = MSG_UNBIND;
// TODO(b/117779333): convert all booleans into an integer / flags
public final boolean mVerbose;
protected final String mTag = getClass().getSimpleName();
protected final Handler mHandler;
protected final ComponentName mComponentName;
private final Context mContext;
private final Intent mIntent;
private final VultureCallback mVultureCallback;
private final int mUserId;
private final ServiceConnection mServiceConnection = new RemoteServiceConnection();
private final int mBindingFlags;
protected I mService;
private boolean mBound;
private boolean mConnecting;
private boolean mDestroyed;
private boolean mServiceDied;
private boolean mCompleted;
// Used just for debugging purposes (on dump)
private long mNextUnbind;
// Used just for debugging purposes (on dump)
private int mServiceExitReason;
private int mServiceExitSubReason;
/** Requests that have been scheduled, but that are not finished yet */
protected final ArrayList callback,
@NonNull Handler handler, int bindingFlags, boolean verbose) {
mContext = context;
mVultureCallback = callback;
mVerbose = verbose;
mComponentName = componentName;
mIntent = new Intent(serviceInterface).setComponent(mComponentName);
mUserId = userId;
mHandler = new Handler(handler.getLooper());
mBindingFlags = bindingFlags;
mServiceExitReason = SERVICE_NOT_EXIST;
mServiceExitSubReason = SERVICE_NOT_EXIST;
}
/**
* Destroys this service.
*/
public final void destroy() {
mHandler.sendMessage(obtainMessage(AbstractRemoteService::handleDestroy, this));
}
/**
* Checks whether this service is destroyed.
*/
public final boolean isDestroyed() {
return mDestroyed;
}
/**
* Gets the name of the service.
*/
@NonNull
public final ComponentName getComponentName() {
return mComponentName;
}
private void handleOnConnectedStateChangedInternal(boolean connected) {
handleOnConnectedStateChanged(connected);
if (connected) {
handlePendingRequests();
}
}
/**
* Handles the pending requests when the connection it bounds to the remote service.
*/
abstract void handlePendingRequests();
/**
* Callback called when the system connected / disconnected to the service and the pending
* requests have been handled.
*
* @param state {@code true} when connected, {@code false} when disconnected.
*/
protected void handleOnConnectedStateChanged(boolean state) {
}
/**
* Gets the base Binder interface from the service.
*/
@NonNull
protected abstract I getServiceInterface(@NonNull IBinder service);
/**
* Defines how long after the last interaction with the service we would unbind.
*
* @return time to unbind (in millis), or {@link #PERMANENT_BOUND_TIMEOUT_MS} to not unbind.
*/
protected abstract long getTimeoutIdleBindMillis();
/**
* Defines how long after we make a remote request to a fill service we timeout.
*
* the remote service class
* @param the interface of the binder service
*/
public abstract static class BasePendingRequest,
I extends IInterface> implements Runnable {
protected final String mTag = getClass().getSimpleName();
protected final Object mLock = new Object();
final WeakReference mWeakService;
@GuardedBy("mLock")
boolean mCancelled;
@GuardedBy("mLock")
boolean mCompleted;
BasePendingRequest(@NonNull S service) {
mWeakService = new WeakReference<>(service);
}
/**
* Gets a reference to the remote service.
*/
protected final S getService() {
return mWeakService.get();
}
/**
* Subclasses must call this method when the remote service finishes, i.e., when the service
* finishes processing a request.
*
* @return {@code false} in the service is already finished, {@code true} otherwise.
*/
protected final boolean finish() {
synchronized (mLock) {
if (mCompleted || mCancelled) {
return false;
}
mCompleted = true;
}
S service = mWeakService.get();
if (service != null) {
service.finishRequest(this);
}
onFinished();
return true;
}
void onFinished() { }
/**
* Called when request fails due to reasons internal to {@link AbstractRemoteService},
* e.g. failure to bind to service.
*/
protected void onFailed() { }
/**
* Checks whether this request was cancelled.
*/
@GuardedBy("mLock")
protected final boolean isCancelledLocked() {
return mCancelled;
}
/**
* Cancels the service.
*
* @return {@code false} if service is already canceled, {@code true} otherwise.
*/
public boolean cancel() {
synchronized (mLock) {
if (mCancelled || mCompleted) {
return false;
}
mCancelled = true;
}
S service = mWeakService.get();
if (service != null) {
service.finishRequest(this);
}
onCancel();
return true;
}
void onCancel() {}
/**
* Checks whether this request leads to a final state where no other requests can be made.
*/
protected boolean isFinal() {
return false;
}
protected boolean isRequestCompleted() {
synchronized (mLock) {
return mCompleted;
}
}
}
/**
* Base class for the requests serviced by the remote service.
*
* the remote service class
* @param the interface of the binder service
*/
public abstract static class PendingRequest,
I extends IInterface> extends BasePendingRequest,
I extends IInterface> extends BasePendingRequest