/**
|
* Copyright (c) 2016, The Android Open Source Project
|
*
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
* you may not use this file except in compliance with the License.
|
* You may obtain a copy of the License at
|
*
|
* http://www.apache.org/licenses/LICENSE-2.0
|
*
|
* Unless required by applicable law or agreed to in writing, software
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
* See the License for the specific language governing permissions and
|
* limitations under the License.
|
*/
|
package com.android.server.utils;
|
|
import android.annotation.NonNull;
|
import android.annotation.Nullable;
|
import android.app.PendingIntent;
|
import android.content.ComponentName;
|
import android.content.Context;
|
import android.content.Intent;
|
import android.content.ServiceConnection;
|
import android.os.Handler;
|
import android.os.IBinder;
|
import android.os.IBinder.DeathRecipient;
|
import android.os.IInterface;
|
import android.os.RemoteException;
|
import android.os.SystemClock;
|
import android.os.UserHandle;
|
import android.util.Slog;
|
|
import java.text.SimpleDateFormat;
|
import java.util.Objects;
|
import java.util.Date;
|
|
/**
|
* Manages the lifecycle of an application-provided service bound from system server.
|
*
|
* @hide
|
*/
|
public class ManagedApplicationService {
|
private final String TAG = getClass().getSimpleName();
|
|
/**
|
* Attempt to reconnect service forever if an onBindingDied or onServiceDisconnected event
|
* is received.
|
*/
|
public static final int RETRY_FOREVER = 1;
|
|
/**
|
* Never attempt to reconnect the service - a single onBindingDied or onServiceDisconnected
|
* event will cause this to fully unbind the service and never attempt to reconnect.
|
*/
|
public static final int RETRY_NEVER = 2;
|
|
/**
|
* Attempt to reconnect the service until the maximum number of retries is reached, then stop.
|
*
|
* The first retry will occur MIN_RETRY_DURATION_MS after the disconnection, and each
|
* subsequent retry will occur after 2x the duration used for the previous retry up to the
|
* MAX_RETRY_DURATION_MS duration.
|
*
|
* In this case, retries mean a full unbindService/bindService pair to handle cases when the
|
* usual service re-connection logic in ActiveServices has very high backoff times or when the
|
* serviceconnection has fully died due to a package update or similar.
|
*/
|
public static final int RETRY_BEST_EFFORT = 3;
|
|
// Maximum number of retries before giving up (for RETRY_BEST_EFFORT).
|
private static final int MAX_RETRY_COUNT = 4;
|
// Max time between retry attempts.
|
private static final long MAX_RETRY_DURATION_MS = 16000;
|
// Min time between retry attempts.
|
private static final long MIN_RETRY_DURATION_MS = 2000;
|
// Time since the last retry attempt after which to clear the retry attempt counter.
|
private static final long RETRY_RESET_TIME_MS = MAX_RETRY_DURATION_MS * 4;
|
|
private final Context mContext;
|
private final int mUserId;
|
private final ComponentName mComponent;
|
private final int mClientLabel;
|
private final String mSettingsAction;
|
private final BinderChecker mChecker;
|
private final boolean mIsImportant;
|
private final int mRetryType;
|
private final Handler mHandler;
|
private final Runnable mRetryRunnable = this::doRetry;
|
private final EventCallback mEventCb;
|
|
private final Object mLock = new Object();
|
|
// State protected by mLock
|
private ServiceConnection mConnection;
|
private IInterface mBoundInterface;
|
private PendingEvent mPendingEvent;
|
private int mRetryCount;
|
private long mLastRetryTimeMs;
|
private long mNextRetryDurationMs = MIN_RETRY_DURATION_MS;
|
private boolean mRetrying;
|
|
public static interface LogFormattable {
|
String toLogString(SimpleDateFormat dateFormat);
|
}
|
|
/**
|
* Lifecycle event of this managed service.
|
*/
|
public static class LogEvent implements LogFormattable {
|
public static final int EVENT_CONNECTED = 1;
|
public static final int EVENT_DISCONNECTED = 2;
|
public static final int EVENT_BINDING_DIED = 3;
|
public static final int EVENT_STOPPED_PERMANENTLY = 4;
|
|
// Time of the events in "current time ms" timebase.
|
public final long timestamp;
|
// Name of the component for this system service.
|
public final ComponentName component;
|
// ID of the event that occurred.
|
public final int event;
|
|
public LogEvent(long timestamp, ComponentName component, int event) {
|
this.timestamp = timestamp;
|
this.component = component;
|
this.event = event;
|
}
|
|
@Override
|
public String toLogString(SimpleDateFormat dateFormat) {
|
return dateFormat.format(new Date(timestamp)) + " " + eventToString(event)
|
+ " Managed Service: "
|
+ ((component == null) ? "None" : component.flattenToString());
|
}
|
|
public static String eventToString(int event) {
|
switch (event) {
|
case EVENT_CONNECTED:
|
return "Connected";
|
case EVENT_DISCONNECTED:
|
return "Disconnected";
|
case EVENT_BINDING_DIED:
|
return "Binding Died For";
|
case EVENT_STOPPED_PERMANENTLY:
|
return "Permanently Stopped";
|
default:
|
return "Unknown Event Occurred";
|
}
|
}
|
}
|
|
private ManagedApplicationService(final Context context, final ComponentName component,
|
final int userId, int clientLabel, String settingsAction,
|
BinderChecker binderChecker, boolean isImportant, int retryType, Handler handler,
|
EventCallback eventCallback) {
|
mContext = context;
|
mComponent = component;
|
mUserId = userId;
|
mClientLabel = clientLabel;
|
mSettingsAction = settingsAction;
|
mChecker = binderChecker;
|
mIsImportant = isImportant;
|
mRetryType = retryType;
|
mHandler = handler;
|
mEventCb = eventCallback;
|
}
|
|
/**
|
* Implement to validate returned IBinder instance.
|
*/
|
public interface BinderChecker {
|
IInterface asInterface(IBinder binder);
|
boolean checkType(IInterface service);
|
}
|
|
/**
|
* Implement to call IInterface methods after service is connected.
|
*/
|
public interface PendingEvent {
|
void runEvent(IInterface service) throws RemoteException;
|
}
|
|
/**
|
* Implement to be notified about any problems with remote service.
|
*/
|
public interface EventCallback {
|
/**
|
* Called when an sevice lifecycle event occurs.
|
*/
|
void onServiceEvent(LogEvent event);
|
}
|
|
/**
|
* Create a new ManagedApplicationService object but do not yet bind to the user service.
|
*
|
* @param context a Context to use for binding the application service.
|
* @param component the {@link ComponentName} of the application service to bind.
|
* @param userId the user ID of user to bind the application service as.
|
* @param clientLabel the resource ID of a label displayed to the user indicating the
|
* binding service, or 0 if none is desired.
|
* @param settingsAction an action that can be used to open the Settings UI to enable/disable
|
* binding to these services, or null if none is desired.
|
* @param binderChecker an interface used to validate the returned binder object, or null if
|
* this interface is unchecked.
|
* @param isImportant bind the user service with BIND_IMPORTANT.
|
* @param retryType reconnect behavior to have when bound service is disconnected.
|
* @param handler the Handler to use for retries and delivering EventCallbacks.
|
* @param eventCallback a callback used to deliver disconnection events, or null if you
|
* don't care.
|
* @return a ManagedApplicationService instance.
|
*/
|
public static ManagedApplicationService build(@NonNull final Context context,
|
@NonNull final ComponentName component, final int userId, int clientLabel,
|
@Nullable String settingsAction, @Nullable BinderChecker binderChecker,
|
boolean isImportant, int retryType, @NonNull Handler handler,
|
@Nullable EventCallback eventCallback) {
|
return new ManagedApplicationService(context, component, userId, clientLabel,
|
settingsAction, binderChecker, isImportant, retryType, handler, eventCallback);
|
}
|
|
|
/**
|
* @return the user ID of the user that owns the bound service.
|
*/
|
public int getUserId() {
|
return mUserId;
|
}
|
|
/**
|
* @return the component of the bound service.
|
*/
|
public ComponentName getComponent() {
|
return mComponent;
|
}
|
|
/**
|
* Asynchronously unbind from the application service if the bound service component and user
|
* does not match the given signature.
|
*
|
* @param componentName the component that must match.
|
* @param userId the user ID that must match.
|
* @return {@code true} if not matching.
|
*/
|
public boolean disconnectIfNotMatching(final ComponentName componentName, final int userId) {
|
if (matches(componentName, userId)) {
|
return false;
|
}
|
disconnect();
|
return true;
|
}
|
|
/**
|
* Send an event to run as soon as the binder interface is available.
|
*
|
* @param event a {@link PendingEvent} to send.
|
*/
|
public void sendEvent(@NonNull PendingEvent event) {
|
IInterface iface;
|
synchronized (mLock) {
|
iface = mBoundInterface;
|
if (iface == null) {
|
mPendingEvent = event;
|
}
|
}
|
|
if (iface != null) {
|
try {
|
event.runEvent(iface);
|
} catch (RuntimeException | RemoteException ex) {
|
Slog.e(TAG, "Received exception from user service: ", ex);
|
}
|
}
|
}
|
|
/**
|
* Asynchronously unbind from the application service if bound.
|
*/
|
public void disconnect() {
|
synchronized (mLock) {
|
// Unbind existing connection, if it exists
|
if (mConnection == null) {
|
return;
|
}
|
|
mContext.unbindService(mConnection);
|
mConnection = null;
|
mBoundInterface = null;
|
}
|
}
|
|
/**
|
* Asynchronously bind to the application service if not bound.
|
*/
|
public void connect() {
|
synchronized (mLock) {
|
if (mConnection != null) {
|
// We're already connected or are trying to connect
|
return;
|
}
|
|
Intent intent = new Intent().setComponent(mComponent);
|
if (mClientLabel != 0) {
|
intent.putExtra(Intent.EXTRA_CLIENT_LABEL, mClientLabel);
|
}
|
if (mSettingsAction != null) {
|
intent.putExtra(Intent.EXTRA_CLIENT_INTENT,
|
PendingIntent.getActivity(mContext, 0, new Intent(mSettingsAction), 0));
|
}
|
|
mConnection = new ServiceConnection() {
|
@Override
|
public void onBindingDied(ComponentName componentName) {
|
final long timestamp = System.currentTimeMillis();
|
Slog.w(TAG, "Service binding died: " + componentName);
|
synchronized (mLock) {
|
if (mConnection != this) {
|
return;
|
}
|
mHandler.post(() -> {
|
mEventCb.onServiceEvent(new LogEvent(timestamp, mComponent,
|
LogEvent.EVENT_BINDING_DIED));
|
});
|
|
mBoundInterface = null;
|
startRetriesLocked();
|
}
|
}
|
|
@Override
|
public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
|
final long timestamp = System.currentTimeMillis();
|
Slog.i(TAG, "Service connected: " + componentName);
|
IInterface iface = null;
|
PendingEvent pendingEvent = null;
|
synchronized (mLock) {
|
if (mConnection != this) {
|
// Must've been unbound.
|
return;
|
}
|
mHandler.post(() -> {
|
mEventCb.onServiceEvent(new LogEvent(timestamp, mComponent,
|
LogEvent.EVENT_CONNECTED));
|
});
|
|
stopRetriesLocked();
|
|
mBoundInterface = null;
|
if (mChecker != null) {
|
mBoundInterface = mChecker.asInterface(iBinder);
|
if (!mChecker.checkType(mBoundInterface)) {
|
// Received an invalid binder, disconnect.
|
mBoundInterface = null;
|
Slog.w(TAG, "Invalid binder from " + componentName);
|
startRetriesLocked();
|
return;
|
}
|
iface = mBoundInterface;
|
pendingEvent = mPendingEvent;
|
mPendingEvent = null;
|
}
|
}
|
if (iface != null && pendingEvent != null) {
|
try {
|
pendingEvent.runEvent(iface);
|
} catch (RuntimeException | RemoteException ex) {
|
Slog.e(TAG, "Received exception from user service: ", ex);
|
startRetriesLocked();
|
}
|
}
|
}
|
|
@Override
|
public void onServiceDisconnected(ComponentName componentName) {
|
final long timestamp = System.currentTimeMillis();
|
Slog.w(TAG, "Service disconnected: " + componentName);
|
synchronized (mLock) {
|
if (mConnection != this) {
|
return;
|
}
|
|
mHandler.post(() -> {
|
mEventCb.onServiceEvent(new LogEvent(timestamp, mComponent,
|
LogEvent.EVENT_DISCONNECTED));
|
});
|
|
mBoundInterface = null;
|
startRetriesLocked();
|
}
|
}
|
};
|
|
int flags = Context.BIND_AUTO_CREATE | Context.BIND_FOREGROUND_SERVICE;
|
if (mIsImportant) {
|
flags |= Context.BIND_IMPORTANT;
|
}
|
try {
|
if (!mContext.bindServiceAsUser(intent, mConnection, flags,
|
new UserHandle(mUserId))) {
|
Slog.w(TAG, "Unable to bind service: " + intent);
|
startRetriesLocked();
|
}
|
} catch (SecurityException e) {
|
Slog.w(TAG, "Unable to bind service: " + intent, e);
|
startRetriesLocked();
|
}
|
}
|
}
|
|
private boolean matches(final ComponentName component, final int userId) {
|
return Objects.equals(mComponent, component) && mUserId == userId;
|
}
|
|
private void startRetriesLocked() {
|
if (checkAndDeliverServiceDiedCbLocked()) {
|
// If we delivered the service callback, disconnect and stop retrying.
|
disconnect();
|
return;
|
}
|
|
if (mRetrying) {
|
// Retry already queued, don't queue a new one.
|
return;
|
}
|
mRetrying = true;
|
queueRetryLocked();
|
}
|
|
private void stopRetriesLocked() {
|
mRetrying = false;
|
mHandler.removeCallbacks(mRetryRunnable);
|
}
|
|
private void queueRetryLocked() {
|
long now = SystemClock.uptimeMillis();
|
if ((now - mLastRetryTimeMs) > RETRY_RESET_TIME_MS) {
|
// It's been longer than the reset time since we last had to retry. Re-initialize.
|
mNextRetryDurationMs = MIN_RETRY_DURATION_MS;
|
mRetryCount = 0;
|
}
|
mLastRetryTimeMs = now;
|
mHandler.postDelayed(mRetryRunnable, mNextRetryDurationMs);
|
mNextRetryDurationMs = Math.min(2 * mNextRetryDurationMs, MAX_RETRY_DURATION_MS);
|
mRetryCount++;
|
}
|
|
private boolean checkAndDeliverServiceDiedCbLocked() {
|
|
if (mRetryType == RETRY_NEVER || (mRetryType == RETRY_BEST_EFFORT
|
&& mRetryCount >= MAX_RETRY_COUNT)) {
|
// If we never retry, or we've exhausted our retries, post the onServiceDied callback.
|
Slog.e(TAG, "Service " + mComponent + " has died too much, not retrying.");
|
if (mEventCb != null) {
|
final long timestamp = System.currentTimeMillis();
|
mHandler.post(() -> {
|
mEventCb.onServiceEvent(new LogEvent(timestamp, mComponent,
|
LogEvent.EVENT_STOPPED_PERMANENTLY));
|
});
|
}
|
return true;
|
}
|
return false;
|
}
|
|
private void doRetry() {
|
synchronized (mLock) {
|
if (mConnection == null) {
|
// We disconnected for good. Don't attempt to retry.
|
return;
|
}
|
if (!mRetrying) {
|
// We successfully connected. Don't attempt to retry.
|
return;
|
}
|
Slog.i(TAG, "Attempting to reconnect " + mComponent + "...");
|
// While frameworks may restart the remote Service if we stay bound, we have little
|
// control of the backoff timing for reconnecting the service. In the event of a
|
// process crash, the backoff time can be very large (1-30 min), which is not
|
// acceptable for the types of services this is used for. Instead force an unbind/bind
|
// sequence to cause a more immediate retry.
|
disconnect();
|
if (checkAndDeliverServiceDiedCbLocked()) {
|
// No more retries.
|
return;
|
}
|
queueRetryLocked();
|
connect();
|
}
|
}
|
}
|
