Revert of Android: Make base interface for camera1 and camera2

webrtc/api/java/android/org/webrtc/VideoCapturerAndroid.java

 /*
  *  Copyright 2015 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.
  */
 
@@ skipping 20 matching lines @@
 // An instance of this class can be created by an application using
 // VideoCapturerAndroid.create();
 // This class extends VideoCapturer with a method to easily switch between the
 // front and back camera. It also provides methods for enumerating valid device
 // names.
 //
 // Threading notes: this class is called from C++ code, Android Camera callbacks, and possibly
 // arbitrary Java threads. All public entry points are thread safe, and delegate the work to the
 // camera thread. The internal *OnCameraThread() methods must check |camera| for null to check if
 // the camera has been stopped.
-// TODO(magjed): This class name is now confusing - rename to Camera1VideoCapturer.
 @SuppressWarnings("deprecation")
 public class VideoCapturerAndroid implements
-    CameraVideoCapturer,
+    VideoCapturer,
     android.hardware.Camera.PreviewCallback,
     SurfaceTextureHelper.OnTextureFrameAvailableListener {
   private final static String TAG = "VideoCapturerAndroid";
+  private final static int CAMERA_OBSERVER_PERIOD_MS = 2000;
+  private final static int CAMERA_FREEZE_REPORT_TIMOUT_MS = 4000;
   private static final int CAMERA_STOP_TIMEOUT_MS = 7000;
 
   private boolean isDisposed = false;
   private android.hardware.Camera camera;  // Only non-null while capturing.
   private final Object handlerLock = new Object();
   // |cameraThreadHandler| must be synchronized on |handlerLock| when not on the camera thread,
   // or when modifying the reference. Use maybePostOnCameraThread() instead of posting directly to
   // the handler - this way all callbacks with a specifed token can be removed at once.
   private Handler cameraThreadHandler;
   private Context applicationContext;
   // Synchronization lock for |id|.
   private final Object cameraIdLock = new Object();
   private int id;
   private android.hardware.Camera.CameraInfo info;
-  private CameraStatistics cameraStatistics;
+  private final CameraStatistics cameraStatistics;
   // Remember the requested format in case we want to switch cameras.
   private int requestedWidth;
   private int requestedHeight;
   private int requestedFramerate;
   // The capture format will be the closest supported format to the requested format.
   private CaptureFormat captureFormat;
   private final Object pendingCameraSwitchLock = new Object();
   private volatile boolean pendingCameraSwitch;
   private CapturerObserver frameObserver = null;
   private final CameraEventsHandler eventsHandler;
@@ skipping 23 matching lines @@
       } else {
         errorMessage = "Camera error: " + error;
       }
       Logging.e(TAG, errorMessage);
       if (eventsHandler != null) {
         eventsHandler.onCameraError(errorMessage);
       }
     }
   };
 
