VideoCapturerAndroid: Check that camera is still running in every *OnCameraThread method

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 213 matching lines @@
       this.id = 0;
     } else {
       this.id = getCameraIndex(cameraName);
     }
     this.eventsHandler = eventsHandler;
     isCapturingToTexture = captureToTexture;
     Logging.d(TAG, "VideoCapturerAndroid isCapturingToTexture : " + isCapturingToTexture);
   }
 
   private void checkIsOnCameraThread() {
-    if (Thread.currentThread() != cameraThreadHandler.getLooper().getThread()) {
-      throw new IllegalStateException("Wrong thread");
+    synchronized (handlerLock) {
+      if (cameraThreadHandler == null) {
+        Logging.e(TAG, "Camera is stopped - can't check thread.");
+      } else if (Thread.currentThread() != cameraThreadHandler.getLooper().getThread()) {
+        throw new IllegalStateException("Wrong thread");
+      }
     }
   }
 
   // Returns the camera index for camera with name |deviceName|, or throws IllegalArgumentException
   // if no such camera can be found.
   private static int getCameraIndex(String deviceName) {
     Logging.d(TAG, "getCameraIndex: " + deviceName);
     for (int i = 0; i < android.hardware.Camera.getNumberOfCameras(); ++i) {
       if (deviceName.equals(CameraEnumerationAndroid.getDeviceName(i))) {
         return i;
@@ skipping 59 matching lines @@
         if (eventsHandler != null) {
           eventsHandler.onCameraError("Could not post task to camera thread.");
         }
       }
     }
   }
 
   private void startCaptureOnCameraThread(
       final int width, final int height, final int framerate, final CapturerObserver frameObserver,
       final Context applicationContext) {
-    Throwable error = null;
-    checkIsOnCameraThread();
+    synchronized (handlerLock) {
+      if (cameraThreadHandler == null) {
+        Logging.e(TAG, "startCaptureOnCameraThread: Camera is stopped");
+        return;
+      } else {
+        checkIsOnCameraThread();
+      }
+    }
     if (camera != null) {
       Logging.e(TAG, "startCaptureOnCameraThread: Camera has already been started.");
       return;
     }
     this.applicationContext = applicationContext;
     this.frameObserver = frameObserver;
     this.firstFrameReported = false;
 
     try {
       try {
@@ skipping 14 matching lines @@
             @Override public void run() {
               startCaptureOnCameraThread(width, height, framerate, frameObserver,
                   applicationContext);
             }
           });
           return;
         }
         throw e;
       }
 
-      try {
-        camera.setPreviewTexture(surfaceHelper.getSurfaceTexture());
-      } catch (IOException e) {
-        Logging.e(TAG, "setPreviewTexture failed", error);
-        throw new RuntimeException(e);
-      }
+      camera.setPreviewTexture(surfaceHelper.getSurfaceTexture());
 
       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);
