xref: /cts/tests/autofillservice/src/android/autofillservice/cts/testcore/CtsAugmentedAutofillService.java

/*
 * 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 android.autofillservice.cts.testcore;

import static android.autofillservice.cts.testcore.AugmentedHelper.await;
import static android.autofillservice.cts.testcore.AugmentedHelper.getActivityName;
import static android.autofillservice.cts.testcore.AugmentedTimeouts.AUGMENTED_CONNECTION_TIMEOUT;
import static android.autofillservice.cts.testcore.AugmentedTimeouts.AUGMENTED_FILL_TIMEOUT;
import static android.autofillservice.cts.testcore.CannedAugmentedFillResponse.AugmentedResponseType.NULL;
import static android.autofillservice.cts.testcore.CannedAugmentedFillResponse.AugmentedResponseType.TIMEOUT;
import static android.autofillservice.cts.testcore.Timeouts.FILL_EVENTS_TIMEOUT;

import static com.google.common.truth.Truth.assertWithMessage;

import android.content.ComponentName;
import android.content.Context;
import android.os.CancellationSignal;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.SystemClock;
import android.service.autofill.FillEventHistory;
import android.service.autofill.FillEventHistory.Event;
import android.service.autofill.augmented.AugmentedAutofillService;
import android.service.autofill.augmented.FillCallback;
import android.service.autofill.augmented.FillController;
import android.service.autofill.augmented.FillRequest;
import android.service.autofill.augmented.FillResponse;
import android.util.ArraySet;
import android.util.Log;
import android.view.autofill.AutofillManager;

import androidx.annotation.NonNull;
import androidx.annotation.Nullable;

import com.android.compatibility.common.util.RetryableException;
import com.android.compatibility.common.util.TestNameUtils;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;

/**
 * Implementation of {@link AugmentedAutofillService} used in the tests.
 */
public class CtsAugmentedAutofillService extends AugmentedAutofillService {

    private static final String TAG = CtsAugmentedAutofillService.class.getSimpleName();

    public static final String SERVICE_PACKAGE = Helper.MY_PACKAGE;
    public static final String SERVICE_CLASS = CtsAugmentedAutofillService.class.getSimpleName();

    public static final String SERVICE_NAME = SERVICE_PACKAGE + "/.testcore." + SERVICE_CLASS;

    private static final AugmentedReplier sAugmentedReplier = new AugmentedReplier();

    // We must handle all requests in a separate thread as the service's main thread is the also
    // the UI thread of the test process and we don't want to hose it in case of failures here
    private static final HandlerThread sMyThread = new HandlerThread("MyAugmentedServiceThread");
    private final Handler mHandler;

    private static ServiceWatcher sServiceWatcher;

    static {
        Log.i(TAG, "Starting thread " + sMyThread);
        sMyThread.start();
    }

    public CtsAugmentedAutofillService() {
        mHandler = Handler.createAsync(sMyThread.getLooper());
    }

    @NonNull
    public static ServiceWatcher setServiceWatcher() {
        if (sServiceWatcher != null) {
            throw new IllegalStateException("There Can Be Only One during testing!");
        }
        sServiceWatcher = new ServiceWatcher();
        return sServiceWatcher;
    }


    public static void resetStaticState() {
        // Found the sServiceWatcher is null when AugmentedAutofillService is connected. It should
        // be set when enabling augmented autofill service. But when AugmentedAutofillService is
        // connected, the sServiceWatcher is null. No onDisconnected log ir printed, the
        // sServiceWatcher may be reset here. Add log to help future flaky debugging.
        Log.d(TAG, "resetStaticState()", new Throwable());
        List<Throwable> exceptions = sAugmentedReplier.mExceptions;
        if (exceptions != null) {
            exceptions.clear();
        }
        // TODO(b/123540602): should probably set sInstance to null as well, but first we would need
        // to make sure each test unbinds the service.

        // TODO(b/123540602): each test should use a different service instance, but we need
        // to provide onConnected() / onDisconnected() methods first and then change the infra so
        // we can wait for those

        if (sServiceWatcher != null) {
            Log.wtf(TAG, "resetStaticState(): should not have sServiceWatcher");
            sServiceWatcher = null;
        }
    }

