Events refactor in Android session based capturing.

webrtc/api/android/java/src/org/webrtc/CameraCapturer.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 19 matching lines @@
   private final static int OPEN_CAMERA_TIMEOUT = 10000;
 
   private final CameraEnumerator cameraEnumerator;
   private final CameraEventsHandler eventsHandler;
   private final Handler uiThreadHandler;
 
   private final CameraSession.CreateSessionCallback createSessionCallback =
       new CameraSession.CreateSessionCallback() {
         @Override
         public void onDone(CameraSession session) {
+          checkIsOnCameraThread();
           Logging.d(TAG, "Create session done");
           uiThreadHandler.removeCallbacks(openCameraTimeoutRunnable);
+          capturerObserver.onCapturerStarted(true /* success */);
           synchronized (stateLock) {
             sessionOpening = false;
             currentSession = session;
             stateLock.notifyAll();
 
             if (switchState == SwitchState.IN_PROGRESS) {
               if (switchEventsHandler != null) {
                 switchEventsHandler.onCameraSwitchDone(
                     cameraEnumerator.isFrontFacing(cameraName));
                 switchEventsHandler = null;
               }
               switchState = SwitchState.IDLE;
             } else if (switchState == SwitchState.PENDING) {
               switchState = SwitchState.IDLE;
               switchCameraInternal(switchEventsHandler);
             }
+
+            cameraStatistics = new CameraStatistics(surfaceHelper, eventsHandler);
+            firstFrameObserved = false;
           }
         }
 
         @Override
         public void onFailure(String error) {
+          checkIsOnCameraThread();
           uiThreadHandler.removeCallbacks(openCameraTimeoutRunnable);
+          capturerObserver.onCapturerStarted(false /* success */);
           synchronized (stateLock) {
             openAttemptsRemaining--;
 
             if (openAttemptsRemaining <= 0) {
               Logging.w(TAG, "Opening camera failed, passing: " + error);
               sessionOpening = false;
               stateLock.notifyAll();
 
               if (switchState != SwitchState.IDLE) {
                 if (switchEventsHandler != null) {
                   switchEventsHandler.onCameraSwitchError(error);
                   switchEventsHandler = null;
                 }
                 switchState = SwitchState.IDLE;
               }
 
               eventsHandler.onCameraError(error);
             } else {
               Logging.w(TAG, "Opening camera failed, retry: " + error);
 
               createSessionInternal(OPEN_CAMERA_DELAY_MS);
             }
           }
         }
       };
 
+  private final CameraSession.Events cameraSessionEventsHandler = new CameraSession.Events() {
+    @Override
+    public void onCameraOpening() {
+      checkIsOnCameraThread();
+      synchronized (stateLock) {
+        if (currentSession != null) {
+          Logging.w(TAG, "onCameraOpening while session was open.");
+          return;
+        }
+        eventsHandler.onCameraOpening(cameraName);
+      }
+    }
+
+    @Override
+    public void onCameraError(CameraSession session, String error) {
+      checkIsOnCameraThread();
+      synchronized (stateLock) {
+        if (session != currentSession) {
+          Logging.w(TAG, "onCameraError from another session: " + error);
+          return;
+        }
+        eventsHandler.onCameraError(error);
+        stopCapture();
+      }
+    }
+
+    @Override
+    public void onCameraClosed(CameraSession session) {
+      checkIsOnCameraThread();
+      synchronized (stateLock) {
+        if (session != currentSession && currentSession != null) {
+          Logging.d(TAG, "onCameraClosed from another session.");
+          return;
+        }
+        eventsHandler.onCameraClosed();
+      }
+    }
+
+    @Override
+    public void onByteBufferFrameCaptured(
+        CameraSession session, byte[] data, int width, int height, int rotation,
+        long timestamp) {
+      checkIsOnCameraThread();
+      synchronized (stateLock) {
+        if (session != currentSession) {
+          Logging.w(TAG, "onByteBufferFrameCaptured from another session.");
+          return;
+        }
+        if (!firstFrameObserved) {
+          eventsHandler.onFirstFrameAvailable();
+          firstFrameObserved = true;
+        }
+        cameraStatistics.addFrame();
+        capturerObserver.onByteBufferFrameCaptured(data, width, height, rotation, timestamp);
+      }
+    }
+
+    @Override
+    public void onTextureFrameCaptured(
+        CameraSession session, int width, int height, int oesTextureId, float[] transformMatrix,
+        int rotation, long timestamp) {
+      checkIsOnCameraThread();
+      synchronized (stateLock) {
+        if (session != currentSession) {
+          Logging.w(TAG, "onTextureFrameCaptured from another session.");
+          return;
+        }
+        if (!firstFrameObserved) {
+          eventsHandler.onFirstFrameAvailable();
+          firstFrameObserved = true;
+        }
+        cameraStatistics.addFrame();
+        capturerObserver.onTextureFrameCaptured(
+            width, height, oesTextureId, transformMatrix, rotation, timestamp);
+      }
+    }
+  };
+
   private final Runnable openCameraTimeoutRunnable = new Runnable() {
     @Override
     public void run() {
       eventsHandler.onCameraError("Camera failed to start within timeout.");
     }
   };
 
   // Initialized on initialize
   // -------------------------
   private Handler cameraThreadHandler;
   private Context applicationContext;
   private CapturerObserver capturerObserver;
   private SurfaceTextureHelper surfaceHelper;
 
   private final Object stateLock = new Object();
   private boolean sessionOpening;                  /* guarded by stateLock */
   private CameraSession currentSession;            /* guarded by stateLock */
   private String cameraName;                       /* guarded by stateLock */
   private int width;                               /* guarded by stateLock */
   private int height;                              /* guarded by stateLock */
   private int framerate;                           /* guarded by stateLock */
   private int openAttemptsRemaining;               /* guarded by stateLock */
   private SwitchState switchState = SwitchState.IDLE; /* guarded by stateLock */
   private CameraSwitchHandler switchEventsHandler; /* guarded by stateLock */
