/*
 *  Copyright 2016 The WebRTC project authors. All Rights Reserved.
 *
 *  Use of this source code is governed by a BSD-style license
 *  that can be found in the LICENSE file in the root of the source
 *  tree. An additional intellectual property rights grant can be found
 *  in the file PATENTS.  All contributing project authors may
 *  be found in the AUTHORS file in the root of the source tree.
 */

package org.webrtc;

import org.webrtc.CameraEnumerationAndroid.CaptureFormat;

import android.annotation.TargetApi;
import android.content.Context;
import android.graphics.SurfaceTexture;
import android.hardware.camera2.CameraAccessException;
import android.hardware.camera2.CameraCaptureSession;
import android.hardware.camera2.CameraCharacteristics;
import android.hardware.camera2.CameraDevice;
import android.hardware.camera2.CameraManager;
import android.hardware.camera2.CameraMetadata;
import android.hardware.camera2.CaptureFailure;
import android.hardware.camera2.CaptureRequest;
import android.hardware.camera2.TotalCaptureResult;
import android.hardware.camera2.params.StreamConfigurationMap;
import android.os.Build;
import android.os.Handler;
import android.os.SystemClock;
import android.util.Range;
import android.view.Surface;
import android.view.WindowManager;

import java.util.Arrays;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicBoolean;