-      return;
-    } catch (RuntimeException e) {
-      error = e;
-    }
-    Logging.e(TAG, "startCapture failed", error);
-    // Make sure the camera is released.
-    stopCaptureOnCameraThread(true /* stopHandler */);
-    frameObserver.onCapturerStarted(false);
-    if (eventsHandler != null) {
-      eventsHandler.onCameraError("Camera can not be started.");
-    }
-    return;
+    } catch (IOException|RuntimeException e) {
+      Logging.e(TAG, "startCapture failed", e);
+      // Make sure the camera is released.
+      stopCaptureOnCameraThread(true /* stopHandler */);
+      frameObserver.onCapturerStarted(false);
+      if (eventsHandler != null) {
+        eventsHandler.onCameraError("Camera can not be started.");
+      }
+     }
   }
 
   // (Re)start preview with the closest supported format to |width| x |height| @ |framerate|.
   private void startPreviewOnCameraThread(int width, int height, int framerate) {
-    checkIsOnCameraThread();
+    synchronized (handlerLock) {
+      if (cameraThreadHandler == null || camera == null) {
+        Logging.e(TAG, "startPreviewOnCameraThread: Camera is stopped");
+        return;
+      } else {
+        checkIsOnCameraThread();
+      }
+    }
     Logging.d(
         TAG, "startPreviewOnCameraThread requested: " + width + "x" + height + "@" + framerate);
-    if (camera == null) {
-      Logging.e(TAG, "Calling startPreviewOnCameraThread on stopped camera.");
-      return;
-    }
 
     requestedWidth = width;
     requestedHeight = height;
     requestedFramerate = framerate;
 
     // Find closest supported format for |width| x |height| @ |framerate|.
     final android.hardware.Camera.Parameters parameters = camera.getParameters();
     final List<CaptureFormat.FramerateRange> supportedFramerates =
         CameraEnumerator.convertFramerates(parameters.getSupportedPreviewFpsRange());
     Logging.d(TAG, "Available fps ranges: " + supportedFramerates);
@@ skipping 93 matching lines @@
       Logging.e(TAG, "Camera stop timeout");
       printStackTrace();
       if (eventsHandler != null) {
         eventsHandler.onCameraError("Camera stop timeout");
       }
     }
     Logging.d(TAG, "stopCapture done");
   }
 
   private void stopCaptureOnCameraThread(boolean stopHandler) {
-    checkIsOnCameraThread();
+    synchronized (handlerLock) {
+      if (cameraThreadHandler == null) {
+        Logging.e(TAG, "stopCaptureOnCameraThread: Camera is stopped");
+      } else {
+        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 (stopHandler) {
       synchronized (handlerLock) {
         // Clear the cameraThreadHandler first, in case stopPreview or
         // other driver code deadlocks. Deadlock in
         // android.hardware.Camera._stopPreview(Native Method) has
         // been observed on Nexus 5 (hammerhead), OS version LMY48I.
         // The camera might post another one or two preview frames
         // before stopped, so we have to check for a null
         // cameraThreadHandler in our handler. Remove all pending
         // Runnables posted from |this|.
-        cameraThreadHandler.removeCallbacksAndMessages(this /* token */);
-        cameraThreadHandler = null;
+        if (cameraThreadHandler != null) {
+          cameraThreadHandler.removeCallbacksAndMessages(this /* token */);
+          cameraThreadHandler = null;
+        }
         surfaceHelper = null;
       }
     }
     if (cameraStatistics != null) {
       cameraStatistics.release();
       cameraStatistics = null;
     }
     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) {
       camera.release();
       camera = null;
     }
     if (eventsHandler != null) {
       eventsHandler.onCameraClosed();
     }
     Logging.d(TAG, "stopCaptureOnCameraThread done");
   }
 
   private void switchCameraOnCameraThread() {
-    checkIsOnCameraThread();
+    synchronized (handlerLock) {
+      if (cameraThreadHandler == null) {
+        Logging.e(TAG, "switchCameraOnCameraThread: Camera is stopped");
+        return;
+      } else {
+        checkIsOnCameraThread();
+      }
+    }
     Logging.d(TAG, "switchCameraOnCameraThread");
     stopCaptureOnCameraThread(false /* stopHandler */);
     synchronized (cameraIdLock) {
       id = (id + 1) % android.hardware.Camera.getNumberOfCameras();
     }
     startCaptureOnCameraThread(requestedWidth, requestedHeight, requestedFramerate, frameObserver,
         applicationContext);
     Logging.d(TAG, "switchCameraOnCameraThread done");
   }
 
   private void onOutputFormatRequestOnCameraThread(int width, int height, int framerate) {
-    checkIsOnCameraThread();
-    if (camera == null) {
-      Logging.e(TAG, "Calling onOutputFormatRequest() on stopped camera.");
-      return;
+    synchronized (handlerLock) {
+      if (cameraThreadHandler == null || camera == null) {
+        Logging.e(TAG, "onOutputFormatRequestOnCameraThread: Camera is stopped");
+        return;
+      } else {
+        checkIsOnCameraThread();
+      }
     }
     Logging.d(TAG, "onOutputFormatRequestOnCameraThread: " + width + "x" + height +
         "@" + framerate);
     frameObserver.onOutputFormatRequest(width, height, framerate);
   }
 
   // Exposed for testing purposes only.
   Handler getCameraThreadHandler() {
     return cameraThreadHandler;
   }
@@ skipping 25 matching lines @@
     int rotation = getDeviceOrientation();
     if (info.facing == android.hardware.Camera.CameraInfo.CAMERA_FACING_BACK) {
       rotation = 360 - rotation;
     }
     return (info.orientation + rotation) % 360;
   }
 
   // Called on cameraThread so must not "synchronized".
   @Override
   public void onPreviewFrame(byte[] data, android.hardware.Camera callbackCamera) {
-    if (cameraThreadHandler == null) {
-      // The camera has been stopped.
-      return;
+    synchronized (handlerLock) {
+      if (cameraThreadHandler == null) {
+        Logging.e(TAG, "onPreviewFrame: Camera is stopped");
+        return;
+      } else {
+        checkIsOnCameraThread();
+      }
     }
-    checkIsOnCameraThread();
     if (!queuedBuffers.contains(data)) {
       // |data| is an old invalid buffer.
       return;
     }
     if (camera != callbackCamera) {
       throw new RuntimeException("Unexpected camera in callback!");
     }
 
     final long captureTimeNs =
         TimeUnit.MILLISECONDS.toNanos(SystemClock.elapsedRealtime());
 
     if (eventsHandler != null && !firstFrameReported) {
       eventsHandler.onFirstFrameAvailable();
       firstFrameReported = true;
     }
 
     cameraStatistics.addFrame();
     frameObserver.onByteBufferFrameCaptured(data, captureFormat.width, captureFormat.height,
         getFrameOrientation(), captureTimeNs);
     camera.addCallbackBuffer(data);
   }
 
   @Override
   public void onTextureFrameAvailable(
       int oesTextureId, float[] transformMatrix, long timestampNs) {
-
-    checkIsOnCameraThread();
+    synchronized (handlerLock) {
+      if (cameraThreadHandler == null) {
+        Logging.e(TAG, "onTextureFrameAvailable: Camera is stopped");
+        surfaceHelper.returnTextureFrame();
+        return;
+      } else {
+        checkIsOnCameraThread();
+      }
+    }
     if (eventsHandler != null && !firstFrameReported) {
       eventsHandler.onFirstFrameAvailable();
       firstFrameReported = true;
     }
 
     int rotation = getFrameOrientation();
     if (info.facing == android.hardware.Camera.CameraInfo.CAMERA_FACING_FRONT) {
       // 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);
   }
 }