Merge "Cache start callback for watchdog in case the HAL operation does not...

    private final BaseClientMonitor mClientMonitor;

    @Nullable

    private final ClientMonitorCallback mClientCallback;

    @Nullable

    private ClientMonitorCallback mOnStartCallback;

    @OperationState

    private int mState;

    @VisibleForTesting

        mCancelWatchdog = () -> {

            if (!isFinished()) {

                Slog.e(TAG, "[Watchdog Triggered]: " + this);

                getWrappedCallback().onClientFinished(mClientMonitor, false /* success */);

                getWrappedCallback(mOnStartCallback)

                        .onClientFinished(mClientMonitor, false /* success */);

            }

        };

    }

    }

    private boolean doStart(@NonNull ClientMonitorCallback callback) {

        mOnStartCallback = callback;

        final ClientMonitorCallback cb = getWrappedCallback(callback);

        if (mState == STATE_WAITING_IN_QUEUE_CANCELING) {

import com.android.server.biometrics.log.BiometricLogger;

import org.junit.Before;

import org.junit.Rule;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.mockito.ArgumentCaptor;

import org.mockito.Captor;

import org.mockito.Mock;

import org.mockito.MockitoAnnotations;

import org.mockito.junit.MockitoJUnit;

import org.mockito.junit.MockitoRule;

@Presubmit

@RunWith(AndroidTestingRunner.class)

        }

    }

    @Rule

    public final MockitoRule mockito = MockitoJUnit.rule();

    @Mock

    private InterruptableMonitor<FakeHal> mClientMonitor;

    @Mock

    @Before

    public void setUp() {

        MockitoAnnotations.initMocks(this);

        mHandler = new Handler(TestableLooper.get(this).getLooper());

        mOperation = new BiometricSchedulerOperation(mClientMonitor, mClientCallback);

    }

    private void cancelWatchdog(boolean start) {

        when(mClientMonitor.getFreshDaemon()).thenReturn(mHal);

        mOperation.start(mock(ClientMonitorCallback.class));

        final ClientMonitorCallback opStartCallback = mock(ClientMonitorCallback.class);

        mOperation.start(opStartCallback);

        if (start) {

            verify(mClientMonitor).start(mStartCallback.capture());

            mStartCallback.getValue().onClientStarted(mClientMonitor);

            verify(opStartCallback).onClientStarted(eq(mClientMonitor));

        }

        mOperation.cancel(mHandler, mock(ClientMonitorCallback.class));

        assertThat(mOperation.isFinished()).isTrue();

        assertThat(mOperation.isCanceling()).isFalse();

        verify(opStartCallback).onClientFinished(eq(mClientMonitor), eq(false));

        verify(mClientMonitor).destroy();

    }

}