Events refactor in Android session based capturing.

webrtc/api/android/java/src/org/webrtc/Camera2Session.java

 /*
  *  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.
  */
 
@@ skipping 28 matching lines @@
   private static final String TAG = "Camera2Session";
 
   private static final Histogram camera2StartTimeMsHistogram =
       Histogram.createCounts("WebRTC.Android.Camera2.StartTimeMs", 1, 10000, 50);
   private static final Histogram camera2StopTimeMsHistogram =
       Histogram.createCounts("WebRTC.Android.Camera2.StopTimeMs", 1, 10000, 50);
 
   private static enum SessionState { RUNNING, STOPPED };
 
   private final Handler cameraThreadHandler;
+  private final CreateSessionCallback callback;
+  private final Events events;
+  private final Context applicationContext;
   private final CameraManager cameraManager;
-  private final CreateSessionCallback callback;
-  private final CameraVideoCapturer.CameraEventsHandler eventsHandler;
-  private final Context applicationContext;
-  private final CameraVideoCapturer.CapturerObserver capturerObserver;
   private final SurfaceTextureHelper surfaceTextureHelper;
   private final String cameraId;
   private final int width;
   private final int height;
   private final int framerate;
 
   // Initialized at start
   private CameraCharacteristics cameraCharacteristics;
   private int cameraOrientation;
   private boolean isCameraFrontFacing;
   private int fpsUnitFactor;
   private CaptureFormat captureFormat;
 
   // Initialized when camera opens
   private CameraDevice cameraDevice;
   private Surface surface;
 
   // Initialized when capture session is created
   private CameraCaptureSession captureSession;
-  private CameraVideoCapturer.CameraStatistics cameraStatistics;
 
   // State
   private SessionState state = SessionState.RUNNING;
   private boolean firstFrameReported = false;
 
   // Used only for stats. Only used on the camera thread.
   private final long constructionTimeNs; // Construction time of this class.
 
   private class CameraStateCallback extends CameraDevice.StateCallback {
     private String getErrorDescription(int errorCode) {
@@ skipping 43 matching lines @@
         reportError("Failed to create capture session. " + e);
         return;
       }
     }
 
     @Override
     public void onClosed(CameraDevice camera) {
       checkIsOnCameraThread();
 
       Logging.d(TAG, "Camera device closed.");
-      eventsHandler.onCameraClosed();
+      events.onCameraClosed(Camera2Session.this);
     }
   }
 
   private class CaptureSessionCallback extends CameraCaptureSession.StateCallback {
     @Override
     public void onConfigureFailed(CameraCaptureSession session) {
       checkIsOnCameraThread();
       session.close();
       reportError("Failed to configure capture session.");
     }
@@ skipping 36 matching lines @@
                 int oesTextureId, float[] transformMatrix, long timestampNs) {
               checkIsOnCameraThread();
 
               if (state != SessionState.RUNNING) {
                 Logging.d(TAG, "Texture frame captured but camera is no longer running.");
                 surfaceTextureHelper.returnTextureFrame();
                 return;
               }
 
               if (!firstFrameReported) {
-                eventsHandler.onFirstFrameAvailable();
                 firstFrameReported = true;
                 final int startTimeMs =
                     (int) TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - constructionTimeNs);
                 camera2StartTimeMsHistogram.addSample(startTimeMs);
               }
 
               int rotation = getFrameOrientation();
               if (isCameraFrontFacing) {
                 // 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());
               }
 
               // 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);
+              events.onTextureFrameCaptured(Camera2Session.this, captureFormat.width,
+                  captureFormat.height, oesTextureId, transformMatrix, rotation, timestampNs);
             }
           });