    @Override
    public void onConnected() {
        Log.i(TAG, "onConnected(): sServiceWatcher=" + sServiceWatcher);

        if (sServiceWatcher == null) {
            // (b/230554011):onConnected()/onConnected() may be called multiple times during testing
            // or during the test setup/destroyed. Sometimes the test actually passes but this
            // symtom causes the test addException(), the test result fails finally. Instead of
            // addException only logging here
            Log.w(TAG, "onConnected() without a watcher");
            return;
        }

        final AutofillManager afm = getApplication().getSystemService(AutofillManager.class);
        if (afm == null) {
            Log.e(TAG, "No AutofillManager on application context on onConnected()");
            addException("No AutofillManager on application context on onConnected()");
            return;
        }
        Log.d(TAG, "Set allowlist with " + Helper.MY_PACKAGE + " for augmented autofill");
        final ArraySet<String> packages = new ArraySet<>(1);
        packages.add(Helper.MY_PACKAGE);
        afm.setAugmentedAutofillWhitelist(packages, /* activities= */ null);

        sServiceWatcher.mService = this;
        sServiceWatcher.mCreated.countDown();
    }

    @Override
    public void onDisconnected() {
        Log.i(TAG, "onDisconnected(): sServiceWatcher=" + sServiceWatcher);

        if (sServiceWatcher == null) {
            Log.w(TAG, "onDisconnected() without a watcher");
            return;
        }

        sServiceWatcher.mDestroyed.countDown();
        sServiceWatcher.mService = null;
        sServiceWatcher = null;
    }

    public FillEventHistory getFillEventHistory(int expectedSize) throws Exception {
        return FILL_EVENTS_TIMEOUT.run("getFillEvents(" + expectedSize + ")", () -> {
            final FillEventHistory history = getFillEventHistory();
            if (history == null) {
                return null;
            }
            final List<Event> events = history.getEvents();
            if (events != null) {
                assertWithMessage("Didn't get " + expectedSize + " events yet: " + events).that(
                        events.size()).isEqualTo(expectedSize);
            } else {
                assertWithMessage("Events is null (expecting " + expectedSize + ")").that(
                        expectedSize).isEqualTo(0);
                return null;
            }
            return history;
        });
    }

    @Override
    public void onFillRequest(FillRequest request, CancellationSignal cancellationSignal,
            FillController controller, FillCallback callback) {
        Log.i(TAG, "onFillRequest(): " + AugmentedHelper.toString(request));

        final ComponentName component = request.getActivityComponent();

        if (!TestNameUtils.isRunningTest()) {
            Log.e(TAG, "onFillRequest(" + component + ") called after tests finished");
            return;
        }
        mHandler.post(() -> sAugmentedReplier.handleOnFillRequest(getApplicationContext(), request,
                cancellationSignal, controller, callback));
    }

    /**
     * Gets the {@link AugmentedReplier} singleton.
     */
    public static AugmentedReplier getAugmentedReplier() {
        return sAugmentedReplier;
    }

    private static void addException(@NonNull String fmt, @Nullable Object...args) {
        final String msg = String.format(fmt, args);
        Log.e(TAG, msg);
        sAugmentedReplier.addException(new IllegalStateException(msg));
    }

    /**
     * POJO representation of the contents of a {@link FillRequest}
     * that can be asserted at the end of a test case.
     */
    public static final class AugmentedFillRequest {
        public final FillRequest request;
        public final CancellationSignal cancellationSignal;
        public final FillController controller;
        public final FillCallback callback;

        private AugmentedFillRequest(FillRequest request, CancellationSignal cancellationSignal,
                FillController controller, FillCallback callback) {
            this.request = request;
            this.cancellationSignal = cancellationSignal;
            this.controller = controller;
            this.callback = callback;
        }

        @Override
        public String toString() {
            return "AugmentedFillRequest[activity=" + getActivityName(request) + ", request="
                    + AugmentedHelper.toString(request) + "]";
        }
    }

    /**
     * Object used to answer a
     * {@link AugmentedAutofillService#onFillRequest(FillRequest, CancellationSignal,
     * FillController, FillCallback)} on behalf of a unit test method.
     */
    public static final class AugmentedReplier {

        private final BlockingQueue<CannedAugmentedFillResponse> mResponses =
                new LinkedBlockingQueue<>();
        private final BlockingQueue<AugmentedFillRequest> mFillRequests =
                new LinkedBlockingQueue<>();

        private List<Throwable> mExceptions;
        private boolean mReportUnhandledFillRequest = true;

        private AugmentedReplier() {
        }

        /**
         * Gets the exceptions thrown asynchronously, if any.
         */
        @Nullable
        public List<Throwable> getExceptions() {
            return mExceptions;
        }

        private void addException(@Nullable Throwable e) {
            if (e == null) return;

            if (mExceptions == null) {
                mExceptions = new ArrayList<>();
            }
            mExceptions.add(e);
        }

