Reorder actions on stopCapturer, to avoid crashing on camera timeout.

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 354 matching lines @@
       }
 
       // 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();
-    synchronized (handlerLock) {
-      // Remove all pending Runnables posted from |this|.
-      cameraThreadHandler.removeCallbacksAndMessages(this /* token */);
-      cameraThreadHandler = null;
-    }
+    stopCaptureOnCameraThread(true /* stopHandler */);
     frameObserver.onCapturerStarted(false);
     if (eventsHandler != null) {
       eventsHandler.onCameraError("Camera can not be started.");
     }
     return;
   }
 
   // (Re)start preview with the closest supported format to |width| x |height| @ |framerate|.
   private void startPreviewOnCameraThread(int width, int height, int framerate) {
     checkIsOnCameraThread();
@@ skipping 85 matching lines @@
     camera.startPreview();
   }
 
   // Blocks until camera is known to be stopped.
   @Override
   public void stopCapture() throws InterruptedException {
     Logging.d(TAG, "stopCapture");
     final CountDownLatch barrier = new CountDownLatch(1);
     final boolean didPost = maybePostOnCameraThread(new Runnable() {
       @Override public void run() {
-        stopCaptureOnCameraThread();
-        synchronized (handlerLock) {
-          // Remove all pending Runnables posted from |this|.
-          cameraThreadHandler.removeCallbacksAndMessages(this /* token */);
-          cameraThreadHandler = null;
-          surfaceHelper = null;
-        }
+        stopCaptureOnCameraThread(true /* stopHandler */);
         barrier.countDown();
       }
     });
     if (!didPost) {
       Logging.e(TAG, "Calling stopCapture() for already stopped camera.");
       return;
     }
     if (!barrier.await(CAMERA_STOP_TIMEOUT_MS, TimeUnit.MILLISECONDS)) {
       Logging.e(TAG, "Camera stop timeout");
       printStackTrace();
       if (eventsHandler != null) {
         eventsHandler.onCameraError("Camera stop timeout");
       }
     }
     Logging.d(TAG, "stopCapture done");
   }
 
-  private void stopCaptureOnCameraThread() {
+  private void stopCaptureOnCameraThread(boolean stopHandler) {
     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;
+        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();
     Logging.d(TAG, "switchCameraOnCameraThread");
-    stopCaptureOnCameraThread();
+    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();
@@ skipping 68 matching lines @@
 
     cameraStatistics.addFrame();
     frameObserver.onByteBufferFrameCaptured(data, captureFormat.width, captureFormat.height,
         getFrameOrientation(), captureTimeNs);
     camera.addCallbackBuffer(data);
   }
 
   @Override
   public void onTextureFrameAvailable(
       int oesTextureId, float[] transformMatrix, long timestampNs) {
-    if (cameraThreadHandler == null) {
-      throw new RuntimeException("onTextureFrameAvailable() called after stopCapture().");
-    }
+
     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);
   }
 }