/*
|
* Copyright (C) 2019 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.attention;
|
|
import static android.provider.DeviceConfig.NAMESPACE_ATTENTION_MANAGER_SERVICE;
|
import static android.service.attention.AttentionService.ATTENTION_FAILURE_CANCELLED;
|
import static android.service.attention.AttentionService.ATTENTION_FAILURE_UNKNOWN;
|
|
import android.Manifest;
|
import android.annotation.Nullable;
|
import android.annotation.UserIdInt;
|
import android.app.ActivityManager;
|
import android.attention.AttentionManagerInternal;
|
import android.attention.AttentionManagerInternal.AttentionCallbackInternal;
|
import android.content.BroadcastReceiver;
|
import android.content.ComponentName;
|
import android.content.Context;
|
import android.content.Intent;
|
import android.content.IntentFilter;
|
import android.content.ServiceConnection;
|
import android.content.pm.PackageManager;
|
import android.content.pm.ResolveInfo;
|
import android.content.pm.ServiceInfo;
|
import android.os.Binder;
|
import android.os.Handler;
|
import android.os.IBinder;
|
import android.os.Looper;
|
import android.os.Message;
|
import android.os.PowerManager;
|
import android.os.RemoteException;
|
import android.os.ResultReceiver;
|
import android.os.ShellCallback;
|
import android.os.ShellCommand;
|
import android.os.SystemClock;
|
import android.os.UserHandle;
|
import android.provider.DeviceConfig;
|
import android.service.attention.AttentionService;
|
import android.service.attention.AttentionService.AttentionFailureCodes;
|
import android.service.attention.AttentionService.AttentionSuccessCodes;
|
import android.service.attention.IAttentionCallback;
|
import android.service.attention.IAttentionService;
|
import android.text.TextUtils;
|
import android.util.Slog;
|
import android.util.SparseArray;
|
import android.util.StatsLog;
|
|
import com.android.internal.annotations.GuardedBy;
|
import com.android.internal.annotations.VisibleForTesting;
|
import com.android.internal.util.DumpUtils;
|
import com.android.internal.util.IndentingPrintWriter;
|
import com.android.internal.util.Preconditions;
|
import com.android.server.SystemService;
|
|
import java.io.FileDescriptor;
|
import java.io.PrintWriter;
|
|
/**
|
* An attention service implementation that runs in System Server process.
|
* This service publishes a LocalService and reroutes calls to a {@link AttentionService} that it
|
* manages.
|
*/
|
public class AttentionManagerService extends SystemService {
|
private static final String LOG_TAG = "AttentionManagerService";
|
private static final boolean DEBUG = false;
|
|
/** Default value in absence of {@link DeviceConfig} override. */
|
private static final boolean DEFAULT_SERVICE_ENABLED = true;
|
|
/** Service will unbind if connection is not used for that amount of time. */
|
private static final long CONNECTION_TTL_MILLIS = 60_000;
|
|
/** If the check attention called within that period - cached value will be returned. */
|
private static final long STALE_AFTER_MILLIS = 5_000;
|
|
/** DeviceConfig flag name, if {@code true}, enables AttentionManagerService features. */
|
private static final String SERVICE_ENABLED = "service_enabled";
|
private static String sTestAttentionServicePackage;
|
private final Context mContext;
|
private final PowerManager mPowerManager;
|
private final Object mLock;
|
@GuardedBy("mLock")
|
private final SparseArray<UserState> mUserStates = new SparseArray<>();
|
private AttentionHandler mAttentionHandler;
|
|
@VisibleForTesting
|
ComponentName mComponentName;
|
|
public AttentionManagerService(Context context) {
|
this(context, (PowerManager) context.getSystemService(Context.POWER_SERVICE),
|
new Object(), null);
|
mAttentionHandler = new AttentionHandler();
|
}
|
|
@VisibleForTesting
|
AttentionManagerService(Context context, PowerManager powerManager, Object lock,
|
AttentionHandler handler) {
|
super(context);
|
mContext = Preconditions.checkNotNull(context);
|
mPowerManager = powerManager;
|
mLock = lock;
|
mAttentionHandler = handler;
|
}
|
|
@Override
|
public void onBootPhase(int phase) {
|
if (phase == SystemService.PHASE_SYSTEM_SERVICES_READY) {
|
mContext.registerReceiver(new ScreenStateReceiver(),
|
new IntentFilter(Intent.ACTION_SCREEN_OFF));
|
}
|
}
|
|
@Override
|
public void onStart() {
|
publishBinderService(Context.ATTENTION_SERVICE, new BinderService());
|
publishLocalService(AttentionManagerInternal.class, new LocalService());
|
}
|
|
@Override
|
public void onSwitchUser(int userId) {
|
cancelAndUnbindLocked(peekUserStateLocked(userId));
|
}
|
|
/** Returns {@code true} if attention service is configured on this device. */
|
public static boolean isServiceConfigured(Context context) {
|
return !TextUtils.isEmpty(getServiceConfigPackage(context));
|
}
|
|
/** Resolves and sets up the attention service if it had not been done yet. */
|
private boolean isServiceAvailable() {
|
if (mComponentName == null) {
|
mComponentName = resolveAttentionService(mContext);
|
}
|
return mComponentName != null;
|
}
|
|
/**
|
* Returns {@code true} if attention service is supported on this device.
|
*/
|
private boolean isAttentionServiceSupported() {
|
return isServiceEnabled() && isServiceAvailable();
|
}
|
|
@VisibleForTesting
|
protected boolean isServiceEnabled() {
|
return DeviceConfig.getBoolean(NAMESPACE_ATTENTION_MANAGER_SERVICE, SERVICE_ENABLED,
|
DEFAULT_SERVICE_ENABLED);
|
}
|
|
/**
|
* Checks whether user attention is at the screen and calls in the provided callback.
|
*
|
* Calling this multiple times quickly in a row will result in either a) returning a cached
|
* value, if present, or b) returning {@code false} because only one active request at a time is
|
* allowed.
|
*
|
* @return {@code true} if the framework was able to dispatch the request
|
*/
|
@VisibleForTesting
|
boolean checkAttention(long timeout, AttentionCallbackInternal callbackInternal) {
|
Preconditions.checkNotNull(callbackInternal);
|
|
if (!isAttentionServiceSupported()) {
|
Slog.w(LOG_TAG, "Trying to call checkAttention() on an unsupported device.");
|
return false;
|
}
|
|
// don't allow attention check in screen off state
|
if (!mPowerManager.isInteractive()) {
|
return false;
|
}
|
|
synchronized (mLock) {
|
final long now = SystemClock.uptimeMillis();
|
// schedule shutting down the connection if no one resets this timer
|
freeIfInactiveLocked();
|
|
final UserState userState = getOrCreateCurrentUserStateLocked();
|
// lazily start the service, which should be very lightweight to start
|
userState.bindLocked();
|
|
// throttle frequent requests
|
final AttentionCheckCache cache = userState.mAttentionCheckCache;
|
if (cache != null && now < cache.mLastComputed + STALE_AFTER_MILLIS) {
|
callbackInternal.onSuccess(cache.mResult, cache.mTimestamp);
|
return true;
|
}
|
|
// prevent spamming with multiple requests, only one at a time is allowed
|
if (userState.mCurrentAttentionCheck != null) {
|
if (!userState.mCurrentAttentionCheck.mIsDispatched
|
|| !userState.mCurrentAttentionCheck.mIsFulfilled) {
|
return false;
|
}
|
}
|
|
userState.mCurrentAttentionCheck = createAttentionCheck(callbackInternal, userState);
|
|
if (userState.mService != null) {
|
try {
|
// schedule request cancellation if not returned by that point yet
|
cancelAfterTimeoutLocked(timeout);
|
userState.mService.checkAttention(
|
userState.mCurrentAttentionCheck.mIAttentionCallback);
|
userState.mCurrentAttentionCheck.mIsDispatched = true;
|
} catch (RemoteException e) {
|
Slog.e(LOG_TAG, "Cannot call into the AttentionService");
|
return false;
|
}
|
}
|
return true;
|
}
|
}
|
|
private AttentionCheck createAttentionCheck(AttentionCallbackInternal callbackInternal,
|
UserState userState) {
|
final IAttentionCallback iAttentionCallback = new IAttentionCallback.Stub() {
|
@Override
|
public void onSuccess(@AttentionSuccessCodes int result, long timestamp) {
|
// the callback might have been cancelled already
|
if (!userState.mCurrentAttentionCheck.mIsFulfilled) {
|
callbackInternal.onSuccess(result, timestamp);
|
userState.mCurrentAttentionCheck.mIsFulfilled = true;
|
}
|
|
synchronized (mLock) {
|
userState.mAttentionCheckCache = new AttentionCheckCache(
|
SystemClock.uptimeMillis(), result,
|
timestamp);
|
}
|
StatsLog.write(
|
StatsLog.ATTENTION_MANAGER_SERVICE_RESULT_REPORTED,
|
result);
|
}
|
|
@Override
|
public void onFailure(@AttentionFailureCodes int error) {
|
// the callback might have been cancelled already
|
if (!userState.mCurrentAttentionCheck.mIsFulfilled) {
|
callbackInternal.onFailure(error);
|
userState.mCurrentAttentionCheck.mIsFulfilled = true;
|
}
|
|
StatsLog.write(
|
StatsLog.ATTENTION_MANAGER_SERVICE_RESULT_REPORTED,
|
error);
|
}
|
};
|
|
return new AttentionCheck(callbackInternal, iAttentionCallback);
|
}
|
|
/** Cancels the specified attention check. */
|
@VisibleForTesting
|
void cancelAttentionCheck(AttentionCallbackInternal callbackInternal) {
|
synchronized (mLock) {
|
final UserState userState = peekCurrentUserStateLocked();
|
if (userState == null) {
|
return;
|
}
|
if (!userState.mCurrentAttentionCheck.mCallbackInternal.equals(callbackInternal)) {
|
Slog.w(LOG_TAG, "Cannot cancel a non-current request");
|
return;
|
}
|
cancel(userState);
|
}
|
}
|
|
@GuardedBy("mLock")
|
@VisibleForTesting
|
protected void freeIfInactiveLocked() {
|
// If we are called here, it means someone used the API again - reset the timer then.
|
mAttentionHandler.removeMessages(AttentionHandler.CHECK_CONNECTION_EXPIRATION);
|
|
// Schedule resources cleanup if no one calls the API again.
|
mAttentionHandler.sendEmptyMessageDelayed(AttentionHandler.CHECK_CONNECTION_EXPIRATION,
|
CONNECTION_TTL_MILLIS);
|
}
|
|
@GuardedBy("mLock")
|
private void cancelAfterTimeoutLocked(long timeout) {
|
mAttentionHandler.sendEmptyMessageDelayed(AttentionHandler.ATTENTION_CHECK_TIMEOUT,
|
timeout);
|
}
|
|
|
@GuardedBy("mLock")
|
@VisibleForTesting
|
protected UserState getOrCreateCurrentUserStateLocked() {
|
return getOrCreateUserStateLocked(ActivityManager.getCurrentUser());
|
}
|
|
@GuardedBy("mLock")
|
@VisibleForTesting
|
protected UserState getOrCreateUserStateLocked(int userId) {
|
UserState result = mUserStates.get(userId);
|
if (result == null) {
|
result = new UserState(userId, mContext, mLock, mAttentionHandler, mComponentName);
|
mUserStates.put(userId, result);
|
}
|
return result;
|
}
|
|
@GuardedBy("mLock")
|
@Nullable
|
@VisibleForTesting
|
protected UserState peekCurrentUserStateLocked() {
|
return peekUserStateLocked(ActivityManager.getCurrentUser());
|
}
|
|
@GuardedBy("mLock")
|
@Nullable
|
private UserState peekUserStateLocked(int userId) {
|
return mUserStates.get(userId);
|
}
|
|
private static String getServiceConfigPackage(Context context) {
|
return context.getPackageManager().getAttentionServicePackageName();
|
}
|
|
/**
|
* Provides attention service component name at runtime, making sure it's provided by the
|
* system.
|
*/
|
private static ComponentName resolveAttentionService(Context context) {
|
final String serviceConfigPackage = getServiceConfigPackage(context);
|
|
String resolvedPackage;
|
int flags = PackageManager.MATCH_SYSTEM_ONLY;
|
if (!TextUtils.isEmpty(sTestAttentionServicePackage)) {
|
resolvedPackage = sTestAttentionServicePackage;
|
flags = PackageManager.GET_META_DATA;
|
} else if (!TextUtils.isEmpty(serviceConfigPackage)) {
|
resolvedPackage = serviceConfigPackage;
|
} else {
|
return null;
|
}
|
|
final Intent intent = new Intent(AttentionService.SERVICE_INTERFACE).setPackage(
|
resolvedPackage);
|
|
final ResolveInfo resolveInfo = context.getPackageManager().resolveService(intent, flags);
|
if (resolveInfo == null || resolveInfo.serviceInfo == null) {
|
Slog.wtf(LOG_TAG, String.format("Service %s not found in package %s",
|
AttentionService.SERVICE_INTERFACE, serviceConfigPackage
|
));
|
return null;
|
}
|
|
final ServiceInfo serviceInfo = resolveInfo.serviceInfo;
|
final String permission = serviceInfo.permission;
|
if (Manifest.permission.BIND_ATTENTION_SERVICE.equals(permission)) {
|
return serviceInfo.getComponentName();
|
}
|
Slog.e(LOG_TAG, String.format(
|
"Service %s should require %s permission. Found %s permission",
|
serviceInfo.getComponentName(),
|
Manifest.permission.BIND_ATTENTION_SERVICE,
|
serviceInfo.permission));
|
return null;
|
}
|
|
private void dumpInternal(IndentingPrintWriter ipw) {
|
ipw.println("Attention Manager Service (dumpsys attention) state:\n");
|
|
ipw.println("AttentionServicePackageName=" + getServiceConfigPackage(mContext));
|
ipw.println("Resolved component:");
|
if (mComponentName != null) {
|
ipw.increaseIndent();
|
ipw.println("Component=" + mComponentName.getPackageName());
|
ipw.println("Class=" + mComponentName.getClassName());
|
ipw.decreaseIndent();
|
}
|
|
synchronized (mLock) {
|
int size = mUserStates.size();
|
ipw.print("Number user states: ");
|
ipw.println(size);
|
if (size > 0) {
|
ipw.increaseIndent();
|
for (int i = 0; i < size; i++) {
|
UserState userState = mUserStates.valueAt(i);
|
ipw.print(i);
|
ipw.print(":");
|
userState.dump(ipw);
|
ipw.println();
|
}
|
ipw.decreaseIndent();
|
}
|
}
|
}
|
|
private final class LocalService extends AttentionManagerInternal {
|
@Override
|
public boolean isAttentionServiceSupported() {
|
return AttentionManagerService.this.isAttentionServiceSupported();
|
}
|
|
@Override
|
public boolean checkAttention(long timeout, AttentionCallbackInternal callbackInternal) {
|
return AttentionManagerService.this.checkAttention(timeout, callbackInternal);
|
}
|
|
@Override
|
public void cancelAttentionCheck(AttentionCallbackInternal callbackInternal) {
|
AttentionManagerService.this.cancelAttentionCheck(callbackInternal);
|
}
|
}
|
|
private static final class AttentionCheckCache {
|
private final long mLastComputed;
|
private final int mResult;
|
private final long mTimestamp;
|
|
AttentionCheckCache(long lastComputed, @AttentionService.AttentionSuccessCodes int result,
|
long timestamp) {
|
mLastComputed = lastComputed;
|
mResult = result;
|
mTimestamp = timestamp;
|
}
|
}
|
|
@VisibleForTesting
|
static final class AttentionCheck {
|
private final AttentionCallbackInternal mCallbackInternal;
|
private final IAttentionCallback mIAttentionCallback;
|
private boolean mIsDispatched;
|
private boolean mIsFulfilled;
|
|
AttentionCheck(AttentionCallbackInternal callbackInternal,
|
IAttentionCallback iAttentionCallback) {
|
mCallbackInternal = callbackInternal;
|
mIAttentionCallback = iAttentionCallback;
|
}
|
|
void cancelInternal() {
|
mIsFulfilled = true;
|
mCallbackInternal.onFailure(ATTENTION_FAILURE_CANCELLED);
|
}
|
}
|
|
@VisibleForTesting
|
protected static class UserState {
|
private final ComponentName mComponentName;
|
private final AttentionServiceConnection mConnection = new AttentionServiceConnection();
|
|
@GuardedBy("mLock")
|
IAttentionService mService;
|
@GuardedBy("mLock")
|
AttentionCheck mCurrentAttentionCheck;
|
@GuardedBy("mLock")
|
AttentionCheckCache mAttentionCheckCache;
|
@GuardedBy("mLock")
|
private boolean mBinding;
|
|
@UserIdInt
|
private final int mUserId;
|
private final Context mContext;
|
private final Object mLock;
|
private final Handler mAttentionHandler;
|
|
UserState(int userId, Context context, Object lock, Handler handler,
|
ComponentName componentName) {
|
mUserId = userId;
|
mContext = Preconditions.checkNotNull(context);
|
mLock = Preconditions.checkNotNull(lock);
|
mComponentName = Preconditions.checkNotNull(componentName);
|
mAttentionHandler = handler;
|
}
|
|
@GuardedBy("mLock")
|
private void handlePendingCallbackLocked() {
|
if (!mCurrentAttentionCheck.mIsDispatched) {
|
if (mService != null) {
|
try {
|
mService.checkAttention(mCurrentAttentionCheck.mIAttentionCallback);
|
mCurrentAttentionCheck.mIsDispatched = true;
|
} catch (RemoteException e) {
|
Slog.e(LOG_TAG, "Cannot call into the AttentionService");
|
}
|
} else {
|
mCurrentAttentionCheck.mCallbackInternal.onFailure(ATTENTION_FAILURE_UNKNOWN);
|
}
|
}
|
}
|
|
/** Binds to the system's AttentionService which provides an actual implementation. */
|
@GuardedBy("mLock")
|
private void bindLocked() {
|
// No need to bind if service is binding or has already been bound.
|
if (mBinding || mService != null) {
|
return;
|
}
|
|
mBinding = true;
|
// mContext.bindServiceAsUser() calls into ActivityManagerService which it may already
|
// hold the lock and had called into PowerManagerService, which holds a lock.
|
// That would create a deadlock. To solve that, putting it on a handler.
|
mAttentionHandler.post(() -> {
|
final Intent serviceIntent = new Intent(
|
AttentionService.SERVICE_INTERFACE).setComponent(
|
mComponentName);
|
// Note: no reason to clear the calling identity, we won't have one in a handler.
|
mContext.bindServiceAsUser(serviceIntent, mConnection,
|
Context.BIND_AUTO_CREATE, UserHandle.CURRENT);
|
|
});
|
}
|
|
private void dump(IndentingPrintWriter pw) {
|
pw.println("userId=" + mUserId);
|
synchronized (mLock) {
|
pw.println("binding=" + mBinding);
|
pw.println("current attention check:");
|
if (mCurrentAttentionCheck != null) {
|
pw.increaseIndent();
|
pw.println("is dispatched=" + mCurrentAttentionCheck.mIsDispatched);
|
pw.println("is fulfilled:=" + mCurrentAttentionCheck.mIsFulfilled);
|
pw.decreaseIndent();
|
}
|
pw.println("attention check cache:");
|
if (mAttentionCheckCache != null) {
|
pw.increaseIndent();
|
pw.println("last computed=" + mAttentionCheckCache.mLastComputed);
|
pw.println("timestamp=" + mAttentionCheckCache.mTimestamp);
|
pw.println("result=" + mAttentionCheckCache.mResult);
|
pw.decreaseIndent();
|
}
|
}
|
}
|
|
private class AttentionServiceConnection implements ServiceConnection {
|
@Override
|
public void onServiceConnected(ComponentName name, IBinder service) {
|
init(IAttentionService.Stub.asInterface(service));
|
}
|
|
@Override
|
public void onServiceDisconnected(ComponentName name) {
|
cleanupService();
|
}
|
|
@Override
|
public void onBindingDied(ComponentName name) {
|
cleanupService();
|
}
|
|
@Override
|
public void onNullBinding(ComponentName name) {
|
cleanupService();
|
}
|
|
void cleanupService() {
|
init(null);
|
}
|
|
private void init(@Nullable IAttentionService service) {
|
synchronized (mLock) {
|
mService = service;
|
mBinding = false;
|
handlePendingCallbackLocked();
|
}
|
}
|
}
|
}
|
|
@VisibleForTesting
|
protected class AttentionHandler extends Handler {
|
private static final int CHECK_CONNECTION_EXPIRATION = 1;
|
private static final int ATTENTION_CHECK_TIMEOUT = 2;
|
|
AttentionHandler() {
|
super(Looper.myLooper());
|
}
|
|
@Override
|
public void handleMessage(Message msg) {
|
switch (msg.what) {
|
// Do not occupy resources when not in use - unbind proactively.
|
case CHECK_CONNECTION_EXPIRATION: {
|
for (int i = 0; i < mUserStates.size(); i++) {
|
cancelAndUnbindLocked(mUserStates.valueAt(i));
|
}
|
}
|
break;
|
|
// Callee is no longer interested in the attention check result - cancel.
|
case ATTENTION_CHECK_TIMEOUT: {
|
synchronized (mLock) {
|
cancel(peekCurrentUserStateLocked());
|
}
|
}
|
break;
|
|
default:
|
break;
|
}
|
}
|
}
|
|
@VisibleForTesting
|
void cancel(UserState userState) {
|
if (userState == null || userState.mCurrentAttentionCheck == null) {
|
return;
|
}
|
|
if (userState.mCurrentAttentionCheck.mIsFulfilled) {
|
if (DEBUG) {
|
Slog.d(LOG_TAG, "Trying to cancel the check that has been already fulfilled.");
|
}
|
return;
|
}
|
|
if (userState.mService == null) {
|
userState.mCurrentAttentionCheck.cancelInternal();
|
return;
|
}
|
|
try {
|
userState.mService.cancelAttentionCheck(
|
userState.mCurrentAttentionCheck.mIAttentionCallback);
|
} catch (RemoteException e) {
|
Slog.e(LOG_TAG, "Unable to cancel attention check");
|
userState.mCurrentAttentionCheck.cancelInternal();
|
}
|
}
|
|
@GuardedBy("mLock")
|
private void cancelAndUnbindLocked(UserState userState) {
|
synchronized (mLock) {
|
if (userState == null) {
|
return;
|
}
|
|
cancel(userState);
|
|
if (userState.mService == null) {
|
return;
|
}
|
|
mAttentionHandler.post(() -> mContext.unbindService(userState.mConnection));
|
// Note: this will set mBinding to false even though it could still be trying to bind
|
// (i.e. the runnable was posted in bindLocked but then cancelAndUnbindLocked was
|
// called before it's run yet). This is a safe state at the moment,
|
// since it will eventually, but feels like a source for confusion down the road and
|
// may cause some expensive and unnecessary work to be done.
|
userState.mConnection.cleanupService();
|
mUserStates.remove(userState.mUserId);
|
}
|
}
|
|
/**
|
* Unbinds and stops the service when the screen off intent is received.
|
* Attention service only makes sense when screen is ON; disconnect and stop service otherwise.
|
*/
|
private final class ScreenStateReceiver extends BroadcastReceiver {
|
@Override
|
public void onReceive(Context context, Intent intent) {
|
if (Intent.ACTION_SCREEN_OFF.equals(intent.getAction())) {
|
cancelAndUnbindLocked(peekCurrentUserStateLocked());
|
}
|
}
|
}
|
|
private final class AttentionManagerServiceShellCommand extends ShellCommand {
|
class TestableAttentionCallbackInternal extends AttentionCallbackInternal {
|
private int mLastCallbackCode = -1;
|
|
@Override
|
public void onSuccess(int result, long timestamp) {
|
mLastCallbackCode = result;
|
}
|
|
@Override
|
public void onFailure(int error) {
|
mLastCallbackCode = error;
|
}
|
|
public void reset() {
|
mLastCallbackCode = -1;
|
}
|
|
public int getLastCallbackCode() {
|
return mLastCallbackCode;
|
}
|
}
|
|
final TestableAttentionCallbackInternal mTestableAttentionCallback =
|
new TestableAttentionCallbackInternal();
|
|
@Override
|
public int onCommand(@Nullable final String cmd) {
|
if (cmd == null) {
|
return handleDefaultCommands(cmd);
|
}
|
final PrintWriter err = getErrPrintWriter();
|
try {
|
switch (cmd) {
|
case "getAttentionServiceComponent":
|
return cmdResolveAttentionServiceComponent();
|
case "call":
|
switch (getNextArgRequired()) {
|
case "checkAttention":
|
return cmdCallCheckAttention();
|
case "cancelCheckAttention":
|
return cmdCallCancelAttention();
|
default:
|
throw new IllegalArgumentException("Invalid argument");
|
}
|
case "setTestableAttentionService":
|
return cmdSetTestableAttentionService(getNextArgRequired());
|
case "clearTestableAttentionService":
|
return cmdClearTestableAttentionService();
|
case "getLastTestCallbackCode":
|
return cmdGetLastTestCallbackCode();
|
default:
|
return handleDefaultCommands(cmd);
|
}
|
} catch (IllegalArgumentException e) {
|
err.println("Error: " + e.getMessage());
|
}
|
return -1;
|
}
|
|
private int cmdSetTestableAttentionService(String testingServicePackage) {
|
final PrintWriter out = getOutPrintWriter();
|
if (TextUtils.isEmpty(testingServicePackage)) {
|
out.println("false");
|
} else {
|
sTestAttentionServicePackage = testingServicePackage;
|
resetStates();
|
out.println(mComponentName != null ? "true" : "false");
|
}
|
return 0;
|
}
|
|
private int cmdClearTestableAttentionService() {
|
sTestAttentionServicePackage = "";
|
mTestableAttentionCallback.reset();
|
resetStates();
|
return 0;
|
}
|
|
private int cmdCallCheckAttention() {
|
final PrintWriter out = getOutPrintWriter();
|
boolean calledSuccessfully = checkAttention(2000, mTestableAttentionCallback);
|
out.println(calledSuccessfully ? "true" : "false");
|
return 0;
|
}
|
|
private int cmdCallCancelAttention() {
|
final PrintWriter out = getOutPrintWriter();
|
cancelAttentionCheck(mTestableAttentionCallback);
|
out.println("true");
|
return 0;
|
}
|
|
private int cmdResolveAttentionServiceComponent() {
|
final PrintWriter out = getOutPrintWriter();
|
ComponentName resolvedComponent = resolveAttentionService(mContext);
|
out.println(resolvedComponent != null ? resolvedComponent.flattenToShortString() : "");
|
return 0;
|
}
|
|
private int cmdGetLastTestCallbackCode() {
|
final PrintWriter out = getOutPrintWriter();
|
out.println(mTestableAttentionCallback.getLastCallbackCode());
|
return 0;
|
}
|
|
private void resetStates() {
|
mComponentName = resolveAttentionService(mContext);
|
mUserStates.clear();
|
}
|
|
@Override
|
public void onHelp() {
|
final PrintWriter out = getOutPrintWriter();
|
out.println("Attention commands: ");
|
out.println(" setTestableAttentionService <service_package>: Bind to a custom"
|
+ " implementation of attention service");
|
out.println(" ---<service_package>:");
|
out.println(
|
" := Package containing the Attention Service implementation to bind to");
|
out.println(" ---returns:");
|
out.println(" := true, if was bound successfully");
|
out.println(" := false, if was not bound successfully");
|
out.println(" clearTestableAttentionService: Undo custom bindings. Revert to previous"
|
+ " behavior");
|
out.println(" getAttentionServiceComponent: Get the current service component string");
|
out.println(" ---returns:");
|
out.println(" := If valid, the component string (in shorten form) for the"
|
+ " currently bound service.");
|
out.println(" := else, empty string");
|
out.println(" call checkAttention: Calls check attention");
|
out.println(" ---returns:");
|
out.println(
|
" := true, if the call was successfully dispatched to the service "
|
+ "implementation."
|
+ " (to see the result, call getLastTestCallbackCode)");
|
out.println(" := false, otherwise");
|
out.println(" call cancelCheckAttention: Cancels check attention");
|
out.println(" getLastTestCallbackCode");
|
out.println(" ---returns:");
|
out.println(
|
" := An integer, representing the last callback code received from the "
|
+ "bounded implementation. If none, it will return -1");
|
}
|
}
|
|
private final class BinderService extends Binder {
|
AttentionManagerServiceShellCommand mAttentionManagerServiceShellCommand =
|
new AttentionManagerServiceShellCommand();
|
|
@Override
|
public void onShellCommand(FileDescriptor in, FileDescriptor out,
|
FileDescriptor err,
|
String[] args, ShellCallback callback,
|
ResultReceiver resultReceiver) {
|
mAttentionManagerServiceShellCommand.exec(this, in, out, err, args, callback,
|
resultReceiver);
|
}
|
|
@Override
|
protected void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
|
if (!DumpUtils.checkDumpPermission(mContext, LOG_TAG, pw)) {
|
return;
|
}
|
|
dumpInternal(new IndentingPrintWriter(pw, " "));
|
}
|
}
|
}
|