+  // Camera observer - monitors camera framerate. Observer is executed on camera thread.
+  private final Runnable cameraObserver = new Runnable() {
+    private int freezePeriodCount;
+    @Override
+    public void run() {
+      int cameraFramesCount = cameraStatistics.getAndResetFrameCount();
+      int cameraFps = (cameraFramesCount * 1000 + CAMERA_OBSERVER_PERIOD_MS / 2)
+          / CAMERA_OBSERVER_PERIOD_MS;
+
+      Logging.d(TAG, "Camera fps: " + cameraFps +".");
+      if (cameraFramesCount == 0) {
+        ++freezePeriodCount;
+        if (CAMERA_OBSERVER_PERIOD_MS * freezePeriodCount >= CAMERA_FREEZE_REPORT_TIMOUT_MS
+            && eventsHandler != null) {
+          Logging.e(TAG, "Camera freezed.");
+          if (surfaceHelper.isTextureInUse()) {
+            // This can only happen if we are capturing to textures.
+            eventsHandler.onCameraFreezed("Camera failure. Client must return video buffers.");
+          } else {
+            eventsHandler.onCameraFreezed("Camera failure.");
+          }
+          return;
+        }
+      } else {
+        freezePeriodCount = 0;
+      }
+      maybePostDelayedOnCameraThread(CAMERA_OBSERVER_PERIOD_MS, this);
+    }
+  };
+
+  private static class CameraStatistics {
+    private int frameCount = 0;
+    private final ThreadUtils.ThreadChecker threadChecker = new ThreadUtils.ThreadChecker();
+
+    CameraStatistics() {
+      threadChecker.detachThread();
+    }
+
+    public void addFrame() {
+      threadChecker.checkIsOnValidThread();
+      ++frameCount;
+    }
+
+    public int getAndResetFrameCount() {
+      threadChecker.checkIsOnValidThread();
+      int count = frameCount;
+      frameCount = 0;
+      return count;
+    }
+  }
+
+  public static interface CameraEventsHandler {
+    // Camera error handler - invoked when camera can not be opened
+    // or any camera exception happens on camera thread.
+    void onCameraError(String errorDescription);
+
+    // Invoked when camera stops receiving frames
+    void onCameraFreezed(String errorDescription);
+
+    // Callback invoked when camera is opening.
+    void onCameraOpening(int cameraId);
+
+    // Callback invoked when first camera frame is available after camera is opened.
+    void onFirstFrameAvailable();
+
+    // Callback invoked when camera closed.
+    void onCameraClosed();
+  }
+
+  // Camera switch handler - one of these functions are invoked with the result of switchCamera().
+  // The callback may be called on an arbitrary thread.
+  public interface CameraSwitchHandler {
+    // Invoked on success. |isFrontCamera| is true if the new camera is front facing.
+    void onCameraSwitchDone(boolean isFrontCamera);
+    // Invoked on failure, e.g. camera is stopped or only one camera available.
+    void onCameraSwitchError(String errorDescription);
+  }
+
   public static VideoCapturerAndroid create(String name,
       CameraEventsHandler eventsHandler) {
     return VideoCapturerAndroid.create(name, eventsHandler, false /* captureToTexture */);
   }
 
   public static VideoCapturerAndroid create(String name,
       CameraEventsHandler eventsHandler, boolean captureToTexture) {
     final int cameraId = lookupDeviceName(name);
     if (cameraId == -1) {
       return null;
@@ skipping 14 matching lines @@
         Logging.d(TAG, "VideoCapturerAndroid stacks trace:");
         for (StackTraceElement stackTrace : cameraStackTraces) {
           Logging.d(TAG, stackTrace.toString());
         }
       }
     }
   }
 
   // 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) {
     if (android.hardware.Camera.getNumberOfCameras() < 2) {
       if (switchEventsHandler != null) {
         switchEventsHandler.onCameraSwitchError("No camera to switch to.");
       }
       return;
     }
     synchronized (pendingCameraSwitchLock) {
       if (pendingCameraSwitch) {
         // Do not handle multiple camera switch request to avoid blocking
@@ skipping 63 matching lines @@
   // Returns true if this VideoCapturer is setup to capture video frames to a SurfaceTexture.
   public boolean isCapturingToTexture() {
     return isCapturingToTexture;
   }
 
   private VideoCapturerAndroid(int cameraId, CameraEventsHandler eventsHandler,
       boolean captureToTexture) {
     this.id = cameraId;
     this.eventsHandler = eventsHandler;
     isCapturingToTexture = captureToTexture;
+    cameraStatistics = new CameraStatistics();
     Logging.d(TAG, "VideoCapturerAndroid isCapturingToTexture : " + isCapturingToTexture);
   }
 
   private void checkIsOnCameraThread() {
     if (Thread.currentThread() != cameraThreadHandler.getLooper().getThread()) {
       throw new IllegalStateException("Wrong thread");
     }
   }
 
   // Returns the camera index for camera with name |deviceName|, or -1 if no such camera can be
@@ skipping 140 matching lines @@
       Logging.d(TAG, "Camera orientation: " + info.orientation +
           " .Device orientation: " + getDeviceOrientation());
       camera.setErrorCallback(cameraErrorCallback);
       startPreviewOnCameraThread(width, height, framerate);
       frameObserver.onCapturerStarted(true);
       if (isCapturingToTexture) {
         surfaceHelper.startListening(this);
       }
 
       // Start camera observer.
-      cameraStatistics = new CameraStatistics(surfaceHelper, eventsHandler);
+      maybePostDelayedOnCameraThread(CAMERA_OBSERVER_PERIOD_MS, cameraObserver);
       return;
     } catch (RuntimeException e) {
       error = e;
     }
     Logging.e(TAG, "startCapture failed", error);
     // Make sure the camera is released.
     stopCaptureOnCameraThread();
     synchronized (handlerLock) {
       // Remove all pending Runnables posted from |this|.
       cameraThreadHandler.removeCallbacksAndMessages(this /* token */);
@@ skipping 132 matching lines @@
   private void stopCaptureOnCameraThread() {
     checkIsOnCameraThread();
     Logging.d(TAG, "stopCaptureOnCameraThread");
     // Note that the camera might still not be started here if startCaptureOnCameraThread failed
     // and we posted a retry.
 
     // Make sure onTextureFrameAvailable() is not called anymore.
     if (surfaceHelper != null) {
       surfaceHelper.stopListening();
     }
-    if (cameraStatistics != null) {
-      cameraStatistics.release();
-      cameraStatistics = null;
-    }
+    cameraThreadHandler.removeCallbacks(cameraObserver);
+    cameraStatistics.getAndResetFrameCount();
     Logging.d(TAG, "Stop preview.");
     if (camera != null) {
       camera.stopPreview();
       camera.setPreviewCallbackWithBuffer(null);
     }
     queuedBuffers.clear();
     captureFormat = null;
 
     Logging.d(TAG, "Release camera.");
     if (camera != null) {
@@ skipping 118 matching lines @@
       // Undo the mirror that the OS "helps" us with.
       // http://developer.android.com/reference/android/hardware/Camera.html#setDisplayOrientation(int)
       transformMatrix =
           RendererCommon.multiplyMatrices(transformMatrix, RendererCommon.horizontalFlipMatrix());
     }
     cameraStatistics.addFrame();
     frameObserver.onTextureFrameCaptured(captureFormat.width, captureFormat.height, oesTextureId,
         transformMatrix, rotation, timestampNs);
   }
 }