Android VideoCaptureCamera2: Catch all exceptions in getNumberOfCameras()

media/capture/video/android/java/src/org/chromium/media/VideoCaptureCamera2.java

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package org.chromium.media;
 
 import android.annotation.TargetApi;
 import android.content.Context;
 import android.graphics.ImageFormat;
 import android.hardware.camera2.CameraAccessException;
@@ skipping 126 matching lines @@
     private CameraState mCameraState = CameraState.STOPPED;
     private final Object mCameraStateLock = new Object();
 
     // Service function to grab CameraCharacteristics and handle exceptions.
     private static CameraCharacteristics getCameraCharacteristics(Context appContext, int id) {
         final CameraManager manager =
                 (CameraManager) appContext.getSystemService(Context.CAMERA_SERVICE);
         try {
             return manager.getCameraCharacteristics(Integer.toString(id));
         } catch (CameraAccessException ex) {
-            Log.e(TAG, "getNumberOfCameras: getCameraIdList(): " + ex);
+            Log.e(TAG, "getCameraCharacteristics: " + ex);
         }
         return null;
     }
 
     private boolean createCaptureObjects() {
         Log.d(TAG, "createCaptureObjects");
         if (mCameraDevice == null) return false;
 
         // Create an ImageReader and plug a thread looper into it to have
         // readback take place on its own thread.
         final int maxImages = 2;
         mImageReader = ImageReader.newInstance(mCaptureFormat.getWidth(),
                 mCaptureFormat.getHeight(), mCaptureFormat.getPixelFormat(), maxImages);
         HandlerThread thread = new HandlerThread("CameraPreview");
         thread.start();
         final Handler backgroundHandler = new Handler(thread.getLooper());
         final CrImageReaderListener imageReaderListener = new CrImageReaderListener();
         mImageReader.setOnImageAvailableListener(imageReaderListener, backgroundHandler);
 
         // The Preview template specifically means "high frame rate is given
         // priority over the highest-quality post-processing".
         try {
             mPreviewBuilder = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
-        } catch (CameraAccessException ex) {
-            Log.e(TAG, "createCaptureRequest: " + ex);
-            return false;
-        } catch (IllegalArgumentException ex) {
-            Log.e(TAG, "createCaptureRequest: " + ex);
-            return false;
-        } catch (SecurityException ex) {
+        } catch (CameraAccessException | IllegalArgumentException | SecurityException ex) {
             Log.e(TAG, "createCaptureRequest: " + ex);
             return false;
         }
         if (mPreviewBuilder == null) {
             Log.e(TAG, "mPreviewBuilder error");
             return false;
         }
         // Construct an ImageReader Surface and plug it into our CaptureRequest.Builder.
         mPreviewBuilder.addTarget(mImageReader.getSurface());
 
         // A series of configuration options in the PreviewBuilder
         mPreviewBuilder.set(CaptureRequest.CONTROL_MODE, CameraMetadata.CONTROL_MODE_AUTO);
         mPreviewBuilder.set(
                 CaptureRequest.NOISE_REDUCTION_MODE, CameraMetadata.NOISE_REDUCTION_MODE_FAST);
         mPreviewBuilder.set(CaptureRequest.EDGE_MODE, CameraMetadata.EDGE_MODE_FAST);
         mPreviewBuilder.set(CaptureRequest.CONTROL_VIDEO_STABILIZATION_MODE,
                 CameraMetadata.CONTROL_VIDEO_STABILIZATION_MODE_ON);
         // SENSOR_EXPOSURE_TIME ?
 
         List<Surface> surfaceList = new ArrayList<Surface>(1);
         surfaceList.add(mImageReader.getSurface());
         final CrCaptureSessionListener captureSessionListener = new CrCaptureSessionListener();
         try {
             mCameraDevice.createCaptureSession(surfaceList, captureSessionListener, null);
-        } catch (CameraAccessException ex) {
-            Log.e(TAG, "createCaptureSession: " + ex);
-            return false;
-        } catch (IllegalArgumentException ex) {
-            Log.e(TAG, "createCaptureSession: " + ex);
-            return false;
-        } catch (SecurityException ex) {
+        } catch (CameraAccessException | IllegalArgumentException | SecurityException ex) {
             Log.e(TAG, "createCaptureSession: " + ex);
             return false;
         }
         // Wait for trigger on CrCaptureSessionListener.onConfigured();
         return true;
     }
 
     private boolean createCaptureRequest() {
         Log.d(TAG, "createCaptureRequest");
         try {
             // This line triggers the capture. No |listener| is registered, so
             // we will not get notified of capture events, instead, ImageReader
             // will trigger every time a downloaded image is ready. Since
             //|handler| is null, we'll work on the current Thread Looper.
             mCaptureSession.setRepeatingRequest(mPreviewBuilder.build(), null, null);
-        } catch (CameraAccessException ex) {
-            Log.e(TAG, "setRepeatingRequest: " + ex);
-            return false;
-        } catch (IllegalArgumentException ex) {
-            Log.e(TAG, "setRepeatingRequest: " + ex);
-            return false;
-        } catch (SecurityException ex) {
+        } catch (CameraAccessException | IllegalArgumentException | SecurityException ex) {
             Log.e(TAG, "setRepeatingRequest: " + ex);
             return false;
         }
         // Now wait for trigger on CrImageReaderListener.onImageAvailable();
         return true;
     }
 
     private static void readImageIntoBuffer(Image image, byte[] data) {
         final int imageWidth = image.getWidth();
         final int imageHeight = image.getHeight();
@@ skipping 47 matching lines @@
         return cameraCharacteristics != null
                 && cameraCharacteristics.get(CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL)
                 == CameraMetadata.INFO_SUPPORTED_HARDWARE_LEVEL_LEGACY;
     }
 
     static int getNumberOfCameras(Context appContext) {
         final CameraManager manager =
                 (CameraManager) appContext.getSystemService(Context.CAMERA_SERVICE);
         try {
             return manager.getCameraIdList().length;
-        } catch (CameraAccessException ex) {
+        } catch (CameraAccessException | SecurityException ex) {
+            // SecurityException is an undocumented exception, but has been seen in
+            // http://crbug/605424.
             Log.e(TAG, "getNumberOfCameras: getCameraIdList(): " + ex);
             return 0;
         }
     }
 
     static int getCaptureApiType(int id, Context appContext) {
         final CameraCharacteristics cameraCharacteristics =
                 getCameraCharacteristics(appContext, id);
         if (cameraCharacteristics == null) {
             return CaptureApiType.API_TYPE_UNKNOWN;
@@ skipping 121 matching lines @@
     @Override
     public boolean startCapture() {
         Log.d(TAG, "startCapture");
         changeCameraStateAndNotify(CameraState.OPENING);
         final CameraManager manager =
                 (CameraManager) mContext.getSystemService(Context.CAMERA_SERVICE);
         final Handler mainHandler = new Handler(mContext.getMainLooper());
         final CrStateListener stateListener = new CrStateListener();
         try {
             manager.openCamera(Integer.toString(mId), stateListener, mainHandler);
-        } catch (CameraAccessException ex) {
-            Log.e(TAG, "allocate: manager.openCamera: " + ex);
-            return false;
-        } catch (IllegalArgumentException ex) {
-            Log.e(TAG, "allocate: manager.openCamera: " + ex);
-            return false;
-        } catch (SecurityException ex) {
+        } catch (CameraAccessException | IllegalArgumentException | SecurityException ex) {
             Log.e(TAG, "allocate: manager.openCamera: " + ex);
             return false;
         }
 
         return true;
     }
 
     @Override
     public boolean stopCapture() {
         Log.d(TAG, "stopCapture");
 
         // With Camera2 API, the capture is started asynchronously, which will cause problem if
         // stopCapture comes too quickly. Without stopping the previous capture properly, the next
         // startCapture will fail and make Chrome no-responding. So wait camera to be STARTED.
         synchronized (mCameraStateLock) {
             while (mCameraState != CameraState.STARTED && mCameraState != CameraState.STOPPED) {
                 try {
                     mCameraStateLock.wait();
                 } catch (InterruptedException ex) {
                     Log.e(TAG, "CaptureStartedEvent: " + ex);
                 }
             }
             if (mCameraState == CameraState.STOPPED) return true;
         }
 
         try {
             mCaptureSession.abortCaptures();
-        } catch (CameraAccessException ex) {
-            Log.e(TAG, "abortCaptures: " + ex);
-            return false;
-        } catch (IllegalStateException ex) {
+        } catch (CameraAccessException | IllegalStateException ex) {
             Log.e(TAG, "abortCaptures: " + ex);
             return false;
         }
         if (mCameraDevice == null) return false;
         mCameraDevice.close();
         changeCameraStateAndNotify(CameraState.STOPPED);
         return true;
     }
 
     @Override
     public void deallocate() {
         Log.d(TAG, "deallocate");
     }
 }