@TargetApi(21)
public class Camera2Capturer implements
    CameraVideoCapturer,
    SurfaceTextureHelper.OnTextureFrameAvailableListener {
  private final static String TAG = "Camera2Capturer";

  private final static int MAX_OPEN_CAMERA_ATTEMPTS = 3;
  private final static int OPEN_CAMERA_DELAY_MS = 500;
  private final static int STOP_TIMEOUT = 10000;
  private final static int START_TIMEOUT = 10000;
  private final static Object STOP_TIMEOUT_RUNNABLE_TOKEN = new Object();

  // In the Camera2 API, starting a camera is inherently asynchronous, and this state is
  // represented with 'STARTING'. Stopping is also asynchronous and this state is 'STOPPING'.
  private static enum CameraState { IDLE, STARTING, RUNNING, STOPPING }

  // Thread safe objects.
  // --------------------
  private final CameraManager cameraManager;
  private final CameraEventsHandler eventsHandler;

  // Set once in initialization(), before any other calls, so therefore thread safe.
  // ---------------------------------------------------------------------------------------------
  private SurfaceTextureHelper surfaceTextureHelper;
  private Context applicationContext;
  private CapturerObserver capturerObserver;
  // Use postOnCameraThread() instead of posting directly to the handler - this way all callbacks
  // with a specifed token can be removed at once.
  private Handler cameraThreadHandler;

  // Shared state - guarded by cameraStateLock. Will only be edited from camera thread (when it is
  // running).
  // ---------------------------------------------------------------------------------------------
  private final Object cameraStateLock = new Object();
  private volatile CameraState cameraState = CameraState.IDLE;
  // Remember the requested format in case we want to switch cameras.
  private int requestedWidth;
  private int requestedHeight;
  private int requestedFramerate;

  // Will only be edited while camera state is IDLE and cameraStateLock is acquired.
  private String cameraName;
  private boolean isFrontCamera;
  private int cameraOrientation;

  // Atomic boolean for allowing only one switch at a time.
  private final AtomicBoolean isPendingCameraSwitch = new AtomicBoolean();
  // Guarded by isPendingCameraSwitch.
  private CameraSwitchHandler switchEventsHandler;

  // Internal state - must only be modified from camera thread
  // ---------------------------------------------------------
  private CaptureFormat captureFormat;
  private CameraStatistics cameraStatistics;
  private CameraCaptureSession captureSession;
  private Surface surface;
  private CameraDevice cameraDevice;

  // Factor to convert between Android framerates and CaptureFormat.FramerateRange. It will be
  // either 1 or 1000.
  private int fpsUnitFactor;
  private boolean firstFrameReported;
  private int consecutiveCameraOpenFailures;

  public Camera2Capturer(
      Context context, String cameraName, CameraEventsHandler eventsHandler) {
    Logging.d(TAG, "Camera2Capturer ctor, camera name: " + cameraName);
    this.cameraManager = (CameraManager) context.getSystemService(Context.CAMERA_SERVICE);
    this.eventsHandler = eventsHandler;

    setCameraName(cameraName);
  }

  private boolean isOnCameraThread() {
    return Thread.currentThread() == cameraThreadHandler.getLooper().getThread();
  }

  /**
   * Helper method for checking method is executed on camera thread.
   */
  private void checkIsOnCameraThread() {
    if (!isOnCameraThread()) {
      throw new IllegalStateException("Not on camera thread");
    }
  }

  /**
   * Checks method is not invoked on the camera thread. Used in functions waiting for the camera
   * state to change since executing them on the camera thread would cause a deadlock.
   */
  private void checkNotOnCameraThread() {
    if (cameraThreadHandler == null) {
      return;
    }

    if (Thread.currentThread() == cameraThreadHandler.getLooper().getThread()) {
      throw new IllegalStateException(
          "Method waiting for camera state to change executed on camera thread");
    }
  }

  private void waitForCameraToExitTransitionalState(
      CameraState transitionalState, long timeoutMs) {
    checkNotOnCameraThread();

    // We probably should already have the lock when this is called but acquire it in case
    // we don't have it.
    synchronized (cameraStateLock) {
      long timeoutAt = SystemClock.uptimeMillis() + timeoutMs;

      while (cameraState == transitionalState) {
        Logging.d(TAG, "waitForCameraToExitTransitionalState waiting: "
            + cameraState);

        long timeLeft = timeoutAt - SystemClock.uptimeMillis();

        if (timeLeft <= 0) {
          Logging.e(TAG, "Camera failed to exit transitional state " + transitionalState
              + " within the time limit.");
          break;
        }

        try {
          cameraStateLock.wait(timeLeft);
        } catch (InterruptedException e) {
          Logging.w(TAG, "Trying to interrupt while waiting to exit transitional state "
            + transitionalState + ", ignoring: " + e);
        }
      }
    }
  }

  /**
   * Waits until camera state is not STOPPING.
   */
  private void waitForCameraToStopIfStopping() {
    waitForCameraToExitTransitionalState(CameraState.STOPPING, STOP_TIMEOUT);
  }

  /**
   * Wait until camera state is not STARTING.
   */
  private void waitForCameraToStartIfStarting() {
    waitForCameraToExitTransitionalState(CameraState.STARTING, START_TIMEOUT);
  }

  /**
   * Sets the name of the camera. Camera must be stopped or stopping when this is called.
   */
  private void setCameraName(String cameraName) {
    final CameraCharacteristics characteristics;
    try {
      final String[] cameraIds = cameraManager.getCameraIdList();

      if (cameraName.isEmpty() && cameraIds.length != 0) {
        cameraName = cameraIds[0];
      }

      if (!Arrays.asList(cameraIds).contains(cameraName)) {
        throw new IllegalArgumentException(
            "Camera name: " + cameraName + " does not match any known camera device:");
      }

      characteristics = cameraManager.getCameraCharacteristics(cameraName);
    } catch (CameraAccessException e) {
      throw new RuntimeException("Camera access exception: " + e);
    }

    synchronized (cameraStateLock) {
      waitForCameraToStopIfStopping();

      if (cameraState != CameraState.IDLE) {
        throw new RuntimeException("Changing camera name on running camera.");
      }

      // Note: Usually changing camera state from outside camera thread is not allowed. It is
      // allowed here because camera is not running.
      this.cameraName = cameraName;
      isFrontCamera = characteristics.get(CameraCharacteristics.LENS_FACING)
          == CameraMetadata.LENS_FACING_FRONT;

      /*
       * Clockwise angle through which the output image needs to be rotated to be upright on the
       * device screen in its native orientation.
       * Also defines the direction of rolling shutter readout, which is from top to bottom in the
       * sensor's coordinate system.
       * Units: Degrees of clockwise rotation; always a multiple of 90
       */
      cameraOrientation = characteristics.get(CameraCharacteristics.SENSOR_ORIENTATION);
    }
  }

  /**
   * Triggers appropriate error handlers based on the camera state. Must be called on the camera
   * thread and camera must not be stopped.
   */
  private void reportError(String errorDescription) {
    checkIsOnCameraThread();
    Logging.e(TAG, "Error in camera at state " + cameraState + ": " + errorDescription);

    if (switchEventsHandler != null) {
      switchEventsHandler.onCameraSwitchError(errorDescription);
      switchEventsHandler = null;
    }
    isPendingCameraSwitch.set(false);

    switch (cameraState) {
      case STARTING:
        capturerObserver.onCapturerStarted(false /* success */);
        // fall through
      case RUNNING:
        if (eventsHandler != null) {
          eventsHandler.onCameraError(errorDescription);
        }
        break;
      case STOPPING:
        setCameraState(CameraState.IDLE);
        Logging.e(TAG, "Closing camera failed: " + errorDescription);
        return; // We don't want to call closeAndRelease in this case.
      default:
        throw new RuntimeException("Unknown camera state: " + cameraState);
    }
    closeAndRelease();
  }

  private void closeAndRelease() {
    checkIsOnCameraThread();

    Logging.d(TAG, "Close and release.");
    setCameraState(CameraState.STOPPING);

    // Remove all pending Runnables posted from |this|.
    cameraThreadHandler.removeCallbacksAndMessages(this /* token */);
    if (cameraStatistics != null) {
      cameraStatistics.release();
      cameraStatistics = null;
    }
    if (surfaceTextureHelper != null) {
      surfaceTextureHelper.stopListening();
    }
    if (captureSession != null) {
      captureSession.close();
      captureSession = null;
    }
    if (surface != null) {
      surface.release();
      surface = null;
    }
    if (cameraDevice != null) {
      // Add a timeout for stopping the camera.
      cameraThreadHandler.postAtTime(new Runnable() {
        @Override
        public void run() {
          Logging.e(TAG, "Camera failed to stop within the timeout. Force stopping.");
          setCameraState(CameraState.IDLE);
          if (eventsHandler != null) {
            eventsHandler.onCameraError("Camera failed to stop (timeout).");
          }
        }
      }, STOP_TIMEOUT_RUNNABLE_TOKEN, SystemClock.uptimeMillis() + STOP_TIMEOUT);

      cameraDevice.close();
      cameraDevice = null;
    } else {
      Logging.w(TAG, "closeAndRelease called while cameraDevice is null");
      setCameraState(CameraState.IDLE);
    }
  }

  /**
   * Sets the camera state while ensuring constraints are followed.
   */
  private void setCameraState(CameraState newState) {
    // State must only be modified on the camera thread. It can be edited from other threads
    // if cameraState is IDLE since the camera thread is idle and not modifying the state.
    if (cameraState != CameraState.IDLE) {
      checkIsOnCameraThread();
    }

    switch (newState) {
      case STARTING:
        if (cameraState != CameraState.IDLE) {
          throw new IllegalStateException("Only stopped camera can start.");
        }
        break;
      case RUNNING:
        if (cameraState != CameraState.STARTING) {
          throw new IllegalStateException("Only starting camera can go to running state.");
        }
        break;
      case STOPPING:
        if (cameraState != CameraState.STARTING && cameraState != CameraState.RUNNING) {
          throw new IllegalStateException("Only starting or running camera can stop.");
        }
        break;
      case IDLE:
        if (cameraState != CameraState.STOPPING) {
          throw new IllegalStateException("Only stopping camera can go to idle state.");
        }
        break;
      default:
        throw new RuntimeException("Unknown camera state: " + newState);
    }

    synchronized (cameraStateLock) {
      cameraState = newState;
      cameraStateLock.notifyAll();
    }
  }

  /**
   * Internal method for opening the camera. Must be called on the camera thread.
   */
  private void openCamera() {
    try {
      checkIsOnCameraThread();

      if (cameraState != CameraState.STARTING) {
        throw new IllegalStateException("Camera should be in state STARTING in openCamera.");
      }

      // Camera is in state STARTING so cameraName will not be edited.
      cameraManager.openCamera(cameraName, new CameraStateCallback(), cameraThreadHandler);
    } catch (CameraAccessException e) {
      reportError("Failed to open camera: " + e);
    }
  }

  private boolean isInitialized() {
    return applicationContext != null && capturerObserver != null;
  }

  @Override
  public void initialize(SurfaceTextureHelper surfaceTextureHelper, Context applicationContext,
      CapturerObserver capturerObserver) {
    Logging.d(TAG, "initialize");
    if (applicationContext == null) {
      throw new IllegalArgumentException("applicationContext not set.");
    }
    if (capturerObserver == null) {
      throw new IllegalArgumentException("capturerObserver not set.");
    }
    if (isInitialized()) {
      throw new IllegalStateException("Already initialized");
    }
    this.applicationContext = applicationContext;
    this.capturerObserver = capturerObserver;
    this.surfaceTextureHelper = surfaceTextureHelper;
    this.cameraThreadHandler =
        surfaceTextureHelper == null ? null : surfaceTextureHelper.getHandler();
  }

  private void startCaptureOnCameraThread(
      final int requestedWidth, final int requestedHeight, final int requestedFramerate) {
    checkIsOnCameraThread();

    firstFrameReported = false;
    consecutiveCameraOpenFailures = 0;

    synchronized (cameraStateLock) {
      // Remember the requested format in case we want to switch cameras.
      this.requestedWidth = requestedWidth;
      this.requestedHeight = requestedHeight;
      this.requestedFramerate = requestedFramerate;
    }

    final CameraCharacteristics cameraCharacteristics;
    try {
      // Camera is in state STARTING so cameraName will not be edited.
      cameraCharacteristics = cameraManager.getCameraCharacteristics(cameraName);
    } catch (CameraAccessException e) {
      reportError("getCameraCharacteristics(): " + e.getMessage());
      return;
    }

    List<CaptureFormat.FramerateRange> framerateRanges =
        Camera2Enumerator.getSupportedFramerateRanges(cameraCharacteristics);
    List<Size> sizes = Camera2Enumerator.getSupportedSizes(cameraCharacteristics);

    if (framerateRanges.isEmpty() || sizes.isEmpty()) {
      reportError("No supported capture formats.");
    }

    // Some LEGACY camera implementations use fps rates that are multiplied with 1000. Make sure
    // all values are multiplied with 1000 for consistency.
    this.fpsUnitFactor = (framerateRanges.get(0).max > 1000) ? 1 : 1000;

    final CaptureFormat.FramerateRange bestFpsRange =
        CameraEnumerationAndroid.getClosestSupportedFramerateRange(
            framerateRanges, requestedFramerate);

    final Size bestSize = CameraEnumerationAndroid.getClosestSupportedSize(
        sizes, requestedWidth, requestedHeight);

    this.captureFormat = new CaptureFormat(bestSize.width, bestSize.height, bestFpsRange);
    Logging.d(TAG, "Using capture format: " + captureFormat);

    Logging.d(TAG, "Opening camera " + cameraName);
    if (eventsHandler != null) {
      int cameraIndex = -1;
      try {
        cameraIndex = Integer.parseInt(cameraName);
      } catch (NumberFormatException e) {
        Logging.d(TAG, "External camera with non-int identifier: " + cameraName);
      }
      eventsHandler.onCameraOpening(cameraIndex);
    }

    openCamera();
  }

  /**
   * Starts capture using specified settings. This is automatically called for you by
   * VideoCapturerTrackSource if you are just using the camera as source for video track.
   */
  @Override
  public void startCapture(
      final int requestedWidth, final int requestedHeight, final int requestedFramerate) {
    Logging.d(TAG, "startCapture requested: " + requestedWidth + "x" + requestedHeight
        + "@" + requestedFramerate);
    if (!isInitialized()) {
      throw new IllegalStateException("startCapture called in uninitialized state");
    }
    if (surfaceTextureHelper == null) {
      capturerObserver.onCapturerStarted(false /* success */);
      if (eventsHandler != null) {
        eventsHandler.onCameraError("No SurfaceTexture created.");
      }
      return;
    }
    synchronized (cameraStateLock) {
      waitForCameraToStopIfStopping();
      if (cameraState != CameraState.IDLE) {
        Logging.e(TAG, "Unexpected camera state for startCapture: " + cameraState);
        return;
      }
      setCameraState(CameraState.STARTING);
    }

    postOnCameraThread(new Runnable() {
      @Override
      public void run() {
        startCaptureOnCameraThread(requestedWidth, requestedHeight, requestedFramerate);
      }
    });
  }

  final class CameraStateCallback extends CameraDevice.StateCallback {
    private String getErrorDescription(int errorCode) {
      switch (errorCode) {
        case CameraDevice.StateCallback.ERROR_CAMERA_DEVICE:
          return "Camera device has encountered a fatal error.";
        case CameraDevice.StateCallback.ERROR_CAMERA_DISABLED:
          return "Camera device could not be opened due to a device policy.";
        case CameraDevice.StateCallback.ERROR_CAMERA_IN_USE:
          return "Camera device is in use already.";
        case CameraDevice.StateCallback.ERROR_CAMERA_SERVICE:
          return "Camera service has encountered a fatal error.";
        case CameraDevice.StateCallback.ERROR_MAX_CAMERAS_IN_USE:
          return "Camera device could not be opened because"
              + " there are too many other open camera devices.";
        default:
          return "Unknown camera error: " + errorCode;
      }
    }

    @Override
    public void onDisconnected(CameraDevice camera) {
      checkIsOnCameraThread();
      cameraDevice = camera;
      reportError("Camera disconnected.");
    }

    @Override
    public void onError(CameraDevice camera, int errorCode) {
      checkIsOnCameraThread();
      cameraDevice = camera;

      if (cameraState == CameraState.STARTING && (
          errorCode == CameraDevice.StateCallback.ERROR_CAMERA_IN_USE ||
          errorCode == CameraDevice.StateCallback.ERROR_MAX_CAMERAS_IN_USE)) {
        consecutiveCameraOpenFailures++;

        if (consecutiveCameraOpenFailures < MAX_OPEN_CAMERA_ATTEMPTS) {
          Logging.w(TAG, "Opening camera failed, trying again: " + getErrorDescription(errorCode));

          postDelayedOnCameraThread(OPEN_CAMERA_DELAY_MS, new Runnable() {
            public void run() {
              openCamera();
            }
          });
          return;
        } else {
          Logging.e(TAG, "Opening camera failed too many times. Passing the error.");
        }
      }

      reportError(getErrorDescription(errorCode));
    }

    @Override
    public void onOpened(CameraDevice camera) {
      checkIsOnCameraThread();

      Logging.d(TAG, "Camera opened.");
      if (cameraState != CameraState.STARTING) {
        throw new IllegalStateException("Unexpected state when camera opened: " + cameraState);
      }

      cameraDevice = camera;
      final SurfaceTexture surfaceTexture = surfaceTextureHelper.getSurfaceTexture();
      surfaceTexture.setDefaultBufferSize(captureFormat.width, captureFormat.height);
      surface = new Surface(surfaceTexture);
      try {
        camera.createCaptureSession(
            Arrays.asList(surface), new CaptureSessionCallback(), cameraThreadHandler);
      } catch (CameraAccessException e) {
        reportError("Failed to create capture session. " + e);
      }
    }

    @Override
    public void onClosed(CameraDevice camera) {
      checkIsOnCameraThread();

      Logging.d(TAG, "Camera device closed.");

      if (cameraState != CameraState.STOPPING) {
        Logging.e(TAG, "Camera state was not STOPPING in onClosed. Most likely camera didn't stop "
            + "within timelimit and this method was invoked twice.");
        return;
      }

      cameraThreadHandler.removeCallbacksAndMessages(STOP_TIMEOUT_RUNNABLE_TOKEN);
      setCameraState(CameraState.IDLE);
      if (eventsHandler != null) {
        eventsHandler.onCameraClosed();
      }
      capturerObserver.onCapturerStopped();
    }
  }

  final class CaptureSessionCallback extends CameraCaptureSession.StateCallback {
    @Override
    public void onConfigureFailed(CameraCaptureSession session) {
      checkIsOnCameraThread();
      captureSession = session;
      reportError("Failed to configure capture session.");
    }

    @Override
    public void onConfigured(CameraCaptureSession session) {
      checkIsOnCameraThread();
      Logging.d(TAG, "Camera capture session configured.");
      captureSession = session;
      try {
        /*
         * The viable options for video capture requests are:
         * TEMPLATE_PREVIEW: High frame rate is given priority over the highest-quality
         *   post-processing.
         * TEMPLATE_RECORD: Stable frame rate is used, and post-processing is set for recording
         *   quality.
         */
        final CaptureRequest.Builder captureRequestBuilder =
            cameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_RECORD);
        // Set auto exposure fps range.
        captureRequestBuilder.set(CaptureRequest.CONTROL_AE_TARGET_FPS_RANGE, new Range<Integer>(
            captureFormat.framerate.min / fpsUnitFactor,
            captureFormat.framerate.max / fpsUnitFactor));
        captureRequestBuilder.set(CaptureRequest.CONTROL_AE_MODE,
            CaptureRequest.CONTROL_AE_MODE_ON);
        captureRequestBuilder.set(CaptureRequest.CONTROL_AE_LOCK, false);

        captureRequestBuilder.addTarget(surface);
        session.setRepeatingRequest(
            captureRequestBuilder.build(), new CameraCaptureCallback(), cameraThreadHandler);
      } catch (CameraAccessException e) {
        reportError("Failed to start capture request. " + e);
        return;
      }

      Logging.d(TAG, "Camera device successfully started.");
      surfaceTextureHelper.startListening(Camera2Capturer.this);
      capturerObserver.onCapturerStarted(true /* success */);
      cameraStatistics = new CameraStatistics(surfaceTextureHelper, eventsHandler);
      setCameraState(CameraState.RUNNING);

      if (switchEventsHandler != null) {
        switchEventsHandler.onCameraSwitchDone(isFrontCamera);
        switchEventsHandler = null;
      }
      isPendingCameraSwitch.set(false);
    }
  }

  final class CameraCaptureCallback extends CameraCaptureSession.CaptureCallback {
    static final int MAX_CONSECUTIVE_CAMERA_CAPTURE_FAILURES = 10;
    int consecutiveCameraCaptureFailures;

    @Override
    public void onCaptureFailed(
        CameraCaptureSession session, CaptureRequest request, CaptureFailure failure) {
      checkIsOnCameraThread();
      ++consecutiveCameraCaptureFailures;
      if (consecutiveCameraCaptureFailures > MAX_CONSECUTIVE_CAMERA_CAPTURE_FAILURES) {
        reportError("Capture failed " + consecutiveCameraCaptureFailures + " consecutive times.");
      }
    }

    @Override
    public void onCaptureCompleted(
          CameraCaptureSession session, CaptureRequest request, TotalCaptureResult result) {
      // TODO(sakal): This sometimes gets called after camera has stopped, investigate
      checkIsOnCameraThread();
      consecutiveCameraCaptureFailures = 0;
    }
  }


  // Switch camera to the next valid camera id. This can only be called while
  // the camera is running.
  @Override
  public void switchCamera(final CameraSwitchHandler switchEventsHandler) {
    final String[] cameraIds;
    try {
      cameraIds = cameraManager.getCameraIdList();
    } catch (CameraAccessException e) {
      if (switchEventsHandler != null) {
        switchEventsHandler.onCameraSwitchError("Could not get camera names: " + e);
      }
      return;
    }
    if (cameraIds.length < 2) {
      if (switchEventsHandler != null) {
        switchEventsHandler.onCameraSwitchError("No camera to switch to.");
      }
      return;
    }
    // Do not handle multiple camera switch request to avoid blocking camera thread by handling too
    // many switch request from a queue. We have to be careful to always release
    // |isPendingCameraSwitch| by setting it to false when done.
    if (isPendingCameraSwitch.getAndSet(true)) {
      Logging.w(TAG, "Ignoring camera switch request.");
      if (switchEventsHandler != null) {
        switchEventsHandler.onCameraSwitchError("Pending camera switch already in progress.");
      }
      return;
    }

    final String newCameraId;
    final int requestedWidth;
    final int requestedHeight;
    final int requestedFramerate;

    synchronized (cameraStateLock) {
      waitForCameraToStartIfStarting();

      if (cameraState != CameraState.RUNNING) {
        Logging.e(TAG, "Calling swithCamera() on stopped camera.");
        if (switchEventsHandler != null) {
          switchEventsHandler.onCameraSwitchError("Camera is stopped.");
        }
        isPendingCameraSwitch.set(false);
        return;
      }

      // Calculate new camera index and camera id. Camera is in state RUNNING so cameraName will
      // not be edited.
      final int currentCameraIndex = Arrays.asList(cameraIds).indexOf(cameraName);
      if (currentCameraIndex == -1) {
        Logging.e(TAG, "Couldn't find current camera id " + cameraName
            + " in list of camera ids: " + Arrays.toString(cameraIds));
      }
      final int newCameraIndex = (currentCameraIndex + 1) % cameraIds.length;
      newCameraId = cameraIds[newCameraIndex];

      requestedWidth = this.requestedWidth;
      requestedHeight = this.requestedHeight;
      requestedFramerate = this.requestedFramerate;
      this.switchEventsHandler = switchEventsHandler;
    }

    // Make the switch.
    stopCapture();
    setCameraName(newCameraId);
    startCapture(requestedWidth, requestedHeight, requestedFramerate);

    // Note: switchEventsHandler will be called from onConfigured / reportError.
  }

  // Requests a new output format from the video capturer. Captured frames
  // by the camera will be scaled/or dropped by the video capturer.
  // It does not matter if width and height are flipped. I.E, |width| = 640, |height| = 480 produce
  // the same result as |width| = 480, |height| = 640.
  // TODO(magjed/perkj): Document what this function does. Change name?
  @Override
  public void onOutputFormatRequest(final int width, final int height, final int framerate) {
    postOnCameraThread(new Runnable() {
      @Override
      public void run() {
        Logging.d(TAG,
            "onOutputFormatRequestOnCameraThread: " + width + "x" + height + "@" + framerate);
        capturerObserver.onOutputFormatRequest(width, height, framerate);
      }
    });
  }

  // Reconfigure the camera to capture in a new format. This should only be called while the camera
  // is running.
  @Override
  public void changeCaptureFormat(final int width, final int height, final int framerate) {
    synchronized (cameraStateLock) {
      waitForCameraToStartIfStarting();

      if (cameraState != CameraState.RUNNING) {
        Logging.e(TAG, "Calling changeCaptureFormat() on stopped camera.");
        return;
      }

      requestedWidth = width;
      requestedHeight = height;
      requestedFramerate = framerate;
    }

    // Make the switch.
    stopCapture();
    // TODO(magjed/sakal): Just recreate session.
    startCapture(width, height, framerate);
  }

  @Override
  public List<CaptureFormat> getSupportedFormats() {
    synchronized (cameraState) {
      return Camera2Enumerator.getSupportedFormats(this.cameraManager, cameraName);
    }
  }

  @Override
  public void dispose() {
    synchronized (cameraStateLock) {
      waitForCameraToStopIfStopping();

      if (cameraState != CameraState.IDLE) {
        throw new IllegalStateException("Unexpected camera state for dispose: " + cameraState);
      }
    }
  }

  // Blocks until camera is known to be stopped.
  @Override
  public void stopCapture() {
    final CountDownLatch cameraStoppingLatch = new CountDownLatch(1);

    Logging.d(TAG, "stopCapture");
    checkNotOnCameraThread();

    synchronized (cameraStateLock) {
      waitForCameraToStartIfStarting();

      if (cameraState != CameraState.RUNNING) {
        Logging.w(TAG, "stopCapture called for already stopped camera.");
        return;
      }

      postOnCameraThread(new Runnable() {
        @Override
        public void run() {
          Logging.d(TAG, "stopCaptureOnCameraThread");

          // Stop capture.
          closeAndRelease();
          cameraStoppingLatch.countDown();
        }
      });
    }

    // Wait for the stopping to start
    ThreadUtils.awaitUninterruptibly(cameraStoppingLatch);

    Logging.d(TAG, "stopCapture done");
  }

  private void postOnCameraThread(Runnable runnable) {
    postDelayedOnCameraThread(0 /* delayMs */, runnable);
  }

  private void postDelayedOnCameraThread(int delayMs, Runnable runnable) {
    synchronized (cameraStateLock) {
      if ((cameraState != CameraState.STARTING && cameraState != CameraState.RUNNING)
          || !cameraThreadHandler.postAtTime(
              runnable, this /* token */, SystemClock.uptimeMillis() + delayMs)) {
        Logging.w(TAG, "Runnable not scheduled even though it was requested.");
      }
    }
  }

  private int getDeviceOrientation() {
    int orientation = 0;

    WindowManager wm = (WindowManager) applicationContext.getSystemService(
        Context.WINDOW_SERVICE);
    switch(wm.getDefaultDisplay().getRotation()) {
      case Surface.ROTATION_90:
        orientation = 90;
        break;
      case Surface.ROTATION_180:
        orientation = 180;
        break;
      case Surface.ROTATION_270:
        orientation = 270;
        break;
      case Surface.ROTATION_0:
      default:
        orientation = 0;
        break;
    }
    return orientation;
  }

  @Override
  public void onTextureFrameAvailable(
      int oesTextureId, float[] transformMatrix, long timestampNs) {
    checkIsOnCameraThread();

    if (eventsHandler != null && !firstFrameReported) {
      eventsHandler.onFirstFrameAvailable();
      firstFrameReported = true;
    }

    int rotation;
    if (isFrontCamera) {
      // Undo the mirror that the OS "helps" us with.
      // http://developer.android.com/reference/android/hardware/Camera.html#setDisplayOrientation(int)
      rotation = cameraOrientation + getDeviceOrientation();
      transformMatrix =
          RendererCommon.multiplyMatrices(transformMatrix, RendererCommon.horizontalFlipMatrix());
    } else {
      rotation = cameraOrientation - getDeviceOrientation();
    }
    // Make sure |rotation| is between 0 and 360.
    rotation = (360 + rotation % 360) % 360;

    // Undo camera orientation - we report it as rotation instead.
    transformMatrix = RendererCommon.rotateTextureMatrix(transformMatrix, -cameraOrientation);

    cameraStatistics.addFrame();
    capturerObserver.onTextureFrameCaptured(captureFormat.width, captureFormat.height, oesTextureId,
        transformMatrix, rotation, timestampNs);
  }
}