-      capturerObserver.onCapturerStarted(true /* success */);
-      cameraStatistics = new CameraVideoCapturer.CameraStatistics(
-          surfaceTextureHelper, eventsHandler);
       Logging.d(TAG, "Camera device successfully started.");
       callback.onDone(Camera2Session.this);
     }
   }
 
   private class CameraCaptureCallback extends CameraCaptureSession.CaptureCallback {
     @Override
     public void onCaptureFailed(
         CameraCaptureSession session, CaptureRequest request, CaptureFailure failure) {
       Logging.d(TAG, "Capture failed: " + failure);
     }
   }
 
   public static void create(
-      CameraManager cameraManager, CreateSessionCallback callback,
-      CameraVideoCapturer.CameraEventsHandler eventsHandler, Context applicationContext,
-      CameraVideoCapturer.CapturerObserver capturerObserver,
+      CreateSessionCallback callback, Events events,
+      Context applicationContext, CameraManager cameraManager,
       SurfaceTextureHelper surfaceTextureHelper,
       String cameraId, int width, int height, int framerate) {
     new Camera2Session(
-        cameraManager, callback,
-        eventsHandler, applicationContext,
-        capturerObserver,
+        callback, events,
+        applicationContext, cameraManager,
         surfaceTextureHelper,
         cameraId, width, height, framerate);
   }
 
   private Camera2Session(
-      CameraManager cameraManager, CreateSessionCallback callback,
-      CameraVideoCapturer.CameraEventsHandler eventsHandler, Context applicationContext,
-      CameraVideoCapturer.CapturerObserver capturerObserver,
+      CreateSessionCallback callback, Events events,
+      Context applicationContext, CameraManager cameraManager,
       SurfaceTextureHelper surfaceTextureHelper,
       String cameraId, int width, int height, int framerate) {
     Logging.d(TAG, "Create new camera2 session on camera " + cameraId);
 
     constructionTimeNs = System.nanoTime();
 
     this.cameraThreadHandler = new Handler();
+    this.callback = callback;
+    this.events = events;
+    this.applicationContext = applicationContext;
     this.cameraManager = cameraManager;
-    this.callback = callback;
-    this.eventsHandler = eventsHandler;
-    this.applicationContext = applicationContext;
-    this.capturerObserver = capturerObserver;
     this.surfaceTextureHelper = surfaceTextureHelper;
     this.cameraId = cameraId;
     this.width = width;
     this.height = height;
     this.framerate = framerate;
 
     start();
   }
 
   private void start() {
@@ skipping 35 matching lines @@
         sizes, width, height);
 
     captureFormat = new CaptureFormat(bestSize.width, bestSize.height, bestFpsRange);
     Logging.d(TAG, "Using capture format: " + captureFormat);
   }
 
   private void openCamera() {
     checkIsOnCameraThread();
 
     Logging.d(TAG, "Opening camera " + cameraId);
-    eventsHandler.onCameraOpening(cameraId);
+    events.onCameraOpening(this);
 
     try {
       cameraManager.openCamera(cameraId, new CameraStateCallback(), cameraThreadHandler);
     } catch (CameraAccessException e) {
       reportError("Failed to open camera: " + e);
     }
   }
 
   @Override
   public void stop() {
     final long stopStartTime = System.nanoTime();
     Logging.d(TAG, "Stop camera2 session on camera " + cameraId);
     if (Thread.currentThread() == cameraThreadHandler.getLooper().getThread()) {
       if (state != SessionState.STOPPED) {
         state = SessionState.STOPPED;
-        capturerObserver.onCapturerStopped();
         // Post the stopInternal to return earlier.
         cameraThreadHandler.post(new Runnable() {
           @Override
           public void run() {
             stopInternal();
             final int stopTimeMs =
                 (int) TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - stopStartTime);
             camera2StopTimeMsHistogram.addSample(stopTimeMs);
           }
         });
       }
     } else {
       final CountDownLatch stopLatch = new CountDownLatch(1);
 
       cameraThreadHandler.post(new Runnable() {
         @Override
         public void run() {
           if (state != SessionState.STOPPED) {
             state = SessionState.STOPPED;
-            capturerObserver.onCapturerStopped();
             stopLatch.countDown();
             stopInternal();
             final int stopTimeMs =
                 (int) TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - stopStartTime);
             camera2StopTimeMsHistogram.addSample(stopTimeMs);
           }
         }
       });
 
       ThreadUtils.awaitUninterruptibly(stopLatch);
     }
   }
 
   private void stopInternal() {
     Logging.d(TAG, "Stop internal");
     checkIsOnCameraThread();
 
     surfaceTextureHelper.stopListening();
-    cameraStatistics.release();
 
     captureSession.close();
     captureSession = null;
     surface.release();
     surface = null;
     cameraDevice.close();
     cameraDevice = null;
 
     Logging.d(TAG, "Stop done");
   }
 
   private void reportError(String error) {
     checkIsOnCameraThread();
     Logging.e(TAG, "Error: " + error);
 
     if (captureSession == null) {
       if (cameraDevice != null) {
         cameraDevice.close();
         cameraDevice = null;
       }
 
       state = SessionState.STOPPED;
       callback.onFailure(error);
-      capturerObserver.onCapturerStarted(false /* success */);
     } else {
-      eventsHandler.onCameraError(error);
+      stop();

[magjed_webrtc, 2016/09/16 12:59:19]

I would like to flatten the number of function indirections and different code
paths. If we add null checks in stopInternal(), would it be possible to write
this function like:

final boolean startFailure = (cameraDevice == null);
state = SessionState.STOPPED;
stopInternal();
if (startFailure) {
  callback.onFailure(error);
} else {
  events.onCameraError(this, error);
}
?

[sakal, 2016/09/16 13:25:16]

Done.

+      events.onCameraError(this, error);
     }
   }
 
   private int getDeviceOrientation() {
     int orientation = 0;
 
     WindowManager wm = (WindowManager) applicationContext.getSystemService(
         Context.WINDOW_SERVICE);
     switch(wm.getDefaultDisplay().getRotation()) {
       case Surface.ROTATION_90:
@@ skipping 20 matching lines @@
     }
     return (cameraOrientation + rotation) % 360;
   }
 
   private void checkIsOnCameraThread() {
     if (Thread.currentThread() != cameraThreadHandler.getLooper().getThread()) {
       throw new IllegalStateException("Wrong thread");
     }
   }
 }