+  // Valid from onDone call until stopCapture, otherwise null.
+  private CameraStatistics cameraStatistics;       /* guarded by stateLock */
+  private boolean firstFrameObserved;              /* guarded by stateLock */
 
   public CameraCapturer(
       String cameraName, CameraEventsHandler eventsHandler, CameraEnumerator cameraEnumerator) {
     if (eventsHandler == null) {
       eventsHandler = new CameraEventsHandler() {
         @Override
         public void onCameraError(String errorDescription) {}
         @Override
         public void onCameraFreezed(String errorDescription) {}
         @Override
@@ skipping 50 matching lines @@
       createSessionInternal(0);
     }
   }
 
   private void createSessionInternal(int delayMs) {
     uiThreadHandler.postDelayed(openCameraTimeoutRunnable, delayMs + OPEN_CAMERA_TIMEOUT);
     cameraThreadHandler.postDelayed(new Runnable() {
       @Override
       public void run() {
         createCameraSession(
-            createSessionCallback,
-            eventsHandler, applicationContext, capturerObserver, surfaceHelper,
+            createSessionCallback, cameraSessionEventsHandler, applicationContext, surfaceHelper,
             cameraName, width, height, framerate);
       }
     }, delayMs);
   }
 
   @Override
   public void stopCapture() {
     Logging.d(TAG, "Stop capture");
 
     synchronized (stateLock) {
       while (sessionOpening) {
         Logging.d(TAG, "Stop capture: Waiting for session to open");
         ThreadUtils.waitUninterruptibly(stateLock);
       }
 
       if (currentSession != null) {
         Logging.d(TAG, "Stop capture: Stopping session");
+        cameraStatistics.release();
+        cameraStatistics = null;
         currentSession.stop();
         currentSession = null;
+        capturerObserver.onCapturerStopped();
       } else {
         Logging.d(TAG, "Stop capture: No session open");
       }
     }
 
     Logging.d(TAG, "Stop capture done");
   }
 
   @Override
   public void onOutputFormatRequest(final int width, final int height, final int framerate) {
@@ skipping 97 matching lines @@
       int cameraNameIndex = Arrays.asList(deviceNames).indexOf(cameraName);
       cameraName = deviceNames[(cameraNameIndex + 1) % deviceNames.length];
 
       sessionOpening = true;
       openAttemptsRemaining = 1;
       createSessionInternal(0);
     }
     Logging.d(TAG, "switchCamera done");
   }
 
+  private void checkIsOnCameraThread() {
+    if (Thread.currentThread() != cameraThreadHandler.getLooper().getThread()) {
+      Logging.e(TAG, "Check is on camera thread failed.");
+      throw new RuntimeException("Not on camera thread.");
+    }
+  }
+
   protected String getCameraName() {
     synchronized (stateLock) {
       return cameraName;
     }
   }
 
   abstract protected void createCameraSession(
-      CameraSession.CreateSessionCallback createSessionCallback,
-      CameraEventsHandler eventsHandler, Context applicationContext,
-      CameraVideoCapturer.CapturerObserver capturerObserver,
-      SurfaceTextureHelper surfaceTextureHelper,
+      CameraSession.CreateSessionCallback createSessionCallback, CameraSession.Events events,
+      Context applicationContext, SurfaceTextureHelper surfaceTextureHelper,
       String cameraName, int width, int height, int framerate);
 }