/*
 * Copyright 2020 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.hardware.camera2.cts;

import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyInt;
import static org.mockito.Matchers.anyLong;
import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.atLeastOnce;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.timeout;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;

import com.android.compatibility.common.util.DeviceReportLog;
import com.android.compatibility.common.util.ResultType;
import com.android.compatibility.common.util.ResultUnit;
import com.android.compatibility.common.util.Stat;
import com.android.ex.camera2.blocking.BlockingSessionCallback;
import com.android.ex.camera2.blocking.BlockingExtensionSessionCallback;
import com.android.ex.camera2.blocking.BlockingStateCallback;
import com.android.ex.camera2.exceptions.TimeoutRuntimeException;

import android.graphics.ImageFormat;
import android.graphics.SurfaceTexture;
import android.hardware.HardwareBuffer;
import android.hardware.camera2.CameraCaptureSession;
import android.hardware.camera2.CameraDevice;
import android.hardware.camera2.CameraExtensionCharacteristics;
import android.hardware.camera2.CameraExtensionSession;
import android.hardware.camera2.CaptureRequest;
import android.hardware.camera2.CaptureResult;
import android.hardware.camera2.TotalCaptureResult;
import android.hardware.camera2.cts.helpers.CameraErrorCollector;
import android.hardware.camera2.cts.helpers.StaticMetadata;
import android.hardware.camera2.cts.testcases.Camera2AndroidTestRule;
import android.hardware.camera2.params.ExtensionSessionConfiguration;
import android.hardware.camera2.params.OutputConfiguration;
import android.hardware.camera2.params.SessionConfiguration;
import android.media.ExifInterface;
import android.media.Image;
import android.media.ImageReader;
import android.os.SystemClock;
import android.util.Range;
import android.util.Size;

import static android.hardware.camera2.cts.CameraTestUtils.*;
import static android.hardware.cts.helpers.CameraUtils.*;

import android.util.Log;
import android.view.Surface;
import android.view.TextureView;

import androidx.test.platform.app.InstrumentationRegistry;
import androidx.test.rule.ActivityTestRule;

import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;

import java.io.IOException;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

@RunWith(Parameterized.class)
public class CameraExtensionSessionTest extends Camera2ParameterizedTestCase {
    private static final String TAG = "CameraExtensionSessionTest";
    private static final boolean VERBOSE = Log.isLoggable(TAG, Log.VERBOSE);
    private static final long WAIT_FOR_COMMAND_TO_COMPLETE_MS = 5000;
    private static final long REPEATING_REQUEST_TIMEOUT_MS = 5000;
    public static final int MULTI_FRAME_CAPTURE_IMAGE_TIMEOUT_MS = 10000;

    private SurfaceTexture mSurfaceTexture = null;
    private Camera2AndroidTestRule mTestRule = null;
    private CameraErrorCollector mCollector =  null;

    private DeviceReportLog mReportLog;

    @Override
    public void setUp() throws Exception {
        super.setUp();
        mTestRule = new Camera2AndroidTestRule(mContext);
        mTestRule.before();
        mCollector = new CameraErrorCollector();
    }

    @Override
    public void tearDown() throws Exception {
        if (mTestRule != null) {
            mTestRule.after();
        }
        if (mSurfaceTexture != null) {
            mSurfaceTexture.release();
            mSurfaceTexture = null;
        }
        if (mCollector != null) {
            try {
                mCollector.verify();
            } catch (Throwable e) {
                throw new Exception(e.getMessage());
            }
        }
        super.tearDown();
    }

    @Rule
    public ActivityTestRule<CameraExtensionTestActivity> mActivityRule =
            new ActivityTestRule<>(CameraExtensionTestActivity.class);

    private void updatePreviewSurfaceTexture() {
        if (mSurfaceTexture != null) {
            return;
        }

        TextureView textureView = mActivityRule.getActivity().getTextureView();
        mSurfaceTexture = getAvailableSurfaceTexture(WAIT_FOR_COMMAND_TO_COMPLETE_MS, textureView);
        assertNotNull("Failed to acquire valid preview surface texture!", mSurfaceTexture);
    }

    // Verify that camera extension sessions can be created and closed as expected.
    @Test
    public void testBasicExtensionLifecycle() throws Exception {
        for (String id : mCameraIdsUnderTest) {
            StaticMetadata staticMeta =
                    new StaticMetadata(mTestRule.getCameraManager().getCameraCharacteristics(id));
            if (!staticMeta.isColorOutputSupported()) {
                continue;
            }
            updatePreviewSurfaceTexture();
            CameraExtensionCharacteristics extensionChars =
                    mTestRule.getCameraManager().getCameraExtensionCharacteristics(id);
            List<Integer> supportedExtensions = extensionChars.getSupportedExtensions();
            for (Integer extension : supportedExtensions) {
                List<Size> extensionSizes = extensionChars.getExtensionSupportedSizes(extension,
                        mSurfaceTexture.getClass());
                Size maxSize = CameraTestUtils.getMaxSize(extensionSizes.toArray(new Size[0]));
                mSurfaceTexture.setDefaultBufferSize(maxSize.getWidth(), maxSize.getHeight());
                OutputConfiguration outputConfig = new OutputConfiguration(
                        OutputConfiguration.SURFACE_GROUP_ID_NONE,
                        new Surface(mSurfaceTexture));
                List<OutputConfiguration> outputConfigs = new ArrayList<>();
                outputConfigs.add(outputConfig);

                BlockingExtensionSessionCallback sessionListener =
                        new BlockingExtensionSessionCallback(
                                mock(CameraExtensionSession.StateCallback.class));
                ExtensionSessionConfiguration configuration =
                        new ExtensionSessionConfiguration(extension, outputConfigs,
                                new HandlerExecutor(mTestRule.getHandler()), sessionListener);

                try {
                    mTestRule.openDevice(id);
                    CameraDevice camera = mTestRule.getCamera();
                    camera.createExtensionSession(configuration);
                    CameraExtensionSession extensionSession = sessionListener.waitAndGetSession(
                            SESSION_CONFIGURE_TIMEOUT_MS);

                    extensionSession.close();
                    sessionListener.getStateWaiter().waitForState(
                            BlockingExtensionSessionCallback.SESSION_CLOSED,
                            SESSION_CLOSE_TIMEOUT_MS);
                } finally {
                    mTestRule.closeDevice(id);
                }
            }
        }
    }

    // Verify that regular camera sessions close as expected after creating a camera extension
    // session.
    @Test
    public void testCloseCaptureSession() throws Exception {
        for (String id : mCameraIdsUnderTest) {
            StaticMetadata staticMeta =
                    new StaticMetadata(mTestRule.getCameraManager().getCameraCharacteristics(id));
            if (!staticMeta.isColorOutputSupported()) {
                continue;
            }
            updatePreviewSurfaceTexture();
            CameraExtensionCharacteristics extensionChars =
                    mTestRule.getCameraManager().getCameraExtensionCharacteristics(id);
            List<Integer> supportedExtensions = extensionChars.getSupportedExtensions();
            for (Integer extension : supportedExtensions) {
                List<Size> extensionSizes = extensionChars.getExtensionSupportedSizes(extension,
                        mSurfaceTexture.getClass());
                Size maxSize = CameraTestUtils.getMaxSize(extensionSizes.toArray(new Size[0]));
                mSurfaceTexture.setDefaultBufferSize(maxSize.getWidth(), maxSize.getHeight());
                Surface repeatingSurface = new Surface(mSurfaceTexture);
                OutputConfiguration textureOutput = new OutputConfiguration(
                        OutputConfiguration.SURFACE_GROUP_ID_NONE, repeatingSurface);
                List<OutputConfiguration> outputs = new ArrayList<>();
                outputs.add(textureOutput);
                BlockingSessionCallback regularSessionListener = new BlockingSessionCallback(
                        mock(CameraCaptureSession.StateCallback.class));
                SessionConfiguration regularConfiguration = new SessionConfiguration(
                        SessionConfiguration.SESSION_REGULAR, outputs,
                        new HandlerExecutor(mTestRule.getHandler()), regularSessionListener);

                BlockingExtensionSessionCallback sessionListener =
                        new BlockingExtensionSessionCallback(mock(
                                CameraExtensionSession.StateCallback.class));
                ExtensionSessionConfiguration configuration =
                        new ExtensionSessionConfiguration(extension, outputs,
                                new HandlerExecutor(mTestRule.getHandler()), sessionListener);

                try {
                    mTestRule.openDevice(id);
                    mTestRule.getCamera().createCaptureSession(regularConfiguration);

                    CameraCaptureSession session =
                            regularSessionListener
                                    .waitAndGetSession(SESSION_CONFIGURE_TIMEOUT_MS);
                    assertNotNull(session);

                    CameraDevice camera = mTestRule.getCamera();
                    camera.createExtensionSession(configuration);
                    CameraExtensionSession extensionSession = sessionListener.waitAndGetSession(
                            SESSION_CONFIGURE_TIMEOUT_MS);
                    assertNotNull(extensionSession);

                    regularSessionListener.getStateWaiter().waitForState(
                            BlockingExtensionSessionCallback.SESSION_CLOSED,
                            SESSION_CLOSE_TIMEOUT_MS);

                    extensionSession.close();
                    sessionListener.getStateWaiter().waitForState(
                            BlockingExtensionSessionCallback.SESSION_CLOSED,
                            SESSION_CLOSE_TIMEOUT_MS);
                } finally {
                    mTestRule.closeDevice(id);
                }
            }
        }
    }

    // Verify that camera extension sessions close as expected when creating a regular capture
    // session.
    @Test
    public void testCloseExtensionSession() throws Exception {
        for (String id : mCameraIdsUnderTest) {
            StaticMetadata staticMeta =
                    new StaticMetadata(mTestRule.getCameraManager().getCameraCharacteristics(id));
            if (!staticMeta.isColorOutputSupported()) {
                continue;
            }
            updatePreviewSurfaceTexture();
            CameraExtensionCharacteristics extensionChars =
                    mTestRule.getCameraManager().getCameraExtensionCharacteristics(id);
            List<Integer> supportedExtensions = extensionChars.getSupportedExtensions();
            for (Integer extension : supportedExtensions) {
                List<Size> extensionSizes = extensionChars.getExtensionSupportedSizes(extension,
                        mSurfaceTexture.getClass());
                Size maxSize = CameraTestUtils.getMaxSize(extensionSizes.toArray(new Size[0]));
                mSurfaceTexture.setDefaultBufferSize(maxSize.getWidth(), maxSize.getHeight());
                Surface surface = new Surface(mSurfaceTexture);
                OutputConfiguration textureOutput = new OutputConfiguration(
                        OutputConfiguration.SURFACE_GROUP_ID_NONE, surface);
                List<OutputConfiguration> outputs = new ArrayList<>();
                outputs.add(textureOutput);
                BlockingSessionCallback regularSessionListener = new BlockingSessionCallback(
                        mock(CameraCaptureSession.StateCallback.class));
                SessionConfiguration regularConfiguration = new SessionConfiguration(
                        SessionConfiguration.SESSION_REGULAR, outputs,
                        new HandlerExecutor(mTestRule.getHandler()), regularSessionListener);

                BlockingExtensionSessionCallback sessionListener =
                        new BlockingExtensionSessionCallback(mock(
                                CameraExtensionSession.StateCallback.class));
                ExtensionSessionConfiguration configuration =
                        new ExtensionSessionConfiguration(extension, outputs,
                                new HandlerExecutor(mTestRule.getHandler()), sessionListener);

                try {
                    mTestRule.openDevice(id);
                    CameraDevice camera = mTestRule.getCamera();
                    camera.createExtensionSession(configuration);
                    CameraExtensionSession extensionSession = sessionListener.waitAndGetSession(
                            SESSION_CONFIGURE_TIMEOUT_MS);
                    assertNotNull(extensionSession);

                    mTestRule.getCamera().createCaptureSession(regularConfiguration);
                    sessionListener.getStateWaiter().waitForState(
                            BlockingExtensionSessionCallback.SESSION_CLOSED,
                            SESSION_CLOSE_TIMEOUT_MS);

                    CameraCaptureSession session =
                            regularSessionListener.waitAndGetSession(
                                    SESSION_CONFIGURE_TIMEOUT_MS);
                    session.close();
                    regularSessionListener.getStateWaiter().waitForState(
                            BlockingSessionCallback.SESSION_CLOSED, SESSION_CLOSE_TIMEOUT_MS);
                } finally {
                    mTestRule.closeDevice(id);
                }
            }
        }
    }

    // Verify camera device query
    @Test
    public void testGetDevice() throws Exception {
        for (String id : mCameraIdsUnderTest) {
            StaticMetadata staticMeta =
                    new StaticMetadata(mTestRule.getCameraManager().getCameraCharacteristics(id));
            if (!staticMeta.isColorOutputSupported()) {
                continue;
            }
            updatePreviewSurfaceTexture();
            CameraExtensionCharacteristics extensionChars =
                    mTestRule.getCameraManager().getCameraExtensionCharacteristics(id);
            List<Integer> supportedExtensions = extensionChars.getSupportedExtensions();
            for (Integer extension : supportedExtensions) {
                List<Size> extensionSizes = extensionChars.getExtensionSupportedSizes(extension,
                        mSurfaceTexture.getClass());
                Size maxSize = CameraTestUtils.getMaxSize(extensionSizes.toArray(new Size[0]));
                mSurfaceTexture.setDefaultBufferSize(maxSize.getWidth(), maxSize.getHeight());
                OutputConfiguration privateOutput = new OutputConfiguration(
                        OutputConfiguration.SURFACE_GROUP_ID_NONE,
                        new Surface(mSurfaceTexture));
                List<OutputConfiguration> outputConfigs = new ArrayList<>();
                outputConfigs.add(privateOutput);

                BlockingExtensionSessionCallback sessionListener =
                        new BlockingExtensionSessionCallback(
                                mock(CameraExtensionSession.StateCallback.class));
                ExtensionSessionConfiguration configuration =
                        new ExtensionSessionConfiguration(extension, outputConfigs,
                                new HandlerExecutor(mTestRule.getHandler()), sessionListener);

                try {
                    mTestRule.openDevice(id);
                    CameraDevice camera = mTestRule.getCamera();
                    camera.createExtensionSession(configuration);
                    CameraExtensionSession extensionSession = sessionListener.waitAndGetSession(
                            SESSION_CONFIGURE_TIMEOUT_MS);

                    assertEquals("Unexpected/Invalid camera device", mTestRule.getCamera(),
                            extensionSession.getDevice());
                } finally {
                    mTestRule.closeDevice(id);
                }

                try {
                    sessionListener.getStateWaiter().waitForState(
                            BlockingExtensionSessionCallback.SESSION_CLOSED,
                            SESSION_CLOSE_TIMEOUT_MS);
                    fail("should get TimeoutRuntimeException due to previously closed camera "
                            + "device");
                } catch (TimeoutRuntimeException e) {
                    // Expected, per API spec we should not receive any further session callbacks
                    // besides the device state 'onClosed' callback.
                }
            }
        }
    }

    // Test case for repeating/stopRepeating on all supported extensions and expected state/capture
    // callbacks.
    @Test
    public void testRepeatingCapture() throws Exception {
        for (String id : mCameraIdsUnderTest) {
            StaticMetadata staticMeta =
                    new StaticMetadata(mTestRule.getCameraManager().getCameraCharacteristics(id));
            if (!staticMeta.isColorOutputSupported()) {
                continue;
            }
            updatePreviewSurfaceTexture();
            CameraExtensionCharacteristics extensionChars =
                    mTestRule.getCameraManager().getCameraExtensionCharacteristics(id);
            List<Integer> supportedExtensions = extensionChars.getSupportedExtensions();
            for (Integer extension : supportedExtensions) {
                List<Size> extensionSizes = extensionChars.getExtensionSupportedSizes(extension,
                        mSurfaceTexture.getClass());
                Size maxSize =
                        CameraTestUtils.getMaxSize(extensionSizes.toArray(new Size[0]));
                mSurfaceTexture.setDefaultBufferSize(maxSize.getWidth(),
                        maxSize.getHeight());
                Surface texturedSurface = new Surface(mSurfaceTexture);

                List<OutputConfiguration> outputConfigs = new ArrayList<>();
                outputConfigs.add(new OutputConfiguration(
                        OutputConfiguration.SURFACE_GROUP_ID_NONE, texturedSurface));

                BlockingExtensionSessionCallback sessionListener =
                        new BlockingExtensionSessionCallback(mock(
                                CameraExtensionSession.StateCallback.class));
                ExtensionSessionConfiguration configuration =
                        new ExtensionSessionConfiguration(extension, outputConfigs,
                                new HandlerExecutor(mTestRule.getHandler()),
                                sessionListener);

                boolean captureResultsSupported =
                        !extensionChars.getAvailableCaptureResultKeys(extension).isEmpty();

                try {
                    mTestRule.openDevice(id);
                    CameraDevice camera = mTestRule.getCamera();
                    camera.createExtensionSession(configuration);
                    CameraExtensionSession extensionSession =
                            sessionListener.waitAndGetSession(
                                    SESSION_CONFIGURE_TIMEOUT_MS);
                    assertNotNull(extensionSession);

                    CaptureRequest.Builder captureBuilder =
                            mTestRule.getCamera().createCaptureRequest(
                                    android.hardware.camera2.CameraDevice.TEMPLATE_PREVIEW);
                    captureBuilder.addTarget(texturedSurface);
                    CameraExtensionSession.ExtensionCaptureCallback captureCallbackMock =
                            mock(CameraExtensionSession.ExtensionCaptureCallback.class);
                    SimpleCaptureCallback simpleCaptureCallback =
                            new SimpleCaptureCallback(captureCallbackMock,
                                    extensionChars.getAvailableCaptureResultKeys(extension),
                                    mCollector);
                    CaptureRequest request = captureBuilder.build();
                    int sequenceId = extensionSession.setRepeatingRequest(request,
                            new HandlerExecutor(mTestRule.getHandler()), simpleCaptureCallback);

                    verify(captureCallbackMock,
                            timeout(REPEATING_REQUEST_TIMEOUT_MS).atLeastOnce())
                            .onCaptureStarted(eq(extensionSession), eq(request), anyLong());
                    verify(captureCallbackMock,
                            timeout(REPEATING_REQUEST_TIMEOUT_MS).atLeastOnce())
                            .onCaptureProcessStarted(extensionSession, request);
                    if (captureResultsSupported) {
                        verify(captureCallbackMock,
                                timeout(MULTI_FRAME_CAPTURE_IMAGE_TIMEOUT_MS).atLeastOnce())
                                .onCaptureResultAvailable(eq(extensionSession), eq(request),
                                        any(TotalCaptureResult.class));
                    }

                    extensionSession.stopRepeating();

                    verify(captureCallbackMock,
                            timeout(MULTI_FRAME_CAPTURE_IMAGE_TIMEOUT_MS).times(1))
                            .onCaptureSequenceCompleted(extensionSession, sequenceId);

                    verify(captureCallbackMock, times(0))
                            .onCaptureSequenceAborted(any(CameraExtensionSession.class),
                                    anyInt());

                    extensionSession.close();

                    sessionListener.getStateWaiter().waitForState(
                            BlockingExtensionSessionCallback.SESSION_CLOSED,
                            SESSION_CLOSE_TIMEOUT_MS);

                    assertTrue("The sum of onCaptureProcessStarted and onCaptureFailed" +
                                    " callbacks must be greater or equal than the number of calls" +
                                    " to onCaptureStarted!",
                            simpleCaptureCallback.getTotalFramesArrived() +
                                    simpleCaptureCallback.getTotalFramesFailed() >=
                                    simpleCaptureCallback.getTotalFramesStarted());
                    assertTrue(String.format("The last repeating request surface timestamp " +
                                    "%d must be less than or equal to the last " +
                                    "onCaptureStarted " +
                                    "timestamp %d", mSurfaceTexture.getTimestamp(),
                            simpleCaptureCallback.getLastTimestamp()),
                            mSurfaceTexture.getTimestamp() <=
                                    simpleCaptureCallback.getLastTimestamp());
                } finally {
                    mTestRule.closeDevice(id);
                    texturedSurface.release();
                }
            }
        }
    }

    // Test case for multi-frame only capture on all supported extensions and expected state
    // callbacks. Verify still frame output, measure the average capture latency and if possible
    // ensure that the value is within the reported range.
    @Test
    public void testMultiFrameCapture() throws Exception {
        final int IMAGE_COUNT = 10;
        final int SUPPORTED_CAPTURE_OUTPUT_FORMATS[] = {
                ImageFormat.YUV_420_888,
                ImageFormat.JPEG
        };
        for (String id : mCameraIdsUnderTest) {
            StaticMetadata staticMeta =
                    new StaticMetadata(mTestRule.getCameraManager().getCameraCharacteristics(id));
            if (!staticMeta.isColorOutputSupported()) {
                continue;
            }
            updatePreviewSurfaceTexture();
            CameraExtensionCharacteristics extensionChars =
                    mTestRule.getCameraManager().getCameraExtensionCharacteristics(id);
            List<Integer> supportedExtensions = extensionChars.getSupportedExtensions();
            for (Integer extension : supportedExtensions) {
                for (int captureFormat : SUPPORTED_CAPTURE_OUTPUT_FORMATS) {
                    List<Size> extensionSizes = extensionChars.getExtensionSupportedSizes(extension,
                            captureFormat);
                    if (extensionSizes.isEmpty()) {
                        continue;
                    }
                    Size maxSize = CameraTestUtils.getMaxSize(extensionSizes.toArray(new Size[0]));
                    SimpleImageReaderListener imageListener = new SimpleImageReaderListener(false,
                            1);
                    ImageReader extensionImageReader = CameraTestUtils.makeImageReader(maxSize,
                            captureFormat, /*maxImages*/ 1, imageListener,
                            mTestRule.getHandler());
                    Surface imageReaderSurface = extensionImageReader.getSurface();
                    OutputConfiguration readerOutput = new OutputConfiguration(
                            OutputConfiguration.SURFACE_GROUP_ID_NONE, imageReaderSurface);
                    List<OutputConfiguration> outputConfigs = new ArrayList<>();
                    outputConfigs.add(readerOutput);

                    BlockingExtensionSessionCallback sessionListener =
                            new BlockingExtensionSessionCallback(mock(
                                    CameraExtensionSession.StateCallback.class));
                    ExtensionSessionConfiguration configuration =
                            new ExtensionSessionConfiguration(extension, outputConfigs,
                                    new HandlerExecutor(mTestRule.getHandler()),
                                    sessionListener);
                    String streamName = "test_extension_capture";
                    mReportLog = new DeviceReportLog(REPORT_LOG_NAME, streamName);
                    mReportLog.addValue("camera_id", id, ResultType.NEUTRAL, ResultUnit.NONE);
                    mReportLog.addValue("extension_id", extension, ResultType.NEUTRAL,
                            ResultUnit.NONE);
                    double[] captureTimes = new double[IMAGE_COUNT];
                    boolean captureResultsSupported =
                            !extensionChars.getAvailableCaptureResultKeys(extension).isEmpty();

                    try {
                        mTestRule.openDevice(id);
                        CameraDevice camera = mTestRule.getCamera();
                        camera.createExtensionSession(configuration);
                        CameraExtensionSession extensionSession =
                                sessionListener.waitAndGetSession(
                                        SESSION_CONFIGURE_TIMEOUT_MS);
                        assertNotNull(extensionSession);

                        CaptureRequest.Builder captureBuilder =
                                mTestRule.getCamera().createCaptureRequest(
                                        CameraDevice.TEMPLATE_STILL_CAPTURE);
                        captureBuilder.addTarget(imageReaderSurface);
                        CameraExtensionSession.ExtensionCaptureCallback captureMockCallback =
                                mock(CameraExtensionSession.ExtensionCaptureCallback.class);
                        SimpleCaptureCallback captureCallback =
                                new SimpleCaptureCallback(captureMockCallback,
                                        extensionChars.getAvailableCaptureResultKeys(extension),
                                        mCollector);

                        for (int i = 0; i < IMAGE_COUNT; i++) {
                            int jpegOrientation = (i * 90) % 360; // degrees [0..270]
                            if (captureFormat == ImageFormat.JPEG) {
                                captureBuilder.set(CaptureRequest.JPEG_ORIENTATION,
                                        jpegOrientation);
                            }
                            CaptureRequest request = captureBuilder.build();
                            long startTimeMs = SystemClock.elapsedRealtime();
                            int sequenceId = extensionSession.capture(request,
                                    new HandlerExecutor(mTestRule.getHandler()), captureCallback);

                            Image img =
                                    imageListener.getImage(MULTI_FRAME_CAPTURE_IMAGE_TIMEOUT_MS);
                            captureTimes[i] = SystemClock.elapsedRealtime() - startTimeMs;
                            if (captureFormat == ImageFormat.JPEG) {
                                verifyJpegOrientation(img, maxSize, jpegOrientation);
                            } else {
                                validateImage(img, maxSize.getWidth(), maxSize.getHeight(),
                                        captureFormat, null);
                            }
                            img.close();

                            verify(captureMockCallback, times(1))
                                    .onCaptureStarted(eq(extensionSession), eq(request), anyLong());
                            verify(captureMockCallback,
                                    timeout(MULTI_FRAME_CAPTURE_IMAGE_TIMEOUT_MS).times(1))
                                    .onCaptureProcessStarted(extensionSession, request);
                            verify(captureMockCallback,
                                    timeout(MULTI_FRAME_CAPTURE_IMAGE_TIMEOUT_MS).times(1))
                                    .onCaptureSequenceCompleted(extensionSession, sequenceId);
                            if (captureResultsSupported) {
                                verify(captureMockCallback,
                                        timeout(MULTI_FRAME_CAPTURE_IMAGE_TIMEOUT_MS).times(1))
                                        .onCaptureResultAvailable(eq(extensionSession), eq(request),
                                                any(TotalCaptureResult.class));
                            }
                        }

                        long avgCaptureLatency = (long) Stat.getAverage(captureTimes);
                        String resultFormat = "avg_latency size: " + maxSize.toString() +
                                " image format: " + captureFormat;
                        mReportLog.addValue(resultFormat, avgCaptureLatency,
                                ResultType.LOWER_BETTER, ResultUnit.MS);

                        verify(captureMockCallback, times(0))
                                .onCaptureSequenceAborted(any(CameraExtensionSession.class),
                                        anyInt());
                        verify(captureMockCallback, times(0))
                                .onCaptureFailed(any(CameraExtensionSession.class),
                                        any(CaptureRequest.class));
                        Range<Long> latencyRange =
                                extensionChars.getEstimatedCaptureLatencyRangeMillis(extension,
                                        maxSize, captureFormat);
                        if (latencyRange != null) {
                            String msg = String.format("Camera [%s]: The measured average "
                                            + "capture latency of %d ms. for extension type %d  "
                                            + "with image format: %d and size: %dx%d must be "
                                            + "within the advertised range of [%d, %d] ms.",
                                    id, avgCaptureLatency, extension, captureFormat,
                                    maxSize.getWidth(), maxSize.getHeight(),
                                    latencyRange.getLower(), latencyRange.getUpper());
                            assertTrue(msg, latencyRange.contains(avgCaptureLatency));
                        }

                        extensionSession.close();

                        sessionListener.getStateWaiter().waitForState(
                                BlockingExtensionSessionCallback.SESSION_CLOSED,
                                SESSION_CLOSE_TIMEOUT_MS);
                    } finally {
                        mTestRule.closeDevice(id);
                        extensionImageReader.close();
                        mReportLog.submit(InstrumentationRegistry.getInstrumentation());
                    }
                }
            }
        }
    }

    // Verify concurrent extension sessions behavior
    @Test
    public void testConcurrentSessions() throws Exception {
        Set<Set<String>> concurrentCameraIdSet =
                mTestRule.getCameraManager().getConcurrentCameraIds();
        if (concurrentCameraIdSet.isEmpty()) {
            return;
        }

        for (String id : mCameraIdsUnderTest) {
            StaticMetadata staticMeta =
                    new StaticMetadata(mTestRule.getCameraManager().getCameraCharacteristics(id));
            if (!staticMeta.isColorOutputSupported()) {
                continue;
            }
            CameraExtensionCharacteristics extensionChars =
                    mTestRule.getCameraManager().getCameraExtensionCharacteristics(id);
            List<Integer> supportedExtensions = extensionChars.getSupportedExtensions();
            if (supportedExtensions.isEmpty()) {
                continue;
            }

            Set<String> concurrentCameraIds = null;
            for (Set<String> entry : concurrentCameraIdSet) {
                if (entry.contains(id)) {
                    concurrentCameraIds = entry;
                    break;
                }
            }
            if (concurrentCameraIds == null) {
                continue;
            }

            String concurrentCameraId = null;
            CameraExtensionCharacteristics concurrentExtensionChars = null;
            for (String entry : concurrentCameraIds) {
                if (entry.equals(id)) {
                    continue;
                }
                if (!(new StaticMetadata(mTestRule.getCameraManager().getCameraCharacteristics(
                        entry))).isColorOutputSupported()) {
                    continue;
                }
                CameraExtensionCharacteristics chars =
                        mTestRule.getCameraManager().getCameraExtensionCharacteristics(entry);
                if (chars.getSupportedExtensions().isEmpty()) {
                    continue;
                }
                concurrentCameraId = entry;
                concurrentExtensionChars = chars;
                break;
            }
            if ((concurrentCameraId == null) || (concurrentExtensionChars == null)) {
                continue;
            }

            updatePreviewSurfaceTexture();
            int extensionId = supportedExtensions.get(0);
            List<Size> extensionSizes = extensionChars.getExtensionSupportedSizes(extensionId,
                    mSurfaceTexture.getClass());
            Size maxSize = CameraTestUtils.getMaxSize(extensionSizes.toArray(new Size[0]));
            mSurfaceTexture.setDefaultBufferSize(maxSize.getWidth(), maxSize.getHeight());
            OutputConfiguration outputConfig = new OutputConfiguration(
                    OutputConfiguration.SURFACE_GROUP_ID_NONE,
                    new Surface(mSurfaceTexture));
            List<OutputConfiguration> outputConfigs = new ArrayList<>();
            outputConfigs.add(outputConfig);

            BlockingExtensionSessionCallback sessionListener =
                    new BlockingExtensionSessionCallback(
                            mock(CameraExtensionSession.StateCallback.class));
            ExtensionSessionConfiguration configuration =
                    new ExtensionSessionConfiguration(extensionId, outputConfigs,
                            new HandlerExecutor(mTestRule.getHandler()), sessionListener);

            CameraDevice concurrentCameraDevice = null;
            ImageReader extensionImageReader = null;
            try {
                mTestRule.openDevice(id);
                CameraDevice camera = mTestRule.getCamera();
                camera.createExtensionSession(configuration);
                CameraExtensionSession extensionSession = sessionListener.waitAndGetSession(
                        SESSION_CONFIGURE_TIMEOUT_MS);
                assertNotNull(extensionSession);

                concurrentCameraDevice = CameraTestUtils.openCamera(mTestRule.getCameraManager(),
                        concurrentCameraId, new BlockingStateCallback(), mTestRule.getHandler());
                assertNotNull(concurrentCameraDevice);
                int concurrentExtensionId =
                        concurrentExtensionChars.getSupportedExtensions().get(0);
                List<Size> captureSizes = concurrentExtensionChars.getExtensionSupportedSizes(
                        concurrentExtensionId, mSurfaceTexture.getClass());
                assertFalse("No SurfaceTexture output supported", captureSizes.isEmpty());
                Size captureMaxSize =
                        CameraTestUtils.getMaxSize(captureSizes.toArray(new Size[0]));

                extensionImageReader = ImageReader.newInstance(
                        captureMaxSize.getWidth(), captureMaxSize.getHeight(), ImageFormat.PRIVATE,
                        /*maxImages*/ 1, HardwareBuffer.USAGE_GPU_SAMPLED_IMAGE);
                Surface imageReaderSurface = extensionImageReader.getSurface();
                OutputConfiguration readerOutput = new OutputConfiguration(
                        OutputConfiguration.SURFACE_GROUP_ID_NONE, imageReaderSurface);
                outputConfigs = new ArrayList<>();
                outputConfigs.add(readerOutput);
                CameraExtensionSession.StateCallback mockSessionListener =
                        mock(CameraExtensionSession.StateCallback.class);
                ExtensionSessionConfiguration concurrentConfiguration =
                        new ExtensionSessionConfiguration(concurrentExtensionId, outputConfigs,
                                new HandlerExecutor(mTestRule.getHandler()),
                                mockSessionListener);
                concurrentCameraDevice.createExtensionSession(concurrentConfiguration);
                // Trying to initialize multiple concurrent extension sessions is expected to fail
                verify(mockSessionListener, timeout(SESSION_CONFIGURE_TIMEOUT_MS).times(1))
                        .onConfigureFailed(any(CameraExtensionSession.class));
                verify(mockSessionListener, times(0)).onConfigured(
                        any(CameraExtensionSession.class));

                extensionSession.close();
                sessionListener.getStateWaiter().waitForState(
                        BlockingExtensionSessionCallback.SESSION_CLOSED,
                        SESSION_CLOSE_TIMEOUT_MS);

                // Initialization of another extension session must now be possible
                BlockingExtensionSessionCallback concurrentSessionListener =
                        new BlockingExtensionSessionCallback(
                                mock(CameraExtensionSession.StateCallback.class));
                concurrentConfiguration = new ExtensionSessionConfiguration(concurrentExtensionId,
                        outputConfigs, new HandlerExecutor(mTestRule.getHandler()),
                        concurrentSessionListener);
                concurrentCameraDevice.createExtensionSession(concurrentConfiguration);
                extensionSession = concurrentSessionListener.waitAndGetSession(
                        SESSION_CONFIGURE_TIMEOUT_MS);
                assertNotNull(extensionSession);
                extensionSession.close();
                concurrentSessionListener.getStateWaiter().waitForState(
                        BlockingExtensionSessionCallback.SESSION_CLOSED,
                        SESSION_CLOSE_TIMEOUT_MS);
            } finally {
                mTestRule.closeDevice(id);
                if (concurrentCameraDevice != null) {
                    concurrentCameraDevice.close();
                }
                if (extensionImageReader != null) {
                    extensionImageReader.close();
                }
            }
        }
    }

    // Test case combined repeating with multi frame capture on all supported extensions.
    // Verify still frame output.
    @Test
    public void testRepeatingAndCaptureCombined() throws Exception {
        for (String id : mCameraIdsUnderTest) {
            StaticMetadata staticMeta =
                    new StaticMetadata(mTestRule.getCameraManager().getCameraCharacteristics(id));
            if (!staticMeta.isColorOutputSupported()) {
                continue;
            }
            updatePreviewSurfaceTexture();
            CameraExtensionCharacteristics extensionChars =
                    mTestRule.getCameraManager().getCameraExtensionCharacteristics(id);
            List<Integer> supportedExtensions = extensionChars.getSupportedExtensions();
            for (Integer extension : supportedExtensions) {
                int captureFormat = ImageFormat.JPEG;
                List<Size> captureSizes = extensionChars.getExtensionSupportedSizes(extension,
                        captureFormat);
                assertFalse("No Jpeg output supported", captureSizes.isEmpty());
                Size captureMaxSize =
                        CameraTestUtils.getMaxSize(captureSizes.toArray(new Size[0]));

                SimpleImageReaderListener imageListener = new SimpleImageReaderListener(false
                        , 1);
                ImageReader extensionImageReader = CameraTestUtils.makeImageReader(
                        captureMaxSize, captureFormat, /*maxImages*/ 1, imageListener,
                        mTestRule.getHandler());
                Surface imageReaderSurface = extensionImageReader.getSurface();
                OutputConfiguration readerOutput = new OutputConfiguration(
                        OutputConfiguration.SURFACE_GROUP_ID_NONE, imageReaderSurface);
                List<OutputConfiguration> outputConfigs = new ArrayList<>();
                outputConfigs.add(readerOutput);

                // Pick a supported preview/repeating size with aspect ratio close to the
                // multi-frame capture size
                List<Size> repeatingSizes = extensionChars.getExtensionSupportedSizes(extension,
                        mSurfaceTexture.getClass());
                Size maxRepeatingSize =
                        CameraTestUtils.getMaxSize(repeatingSizes.toArray(new Size[0]));
                List<Size> previewSizes = getSupportedPreviewSizes(id,
                        mTestRule.getCameraManager(),
                        getPreviewSizeBound(mTestRule.getWindowManager(), PREVIEW_SIZE_BOUND));
                List<Size> supportedPreviewSizes =
                        previewSizes.stream().filter(repeatingSizes::contains).collect(
                                Collectors.toList());
                if (!supportedPreviewSizes.isEmpty()) {
                    float targetAr =
                            ((float) captureMaxSize.getWidth()) / captureMaxSize.getHeight();
                    for (Size s : supportedPreviewSizes) {
                        float currentAr = ((float) s.getWidth()) / s.getHeight();
                        if (Math.abs(targetAr - currentAr) < 0.01) {
                            maxRepeatingSize = s;
                            break;
                        }
                    }
                }

                boolean captureResultsSupported =
                        !extensionChars.getAvailableCaptureResultKeys(extension).isEmpty();

                mSurfaceTexture.setDefaultBufferSize(maxRepeatingSize.getWidth(),
                        maxRepeatingSize.getHeight());
                Surface texturedSurface = new Surface(mSurfaceTexture);
                outputConfigs.add(new OutputConfiguration(
                        OutputConfiguration.SURFACE_GROUP_ID_NONE, texturedSurface));

                BlockingExtensionSessionCallback sessionListener =
                        new BlockingExtensionSessionCallback(mock(
                                CameraExtensionSession.StateCallback.class));
                ExtensionSessionConfiguration configuration =
                        new ExtensionSessionConfiguration(extension, outputConfigs,
                                new HandlerExecutor(mTestRule.getHandler()),
                                sessionListener);
                try {
                    mTestRule.openDevice(id);
                    CameraDevice camera = mTestRule.getCamera();
                    camera.createExtensionSession(configuration);
                    CameraExtensionSession extensionSession =
                            sessionListener.waitAndGetSession(
                                    SESSION_CONFIGURE_TIMEOUT_MS);
                    assertNotNull(extensionSession);

                    CaptureRequest.Builder captureBuilder =
                            mTestRule.getCamera().createCaptureRequest(
                                    android.hardware.camera2.CameraDevice.TEMPLATE_PREVIEW);
                    captureBuilder.addTarget(texturedSurface);
                    CameraExtensionSession.ExtensionCaptureCallback repeatingCallbackMock =
                            mock(CameraExtensionSession.ExtensionCaptureCallback.class);
                    SimpleCaptureCallback repeatingCaptureCallback =
                            new SimpleCaptureCallback(repeatingCallbackMock,
                                    extensionChars.getAvailableCaptureResultKeys(extension),
                                    mCollector);
                    CaptureRequest repeatingRequest = captureBuilder.build();
                    int repeatingSequenceId =
                            extensionSession.setRepeatingRequest(repeatingRequest,
                                    new HandlerExecutor(mTestRule.getHandler()),
                                    repeatingCaptureCallback);

                    Thread.sleep(REPEATING_REQUEST_TIMEOUT_MS);

                    verify(repeatingCallbackMock, atLeastOnce())
                            .onCaptureStarted(eq(extensionSession), eq(repeatingRequest),
                                    anyLong());
                    verify(repeatingCallbackMock, atLeastOnce())
                            .onCaptureProcessStarted(extensionSession, repeatingRequest);
                    if (captureResultsSupported) {
                        verify(repeatingCallbackMock,
                                timeout(MULTI_FRAME_CAPTURE_IMAGE_TIMEOUT_MS).atLeastOnce())
                                .onCaptureResultAvailable(eq(extensionSession),
                                        eq(repeatingRequest), any(TotalCaptureResult.class));
                    }

                    captureBuilder = mTestRule.getCamera().createCaptureRequest(
                            android.hardware.camera2.CameraDevice.TEMPLATE_STILL_CAPTURE);
                    captureBuilder.addTarget(imageReaderSurface);
                    CameraExtensionSession.ExtensionCaptureCallback captureCallback =
                            mock(CameraExtensionSession.ExtensionCaptureCallback.class);

                    CaptureRequest captureRequest = captureBuilder.build();
                    int captureSequenceId = extensionSession.capture(captureRequest,
                            new HandlerExecutor(mTestRule.getHandler()), captureCallback);

                    Image img =
                            imageListener.getImage(MULTI_FRAME_CAPTURE_IMAGE_TIMEOUT_MS);
                    validateImage(img, captureMaxSize.getWidth(),
                            captureMaxSize.getHeight(), captureFormat, null);
                    img.close();

                    verify(captureCallback, times(1))
                            .onCaptureStarted(eq(extensionSession), eq(captureRequest),
                                    anyLong());
                    verify(captureCallback, timeout(MULTI_FRAME_CAPTURE_IMAGE_TIMEOUT_MS).times(1))
                            .onCaptureProcessStarted(extensionSession, captureRequest);
                    if (captureResultsSupported) {
                        verify(captureCallback,
                                timeout(MULTI_FRAME_CAPTURE_IMAGE_TIMEOUT_MS).times(1))
                                .onCaptureResultAvailable(eq(extensionSession),
                                        eq(captureRequest), any(TotalCaptureResult.class));
                    }
                    verify(captureCallback, timeout(MULTI_FRAME_CAPTURE_IMAGE_TIMEOUT_MS).times(1))
                            .onCaptureSequenceCompleted(extensionSession,
                                    captureSequenceId);
                    verify(captureCallback, times(0))
                            .onCaptureSequenceAborted(any(CameraExtensionSession.class),
                                    anyInt());
                    verify(captureCallback, times(0))
                            .onCaptureFailed(any(CameraExtensionSession.class),
                                    any(CaptureRequest.class));

                    extensionSession.stopRepeating();

                    verify(repeatingCallbackMock,
                            timeout(MULTI_FRAME_CAPTURE_IMAGE_TIMEOUT_MS).times(1))
                            .onCaptureSequenceCompleted(extensionSession, repeatingSequenceId);

                    verify(repeatingCallbackMock, times(0))
                            .onCaptureSequenceAborted(any(CameraExtensionSession.class),
                                    anyInt());

                    extensionSession.close();

                    sessionListener.getStateWaiter().waitForState(
                            BlockingExtensionSessionCallback.SESSION_CLOSED,
                            SESSION_CLOSE_TIMEOUT_MS);

                    assertTrue("The sum of onCaptureProcessStarted and onCaptureFailed" +
                                    " callbacks must be greater or equal than the number of calls" +
                                    " to onCaptureStarted!",
                            repeatingCaptureCallback.getTotalFramesArrived() +
                                    repeatingCaptureCallback.getTotalFramesFailed() >=
                            repeatingCaptureCallback.getTotalFramesStarted());
                    assertTrue(String.format("The last repeating request surface timestamp " +
                                    "%d must be less than or equal to the last " +
                                    "onCaptureStarted " +
                                    "timestamp %d", mSurfaceTexture.getTimestamp(),
                            repeatingCaptureCallback.getLastTimestamp()),
                            mSurfaceTexture.getTimestamp() <=
                                    repeatingCaptureCallback.getLastTimestamp());

                } finally {
                    mTestRule.closeDevice(id);
                    texturedSurface.release();
                    extensionImageReader.close();
                }
            }
        }
    }

    private void verifyJpegOrientation(Image img, Size jpegSize, int requestedOrientation)
            throws IOException {
        byte[] blobBuffer = getDataFromImage(img);
        String blobFilename = mTestRule.getDebugFileNameBase() + "/verifyJpegKeys.jpeg";
        dumpFile(blobFilename, blobBuffer);
        ExifInterface exif = new ExifInterface(blobFilename);
        int exifWidth = exif.getAttributeInt(ExifInterface.TAG_IMAGE_WIDTH, /*defaultValue*/0);
        int exifHeight = exif.getAttributeInt(ExifInterface.TAG_IMAGE_LENGTH, /*defaultValue*/0);
        Size exifSize = new Size(exifWidth, exifHeight);
        int exifOrientation = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION,
                /*defaultValue*/ ExifInterface.ORIENTATION_UNDEFINED);
        final int ORIENTATION_MIN = ExifInterface.ORIENTATION_UNDEFINED;
        final int ORIENTATION_MAX = ExifInterface.ORIENTATION_ROTATE_270;
        assertTrue(String.format("Exif orientation must be in range of [%d, %d]",
                ORIENTATION_MIN, ORIENTATION_MAX),
                exifOrientation >= ORIENTATION_MIN && exifOrientation <= ORIENTATION_MAX);

        /**
         * Device captured image doesn't respect the requested orientation,
         * which means it rotates the image buffer physically. Then we
         * should swap the exif width/height accordingly to compare.
         */
        boolean deviceRotatedImage = exifOrientation == ExifInterface.ORIENTATION_UNDEFINED;

        if (deviceRotatedImage) {
            // Case 1.
            boolean needSwap = (requestedOrientation % 180 == 90);
            if (needSwap) {
                exifSize = new Size(exifHeight, exifWidth);
            }
        } else {
            // Case 2.
            assertEquals("Exif orientation should match requested orientation",
                    requestedOrientation, getExifOrientationInDegree(exifOrientation));
        }

        assertEquals("Exif size should match jpeg capture size", jpegSize, exifSize);
    }

    private static int getExifOrientationInDegree(int exifOrientation) {
        switch (exifOrientation) {
            case ExifInterface.ORIENTATION_NORMAL:
                return 0;
            case ExifInterface.ORIENTATION_ROTATE_90:
                return 90;
            case ExifInterface.ORIENTATION_ROTATE_180:
                return 180;
            case ExifInterface.ORIENTATION_ROTATE_270:
                return 270;
            default:
                fail("It is impossible to get non 0, 90, 180, 270 degress exif" +
                        "info based on the request orientation range");
                return -1;
        }
    }

    public static class SimpleCaptureCallback
            extends CameraExtensionSession.ExtensionCaptureCallback {
        private long mLastTimestamp = -1;
        private int mNumFramesArrived = 0;
        private int mNumFramesStarted = 0;
        private int mNumFramesFailed = 0;
        private boolean mNonIncreasingTimestamps = false;
        private final CameraExtensionSession.ExtensionCaptureCallback mProxy;
        private final HashSet<CaptureResult.Key> mSupportedResultKeys;
        private final CameraErrorCollector mCollector;

        public SimpleCaptureCallback(CameraExtensionSession.ExtensionCaptureCallback proxy,
                Set<CaptureResult.Key> supportedResultKeys, CameraErrorCollector errorCollector) {
            mProxy = proxy;
            mSupportedResultKeys = new HashSet<>(supportedResultKeys);
            mCollector = errorCollector;
        }

        @Override
        public void onCaptureStarted(CameraExtensionSession session,
                                     CaptureRequest request, long timestamp) {

            if (timestamp < mLastTimestamp) {
                mNonIncreasingTimestamps = true;
            }
            mLastTimestamp = timestamp;
            mNumFramesStarted++;
            if (mProxy != null) {
                mProxy.onCaptureStarted(session, request, timestamp);
            }
        }

        @Override
        public void onCaptureProcessStarted(CameraExtensionSession session,
                                            CaptureRequest request) {
            mNumFramesArrived++;
            if (mProxy != null) {
                mProxy.onCaptureProcessStarted(session, request);
            }
        }

        @Override
        public void onCaptureFailed(CameraExtensionSession session,
                                    CaptureRequest request) {
            mNumFramesFailed++;
            if (mProxy != null) {
                mProxy.onCaptureFailed(session, request);
            }
        }

        @Override
        public void onCaptureSequenceAborted(CameraExtensionSession session,
                                             int sequenceId) {
            if (mProxy != null) {
                mProxy.onCaptureSequenceAborted(session, sequenceId);
            }
        }

        @Override
        public void onCaptureSequenceCompleted(CameraExtensionSession session,
                                               int sequenceId) {
            if (mProxy != null) {
                mProxy.onCaptureSequenceCompleted(session, sequenceId);
            }
        }

        @Override
        public void  onCaptureResultAvailable(CameraExtensionSession session,
                CaptureRequest request, TotalCaptureResult result) {
            if (mSupportedResultKeys.isEmpty()) {
                mCollector.addMessage("Capture results not supported, but " +
                        "onCaptureResultAvailable still got triggered!");
                return;
            }

            List<CaptureResult.Key<?>> resultKeys = result.getKeys();
            for (CaptureResult.Key<?> resultKey : resultKeys) {
                mCollector.expectTrue("Capture result " + resultKey + " is not among the"
                        + " supported result keys!", mSupportedResultKeys.contains(resultKey));
            }

            Integer jpegOrientation = request.get(CaptureRequest.JPEG_ORIENTATION);
            if (jpegOrientation != null) {
                Integer resultJpegOrientation = result.get(CaptureResult.JPEG_ORIENTATION);
                mCollector.expectTrue("Request Jpeg orientation: " + jpegOrientation +
                        " doesn't match with result: " + resultJpegOrientation,
                        jpegOrientation.equals(resultJpegOrientation));
            }

            Byte jpegQuality = request.get(CaptureRequest.JPEG_QUALITY);
            if (jpegQuality != null) {
                Byte resultJpegQuality = result.get(CaptureResult.JPEG_QUALITY);
                mCollector.expectTrue("Request Jpeg quality: " + jpegQuality +
                        " doesn't match with result: " + resultJpegQuality,
                        jpegQuality.equals(resultJpegQuality));
            }

            if (mProxy != null) {
                mProxy.onCaptureResultAvailable(session, request, result);
            }
        }

        public int getTotalFramesArrived() {
            return mNumFramesArrived;
        }

        public int getTotalFramesStarted() {
            return mNumFramesStarted;
        }

        public int getTotalFramesFailed() {
            return mNumFramesFailed;
        }

        public long getLastTimestamp() throws IllegalStateException {
            if (mNonIncreasingTimestamps) {
                throw new IllegalStateException("Non-monotonically increasing timestamps!");
            }
            return mLastTimestamp;
        }
    }

    @Test
    public void testIllegalArguments() throws Exception {
        for (String id : mCameraIdsUnderTest) {
            StaticMetadata staticMeta =
                    new StaticMetadata(mTestRule.getCameraManager().getCameraCharacteristics(id));
            if (!staticMeta.isColorOutputSupported()) {
                continue;
            }
            updatePreviewSurfaceTexture();
            CameraExtensionCharacteristics extensionChars =
                    mTestRule.getCameraManager().getCameraExtensionCharacteristics(id);
            List<Integer> supportedExtensions = extensionChars.getSupportedExtensions();
            for (Integer extension : supportedExtensions) {
                List<OutputConfiguration> outputConfigs = new ArrayList<>();
                BlockingExtensionSessionCallback sessionListener =
                        new BlockingExtensionSessionCallback(mock(
                                CameraExtensionSession.StateCallback.class));
                ExtensionSessionConfiguration configuration =
                        new ExtensionSessionConfiguration(extension, outputConfigs,
                                new HandlerExecutor(mTestRule.getHandler()),
                                sessionListener);

                try {
                    mTestRule.openDevice(id);
                    CameraDevice camera = mTestRule.getCamera();
                    try {
                        camera.createExtensionSession(configuration);
                        fail("should get IllegalArgumentException due to absent output surfaces");
                    } catch (IllegalArgumentException e) {
                        // Expected, we can proceed further
                    }

                    int captureFormat = ImageFormat.YUV_420_888;
                    List<Size> captureSizes = extensionChars.getExtensionSupportedSizes(extension,
                            captureFormat);
                    if (captureSizes.isEmpty()) {
                        captureFormat = ImageFormat.JPEG;
                        captureSizes = extensionChars.getExtensionSupportedSizes(extension,
                                captureFormat);
                    }
                    Size captureMaxSize =
                            CameraTestUtils.getMaxSize(captureSizes.toArray(new Size[0]));

                    mSurfaceTexture.setDefaultBufferSize(1, 1);
                    Surface texturedSurface = new Surface(mSurfaceTexture);
                    outputConfigs.add(new OutputConfiguration(
                            OutputConfiguration.SURFACE_GROUP_ID_NONE, texturedSurface));
                    configuration = new ExtensionSessionConfiguration(extension, outputConfigs,
                            new HandlerExecutor(mTestRule.getHandler()), sessionListener);

                    try {
                        camera.createExtensionSession(configuration);
                        fail("should get IllegalArgumentException due to illegal repeating request"
                                + " output surface");
                    } catch (IllegalArgumentException e) {
                        // Expected, we can proceed further
                    } finally {
                        outputConfigs.clear();
                    }

                    SimpleImageReaderListener imageListener = new SimpleImageReaderListener(false,
                            1);
                    Size invalidCaptureSize = new Size(1, 1);
                    ImageReader extensionImageReader = CameraTestUtils.makeImageReader(
                            invalidCaptureSize, captureFormat, /*maxImages*/ 1,
                            imageListener, mTestRule.getHandler());
                    Surface imageReaderSurface = extensionImageReader.getSurface();
                    OutputConfiguration readerOutput = new OutputConfiguration(
                            OutputConfiguration.SURFACE_GROUP_ID_NONE, imageReaderSurface);
                    outputConfigs.add(readerOutput);
                    configuration = new ExtensionSessionConfiguration(extension, outputConfigs,
                            new HandlerExecutor(mTestRule.getHandler()), sessionListener);

                    try{
                        camera.createExtensionSession(configuration);
                        fail("should get IllegalArgumentException due to illegal multi-frame"
                                + " request output surface");
                    } catch (IllegalArgumentException e) {
                        // Expected, we can proceed further
                    } finally {
                        outputConfigs.clear();
                        extensionImageReader.close();
                    }

                    // Pick a supported preview/repeating size with aspect ratio close to the
                    // multi-frame capture size
                    List<Size> repeatingSizes = extensionChars.getExtensionSupportedSizes(extension,
                            mSurfaceTexture.getClass());
                    Size maxRepeatingSize =
                            CameraTestUtils.getMaxSize(repeatingSizes.toArray(new Size[0]));
                    List<Size> previewSizes = getSupportedPreviewSizes(id,
                            mTestRule.getCameraManager(),
                            getPreviewSizeBound(mTestRule.getWindowManager(), PREVIEW_SIZE_BOUND));
                    List<Size> supportedPreviewSizes =
                            previewSizes.stream().filter(repeatingSizes::contains).collect(
                                    Collectors.toList());
                    if (!supportedPreviewSizes.isEmpty()) {
                        float targetAr =
                                ((float) captureMaxSize.getWidth()) / captureMaxSize.getHeight();
                        for (Size s : supportedPreviewSizes) {
                            float currentAr = ((float) s.getWidth()) / s.getHeight();
                            if (Math.abs(targetAr - currentAr) < 0.01) {
                                maxRepeatingSize = s;
                                break;
                            }
                        }
                    }

                    imageListener = new SimpleImageReaderListener(false, 1);
                    extensionImageReader = CameraTestUtils.makeImageReader(captureMaxSize,
                            captureFormat, /*maxImages*/ 1, imageListener, mTestRule.getHandler());
                    imageReaderSurface = extensionImageReader.getSurface();
                    readerOutput = new OutputConfiguration(OutputConfiguration.SURFACE_GROUP_ID_NONE,
                            imageReaderSurface);
                    outputConfigs.add(readerOutput);

                    mSurfaceTexture.setDefaultBufferSize(maxRepeatingSize.getWidth(),
                            maxRepeatingSize.getHeight());
                    texturedSurface = new Surface(mSurfaceTexture);
                    outputConfigs.add(new OutputConfiguration(
                            OutputConfiguration.SURFACE_GROUP_ID_NONE, texturedSurface));

                    configuration = new ExtensionSessionConfiguration(extension, outputConfigs,
                            new HandlerExecutor(mTestRule.getHandler()), sessionListener);
                    camera.createExtensionSession(configuration);
                    CameraExtensionSession extensionSession =
                            sessionListener.waitAndGetSession(
                                    SESSION_CONFIGURE_TIMEOUT_MS);
                    assertNotNull(extensionSession);

                    CaptureRequest.Builder captureBuilder =
                            mTestRule.getCamera().createCaptureRequest(
                                    android.hardware.camera2.CameraDevice.TEMPLATE_PREVIEW);
                    captureBuilder.addTarget(imageReaderSurface);
                    CameraExtensionSession.ExtensionCaptureCallback repeatingCallbackMock =
                            mock(CameraExtensionSession.ExtensionCaptureCallback.class);
                    SimpleCaptureCallback repeatingCaptureCallback =
                            new SimpleCaptureCallback(repeatingCallbackMock,
                                    extensionChars.getAvailableCaptureResultKeys(extension),
                                    mCollector);
                    CaptureRequest repeatingRequest = captureBuilder.build();
                    try {
                        extensionSession.setRepeatingRequest(repeatingRequest,
                                new HandlerExecutor(mTestRule.getHandler()),
                                repeatingCaptureCallback);
                        fail("should get IllegalArgumentException due to illegal repeating request"
                                + " output target");
                    } catch (IllegalArgumentException e) {
                        // Expected, we can proceed further
                    }

                    captureBuilder = mTestRule.getCamera().createCaptureRequest(
                            android.hardware.camera2.CameraDevice.TEMPLATE_STILL_CAPTURE);
                    captureBuilder.addTarget(texturedSurface);
                    CameraExtensionSession.ExtensionCaptureCallback captureCallback =
                            mock(CameraExtensionSession.ExtensionCaptureCallback.class);

                    CaptureRequest captureRequest = captureBuilder.build();
                    try {
                        extensionSession.capture(captureRequest,
                                new HandlerExecutor(mTestRule.getHandler()), captureCallback);
                        fail("should get IllegalArgumentException due to illegal multi-frame"
                                + " request output target");
                    } catch (IllegalArgumentException e) {
                        // Expected, we can proceed further
                    }

                    extensionSession.close();

                    sessionListener.getStateWaiter().waitForState(
                            BlockingExtensionSessionCallback.SESSION_CLOSED,
                            SESSION_CLOSE_TIMEOUT_MS);

                    texturedSurface.release();
                    extensionImageReader.close();

                    try {
                        extensionSession.setRepeatingRequest(captureRequest,
                                new HandlerExecutor(mTestRule.getHandler()), captureCallback);
                        fail("should get IllegalStateException due to closed session");
                    } catch (IllegalStateException e) {
                        // Expected, we can proceed further
                    }

                    try {
                        extensionSession.stopRepeating();
                        fail("should get IllegalStateException due to closed session");
                    } catch (IllegalStateException e) {
                        // Expected, we can proceed further
                    }

                    try {
                        extensionSession.capture(captureRequest,
                                new HandlerExecutor(mTestRule.getHandler()), captureCallback);
                        fail("should get IllegalStateException due to closed session");
                    } catch (IllegalStateException e) {
                        // Expected, we can proceed further
                    }
                } finally {
                    mTestRule.closeDevice(id);
                }
            }
        }
    }
}