Add a timeout for starting the camera on CameraCapturer.

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.
  */
 
 package org.webrtc;
 
 import android.content.Context;
 import android.os.Handler;
+import android.os.Looper;
 
 import java.util.Arrays;
 
 @SuppressWarnings("deprecation")
 public abstract class CameraCapturer implements CameraVideoCapturer {
   enum SwitchState {
     IDLE,        // No switch requested.
     PENDING,     // Waiting for previous capture session to open.
     IN_PROGRESS, // Waiting for new switched capture session to start.
   }
 
   private static final String TAG = "CameraCapturer";
   private final static int MAX_OPEN_CAMERA_ATTEMPTS = 3;
   private final static int OPEN_CAMERA_DELAY_MS = 500;
+  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) {
           Logging.d(TAG, "Create session done");
-
+          uiThreadHandler.removeCallbacks(openCameraTimeoutRunnable);
           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);
             }
           }
         }
 
         @Override
         public void onFailure(String error) {
+          uiThreadHandler.removeCallbacks(openCameraTimeoutRunnable);
           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 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 */
@@ skipping 18 matching lines @@
         @Override
         public void onFirstFrameAvailable() {}
         @Override
         public void onCameraClosed() {}
       };
     }
 
     this.eventsHandler = eventsHandler;
     this.cameraEnumerator = cameraEnumerator;
     this.cameraName = cameraName;
+    uiThreadHandler = new Handler(Looper.getMainLooper());
 
     final String[] deviceNames = cameraEnumerator.getDeviceNames();
 
     if (deviceNames.length == 0) {
       throw new RuntimeException("No cameras attached.");
     }
     if (!Arrays.asList(deviceNames).contains(this.cameraName)) {
       throw new IllegalArgumentException(
           "Camera name " + this.cameraName + " does not match any known camera device.");
     }
@@ skipping 23 matching lines @@
       this.height = height;
       this.framerate = framerate;
 
       sessionOpening = true;
       openAttemptsRemaining = MAX_OPEN_CAMERA_ATTEMPTS;
       createSessionInternal(0);
     }
   }
 
   private void createSessionInternal(int delayMs) {
+    uiThreadHandler.postDelayed(openCameraTimeoutRunnable, delayMs + OPEN_CAMERA_TIMEOUT);

[magjed_webrtc, 2016/08/18 13:46:36]

Maybe post it inside the runnable below together with the call to
createCameraSession?

[sakal, 2016/08/18 13:48:17]

That would break the purpose of this CL. If the camera thread is blocked, this
would never get posted.

[magjed_webrtc, 2016/08/18 14:19:42]

Ah, right :)

     cameraThreadHandler.postDelayed(new Runnable() {
       @Override
       public void run() {
         createCameraSession(
             createSessionCallback,
             eventsHandler, applicationContext, capturerObserver, surfaceHelper,
             cameraName, width, height, framerate);
       }
     }, delayMs);
   }
@@ skipping 114 matching lines @@
     }
   }
 
   abstract protected void createCameraSession(
       CameraSession.CreateSessionCallback createSessionCallback,
       CameraEventsHandler eventsHandler, Context applicationContext,
       CameraVideoCapturer.CapturerObserver capturerObserver,
       SurfaceTextureHelper surfaceTextureHelper,
       String cameraName, int width, int height, int framerate);
 }