        /**
         * Sets the expectation for the next {@code onFillRequest}.
         */
        public AugmentedReplier addResponse(@NonNull CannedAugmentedFillResponse response) {
            if (response == null) {
                throw new IllegalArgumentException("Cannot be null - use NO_RESPONSE instead");
            }
            mResponses.add(response);
            return this;
        }
        /**
         * Gets the next fill request, in the order received.
         */
        public AugmentedFillRequest getNextFillRequest() {
            AugmentedFillRequest request;
            try {
                request = mFillRequests.poll(AUGMENTED_FILL_TIMEOUT.ms(), TimeUnit.MILLISECONDS);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                throw new IllegalStateException("Interrupted", e);
            }
            if (request == null) {
                throw new RetryableException(AUGMENTED_FILL_TIMEOUT, "onFillRequest() not called");
            }
            return request;
        }

        /**
         * Asserts all {@link AugmentedAutofillService#onFillRequest(FillRequest,
         * CancellationSignal, FillController, FillCallback)} received by the service were properly
         * {@link #getNextFillRequest() handled} by the test case.
         */
        public void assertNoUnhandledFillRequests() {
            if (mFillRequests.isEmpty()) return; // Good job, test case!

            if (!mReportUnhandledFillRequest) {
                // Just log, so it's not thrown again on @After if already thrown on main body
                Log.d(TAG, "assertNoUnhandledFillRequests(): already reported, "
                        + "but logging just in case: " + mFillRequests);
                return;
            }

            mReportUnhandledFillRequest = false;
            throw new AssertionError(mFillRequests.size() + " unhandled fill requests: "
                    + mFillRequests);
        }

        /**
         * Gets the current number of unhandled requests.
         */
        public int getNumberUnhandledFillRequests() {
            return mFillRequests.size();
        }

        /**
         * Resets its internal state.
         */
        public void reset() {
            mResponses.clear();
            mFillRequests.clear();
            mExceptions = null;
            mReportUnhandledFillRequest = true;
        }

        private void handleOnFillRequest(@NonNull Context context, @NonNull FillRequest request,
                @NonNull CancellationSignal cancellationSignal, @NonNull FillController controller,
                @NonNull FillCallback callback) {
            final AugmentedFillRequest myRequest = new AugmentedFillRequest(request,
                    cancellationSignal, controller, callback);
            Log.d(TAG, "offering " + myRequest);
            Helper.offer(mFillRequests, myRequest, AUGMENTED_CONNECTION_TIMEOUT.ms());
            try {
                final CannedAugmentedFillResponse response;
                try {
                    response = mResponses.poll(AUGMENTED_CONNECTION_TIMEOUT.ms(),
                            TimeUnit.MILLISECONDS);
                } catch (InterruptedException e) {
                    Log.w(TAG, "Interrupted getting CannedAugmentedFillResponse: " + e);
                    Thread.currentThread().interrupt();
                    addException(e);
                    return;
                }
                if (response == null) {
                    Log.w(TAG, "onFillRequest() for " + getActivityName(request)
                            + " received when no canned response was set.");
                    return;
                }

                // sleep for timeout tests.
                final long delay = response.getDelay();
                if (delay > 0) {
                    SystemClock.sleep(response.getDelay());
                }

                if (response.getResponseType() == NULL) {
                    Log.d(TAG, "onFillRequest(): replying with null");
                    callback.onSuccess(null);
                    return;
                }

                if (response.getResponseType() == TIMEOUT) {
                    Log.d(TAG, "onFillRequest(): not replying at all");
                    return;
                }

                Log.v(TAG, "onFillRequest(): response = " + response);
                final FillResponse fillResponse = response.asFillResponse(context, request,
                        controller);
                Log.v(TAG, "onFillRequest(): fillResponse = " + fillResponse);
                callback.onSuccess(fillResponse);
            } catch (Throwable t) {
                addException(t);
            }
        }
    }

    public static final class ServiceWatcher {

        private final CountDownLatch mCreated = new CountDownLatch(1);
        private final CountDownLatch mDestroyed = new CountDownLatch(1);

        private CtsAugmentedAutofillService mService;

        @NonNull
        public CtsAugmentedAutofillService waitOnConnected() throws InterruptedException {
            Log.d(TAG, "waitOnConnected(), mService= " + mService);
            await(mCreated, "not created");

            if (mService == null) {
                throw new IllegalStateException("not created");
            }

            return mService;
        }

        public void waitOnDisconnected() throws InterruptedException {
            Log.d(TAG, "waitOnConnected(), mService= " + mService);
            await(mDestroyed, "not destroyed");
        }

        @Override
        public String toString() {
            return "mService: " + mService + " created: " + (mCreated.getCount() == 0)
                    + " destroyed: " + (mDestroyed.getCount() == 0);
        }
    }
}