Fixed and improved (for reuse) PendingRequest lifecycle. (205d420c) · Commits · e / os / android_frameworks_base

services/autofill/java/com/android/server/autofill/RemoteFillService.java

+127 −96

Original line number	Original line	Diff line number	Diff line
	@@ -404,10 +404,86 @@ final class RemoteFillService implements DeathRecipient {
	}		}

	private static abstract class PendingRequest implements Runnable {		private static abstract class PendingRequest implements Runnable {
	void cancel() {		protected final Object mLock = new Object();
			private final WeakReference<RemoteFillService> mWeakService;

			private final Runnable mTimeoutTrigger;
			private final Handler mServiceHandler;

			@GuardedBy("mLock")
			private boolean mCancelled;

			@GuardedBy("mLock")
			private boolean mCompleted;

			PendingRequest(RemoteFillService service) {
			mWeakService = new WeakReference<>(service);
			mServiceHandler = service.mHandler.getHandler();
			mTimeoutTrigger = () -> {
			synchronized (mLock) {
			if (mCancelled) {
			return;
			}
			mCompleted = true;
			}

			final RemoteFillService remoteService = mWeakService.get();
			if (remoteService != null) {
			fail(remoteService);
			}
			};
			mServiceHandler.postAtTime(mTimeoutTrigger,
			SystemClock.uptimeMillis() + TIMEOUT_REMOTE_REQUEST_MILLIS);
			}

			protected RemoteFillService getService() {
			return mWeakService.get();
	}		}

			/**
			* Sub-classes must call this method when the remote service finishes, i.e., when it
			* called {@code onFill...} or {@code onSave...}.
			*
			* @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;
			}
			mServiceHandler.removeCallbacks(mTimeoutTrigger);
			return true;
			}

			protected boolean isCancelledLocked() {
			return mCancelled;
			}

			/**
			* Cancels the service.
			*
			* @return {@code false} if service is already canceled, {@code true} otherwise.
			*/
			boolean cancel() {
			synchronized (mLock) {
			if (mCancelled \|\| mCompleted) {
			return false;
			}
			mCancelled = true;
			}

			mServiceHandler.removeCallbacks(mTimeoutTrigger);
			return true;
			}

			/**
			* Called by the self-destructure timeout when the AutofilllService didn't reply to the
			* request on time.
			*/
			abstract void fail(RemoteFillService remoteService);

	/**		/**
	* @return whether this request leads to a final state where no		* @return whether this request leads to a final state where no
	* other requests can be made.		* other requests can be made.
	@@ -418,22 +494,14 @@ final class RemoteFillService implements DeathRecipient {
	}		}

	private static final class PendingFillRequest extends PendingRequest {		private static final class PendingFillRequest extends PendingRequest {
	private final Object mLock = new Object();

	private final WeakReference<RemoteFillService> mWeakService;
	private final FillRequest mRequest;		private final FillRequest mRequest;
	private final IFillCallback mCallback;		private final IFillCallback mCallback;
	private ICancellationSignal mCancellation;		private ICancellationSignal mCancellation;

	@GuardedBy("mLock")
	private boolean mCancelled;

	@GuardedBy("mLock")
	private boolean mCompleted;

	public PendingFillRequest(FillRequest request, RemoteFillService service) {		public PendingFillRequest(FillRequest request, RemoteFillService service) {
			super(service);
	mRequest = request;		mRequest = request;
	mWeakService = new WeakReference<>(service);
	mCallback = new IFillCallback.Stub() {		mCallback = new IFillCallback.Stub() {
	@Override		@Override
	public void onCancellable(ICancellationSignal cancellation) {		public void onCancellable(ICancellationSignal cancellation) {
	@@ -441,7 +509,7 @@ final class RemoteFillService implements DeathRecipient {
	final boolean cancelled;		final boolean cancelled;
	synchronized (mLock) {		synchronized (mLock) {
	mCancellation = cancellation;		mCancellation = cancellation;
	cancelled = mCancelled;		cancelled = isCancelledLocked();
	}		}
	if (cancelled) {		if (cancelled) {
	try {		try {
	@@ -455,15 +523,10 @@ final class RemoteFillService implements DeathRecipient {

	@Override		@Override
	public void onSuccess(FillResponse response) {		public void onSuccess(FillResponse response) {
	synchronized (mLock) {		if (!finish()) return;
	if (mCompleted) {
	return;		final RemoteFillService remoteService = getService();
	}
	mCompleted = true;
	}
	RemoteFillService remoteService = mWeakService.get();
	if (remoteService != null) {		if (remoteService != null) {
	service.mHandler.getHandler().removeCallbacks(PendingFillRequest.this);
	remoteService.dispatchOnFillRequestSuccess(PendingFillRequest.this,		remoteService.dispatchOnFillRequestSuccess(PendingFillRequest.this,
	getCallingUid(), request.getFlags(), response);		getCallingUid(), request.getFlags(), response);
	}		}
	@@ -471,132 +534,100 @@ final class RemoteFillService implements DeathRecipient {

	@Override		@Override
	public void onFailure(CharSequence message) {		public void onFailure(CharSequence message) {
	synchronized (mLock) {		if (!finish()) return;
	if (mCompleted) {
	return;		final RemoteFillService remoteService = getService();
	}
	mCompleted = true;
	}
	RemoteFillService remoteService = mWeakService.get();
	if (remoteService != null) {		if (remoteService != null) {
	service.mHandler.getHandler().removeCallbacks(PendingFillRequest.this);
	remoteService.dispatchOnFillRequestFailure(		remoteService.dispatchOnFillRequestFailure(
	PendingFillRequest.this, message);		PendingFillRequest.this, message);
	}		}
	}		}
	};		};
	service.mHandler.getHandler().postAtTime(() -> {
	cancel();
	try {
	mCallback.onFailure(null);
	} catch (RemoteException e) {
	/* ignore */
	}		}
	}, PendingFillRequest.this,
	SystemClock.uptimeMillis() + TIMEOUT_REMOTE_REQUEST_MILLIS);		@Override
			void fail(RemoteFillService remoteService) {
			remoteService.dispatchOnFillRequestFailure(PendingFillRequest.this, null);
	}		}

	@Override		@Override
	public void run() {		public void run() {
	RemoteFillService remoteService = mWeakService.get();		final RemoteFillService remoteService = getService();
	if (remoteService != null) {		if (remoteService != null) {
	try {		try {
	remoteService.mAutoFillService.onFillRequest(mRequest, mCallback);		remoteService.mAutoFillService.onFillRequest(mRequest, mCallback);
	} catch (RemoteException e) {		} catch (RemoteException e) {
	Slog.e(LOG_TAG, "Error calling on fill request", e);		Slog.e(LOG_TAG, "Error calling on fill request", e);
	cancel();
			remoteService.dispatchOnFillRequestFailure(PendingFillRequest.this, null);
	}		}
	}		}
	}		}

	@Override		@Override
	public void cancel() {		public boolean cancel() {
	final ICancellationSignal cancellation;		if (!super.cancel()) return false;
	synchronized (mLock) {
	if (mCancelled) {		final ICancellationSignal cancellation = mCancellation;
	return;		if (cancellation != null) {
	}
	mCancelled = true;
	cancellation = mCancellation;
	}
	if (cancellation == null) {
	return;
	}
	try {		try {
	cancellation.cancel();		cancellation.cancel();
	} catch (RemoteException e) {		} catch (RemoteException e) {
	Slog.e(LOG_TAG, "Error cancelling a fill request", e);		Slog.e(LOG_TAG, "Error cancelling a fill request", e);
	}		}
	}		}
			return true;
			}
	}		}

	private static final class PendingSaveRequest extends PendingRequest {		private static final class PendingSaveRequest extends PendingRequest {
	private final Object mLock = new Object();

	private final WeakReference<RemoteFillService> mWeakService;
	private final SaveRequest mRequest;		private final SaveRequest mRequest;
	private final ISaveCallback mCallback;		private final ISaveCallback mCallback;

	@GuardedBy("mLock")
	private boolean mCompleted;

	public PendingSaveRequest(@NonNull SaveRequest request,		public PendingSaveRequest(@NonNull SaveRequest request,
	@NonNull RemoteFillService service) {		@NonNull RemoteFillService service) {
			super(service);
	mRequest = request;		mRequest = request;
	mWeakService = new WeakReference<>(service);
	mCallback = new ISaveCallback.Stub() {		mCallback = new ISaveCallback.Stub() {
	@Override		@Override
	public void onSuccess() {		public void onSuccess() {
	synchronized (mLock) {		if (!finish()) return;
	if (mCompleted) {
	return;		final RemoteFillService remoteService = getService();
	}		if (remoteService != null) {
	mCompleted = true;		remoteService.dispatchOnSaveRequestSuccess(PendingSaveRequest.this);
	}
	cancel();
	RemoteFillService service = mWeakService.get();
	if (service != null) {
	service.mHandler.getHandler().removeCallbacks(PendingSaveRequest.this);
	service.dispatchOnSaveRequestSuccess(
	PendingSaveRequest.this);
	}		}
	}		}

	@Override		@Override
	public void onFailure(CharSequence message) {		public void onFailure(CharSequence message) {
	synchronized (mLock) {		if (!finish()) return;
	if (mCompleted) {
	return;		final RemoteFillService remoteService = getService();
	}		if (remoteService != null) {
	mCompleted = true;		remoteService.dispatchOnSaveRequestFailure(PendingSaveRequest.this,
	}		message);
	RemoteFillService service = mWeakService.get();
	if (service != null) {
	service.mHandler.getHandler().removeCallbacks(PendingSaveRequest.this);
	service.dispatchOnSaveRequestFailure(
	PendingSaveRequest.this, message);
	}		}
	}		}
	};		};
	service.mHandler.getHandler().postAtTime(() -> {
	cancel();
	try {
	mCallback.onFailure(null);
	} catch (RemoteException e) {
	/* ignore */
	}		}
	}, PendingSaveRequest.this,
	SystemClock.uptimeMillis() + TIMEOUT_REMOTE_REQUEST_MILLIS);		@Override
			void fail(RemoteFillService remoteService) {
			remoteService.dispatchOnSaveRequestFailure(PendingSaveRequest.this, null);
	}		}

	@Override		@Override
	public void run() {		public void run() {
	final RemoteFillService service = mWeakService.get();		final RemoteFillService remoteService = getService();
	if (service != null) {		if (remoteService != null) {
	try {		try {
	service.mAutoFillService.onSaveRequest(mRequest, mCallback);		remoteService.mAutoFillService.onSaveRequest(mRequest, mCallback);
	} catch (RemoteException e) {		} catch (RemoteException e) {
	Slog.e(LOG_TAG, "Error calling on save request", e);		Slog.e(LOG_TAG, "Error calling on save request", e);

			remoteService.dispatchOnFillRequestFailure(PendingSaveRequest.this, null);
	}		}
	}		}
	}		}