Android: Remove GetApplicationContext part 4

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.graphics.Rect;
 import android.hardware.camera2.CameraAccessException;
 import android.hardware.camera2.CameraCaptureSession;
 import android.hardware.camera2.CameraCharacteristics;
 import android.hardware.camera2.CameraDevice;
 import android.hardware.camera2.CameraManager;
 import android.hardware.camera2.CameraMetadata;
 import android.hardware.camera2.CaptureRequest;
 import android.hardware.camera2.params.MeteringRectangle;
 import android.hardware.camera2.params.StreamConfigurationMap;
 import android.media.Image;
 import android.media.ImageReader;
 import android.os.Build;
 import android.os.Handler;
 import android.os.HandlerThread;
 import android.util.Range;
 import android.util.Size;
 import android.util.SparseIntArray;
 import android.view.Surface;
 
+import org.chromium.base.ContextUtils;
 import org.chromium.base.Log;
 import org.chromium.base.annotations.JNINamespace;
 
 import java.nio.ByteBuffer;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 
 /**
  * This class implements Video Capture using Camera2 API, introduced in Android
@@ skipping 179 matching lines @@
                 notifyTakePhotoError(mCallbackId);
                 return;
             }
 
             if (createPreviewObjects()) return;
 
             nativeOnError(mNativeVideoCaptureDeviceAndroid, "Error restarting preview");
         }
     };
 
-    // Inner Runnable to restart capture, must be run on |mContext| looper.
+    // Inner Runnable to restart capture, must be run on application context looper.
     private final Runnable mRestartCapture = new Runnable() {
         @Override
         public void run() {
             mPreviewSession.close(); // Asynchronously kill the CaptureSession.
             createPreviewObjects();
         }
     };
 
     private static final double kNanoSecondsToFps = 1.0E-9;
     private static final String TAG = "VideoCapture";
@@ skipping 34 matching lines @@
     private MeteringRectangle mAreaOfInterest;
     private int mExposureCompensation;
     private int mWhiteBalanceMode = AndroidMeteringMode.CONTINUOUS;
     private int mColorTemperature = -1;
     private int mIso;
     private boolean mRedEyeReduction;
     private int mFillLightMode = AndroidFillLightMode.OFF;
     private boolean mTorch;
 
     // Service function to grab CameraCharacteristics and handle exceptions.
-    private static CameraCharacteristics getCameraCharacteristics(Context appContext, int id) {
+    private static CameraCharacteristics getCameraCharacteristics(int id) {
         final CameraManager manager =
-                (CameraManager) appContext.getSystemService(Context.CAMERA_SERVICE);
+                (CameraManager) ContextUtils.getApplicationContext().getSystemService(
+                        Context.CAMERA_SERVICE);
         try {
             return manager.getCameraCharacteristics(Integer.toString(id));
         } catch (CameraAccessException ex) {
             Log.e(TAG, "getCameraCharacteristics: ", ex);
         }
         return null;
     }
 
     // {@link nativeOnPhotoTaken()} needs to be called back if there's any
     // problem after {@link takePhoto()} has returned true.
@@ skipping 78 matching lines @@
         // |mExposureMode|, |mFillLightMode| and |mTorch| interact to configure the AE and Flash
         // modes. In a nutshell, FLASH_MODE is only effective if the auto-exposure is ON/OFF,
         // otherwise the auto-exposure related flash control (ON_{AUTO,ALWAYS}_FLASH{_REDEYE) takes
         // priority.  |mTorch| mode overrides any previous |mFillLightMode| flash control.
         if (mExposureMode == AndroidMeteringMode.NONE
                 || mExposureMode == AndroidMeteringMode.FIXED) {
             requestBuilder.set(CaptureRequest.CONTROL_AE_MODE, CameraMetadata.CONTROL_AE_MODE_OFF);
 
             // We need to configure by hand the exposure time when AE mode is off.  Set it to the
             // middle of the allowed range. Further tuning will be done via |mIso|.
-            final CameraCharacteristics cameraCharacteristics =
-                    getCameraCharacteristics(mContext, mId);
+            final CameraCharacteristics cameraCharacteristics = getCameraCharacteristics(mId);
             Range<Long> range = cameraCharacteristics.get(
                     CameraCharacteristics.SENSOR_INFO_EXPOSURE_TIME_RANGE);
             requestBuilder.set(CaptureRequest.SENSOR_EXPOSURE_TIME,
                     range.getLower() + (range.getUpper() + range.getLower()) / 2 /* nanoseconds*/);
 
         } else {
             requestBuilder.set(CaptureRequest.CONTROL_MODE, CaptureRequest.CONTROL_MODE_AUTO);
             requestBuilder.set(CaptureRequest.CONTROL_AE_MODE, CameraMetadata.CONTROL_AE_MODE_ON);
             requestBuilder.set(CaptureRequest.CONTROL_AE_TARGET_FPS_RANGE, mAeFpsRange);
         }
@@ skipping 100 matching lines @@
 
         for (int i = 0; i < COLOR_TEMPERATURES_MAP.size(); ++i) {
             final int diff = Math.abs(colorTemperature - COLOR_TEMPERATURES_MAP.keyAt(i));
             if (diff >= minDiff) continue;
             minDiff = diff;
             matchedTemperature = COLOR_TEMPERATURES_MAP.valueAt(i);
         }
         return matchedTemperature;
     }
 
-    static boolean isLegacyDevice(Context appContext, int id) {
-        final CameraCharacteristics cameraCharacteristics =
-                getCameraCharacteristics(appContext, id);
+    static boolean isLegacyDevice(int id) {
+        final CameraCharacteristics cameraCharacteristics = getCameraCharacteristics(id);
         return cameraCharacteristics != null
                 && cameraCharacteristics.get(CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL)
                 == CameraMetadata.INFO_SUPPORTED_HARDWARE_LEVEL_LEGACY;
     }
 
-    static int getNumberOfCameras(Context appContext) {
+    static int getNumberOfCameras() {
         final CameraManager manager =
-                (CameraManager) appContext.getSystemService(Context.CAMERA_SERVICE);
+                (CameraManager) ContextUtils.getApplicationContext().getSystemService(
+                        Context.CAMERA_SERVICE);
         try {
             return manager.getCameraIdList().length;
         } catch (CameraAccessException | SecurityException ex) {
             // SecurityException is undocumented but seen in the wild: https://crbug/605424.
             Log.e(TAG, "getNumberOfCameras: getCameraIdList(): ", ex);
             return 0;
         }
     }
 
-    static int getCaptureApiType(int id, Context appContext) {
-        final CameraCharacteristics cameraCharacteristics =
-                getCameraCharacteristics(appContext, id);
+    static int getCaptureApiType(int id) {
+        final CameraCharacteristics cameraCharacteristics = getCameraCharacteristics(id);
         if (cameraCharacteristics == null) {
             return VideoCaptureApi.UNKNOWN;
         }
 
         final int supportedHWLevel =
                 cameraCharacteristics.get(CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL);
         switch (supportedHWLevel) {
             case CameraMetadata.INFO_SUPPORTED_HARDWARE_LEVEL_LEGACY:
                 return VideoCaptureApi.ANDROID_API2_LEGACY;
             case CameraMetadata.INFO_SUPPORTED_HARDWARE_LEVEL_FULL:
                 return VideoCaptureApi.ANDROID_API2_FULL;
             case CameraMetadata.INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED:
                 return VideoCaptureApi.ANDROID_API2_LIMITED;
             default:
                 return VideoCaptureApi.ANDROID_API2_LEGACY;
         }
     }
 
-    static String getName(int id, Context appContext) {
-        final CameraCharacteristics cameraCharacteristics =
-                getCameraCharacteristics(appContext, id);
+    static String getName(int id) {
+        final CameraCharacteristics cameraCharacteristics = getCameraCharacteristics(id);
         if (cameraCharacteristics == null) return null;
         final int facing = cameraCharacteristics.get(CameraCharacteristics.LENS_FACING);
         return "camera2 " + id + ", facing "
                 + ((facing == CameraCharacteristics.LENS_FACING_FRONT) ? "front" : "back");
     }
 
-    static VideoCaptureFormat[] getDeviceSupportedFormats(Context appContext, int id) {
-        final CameraCharacteristics cameraCharacteristics =
-                getCameraCharacteristics(appContext, id);
+    static VideoCaptureFormat[] getDeviceSupportedFormats(int id) {
+        final CameraCharacteristics cameraCharacteristics = getCameraCharacteristics(id);
         if (cameraCharacteristics == null) return null;
 
         final int[] capabilities =
                 cameraCharacteristics.get(CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES);
         // Per-format frame rate via getOutputMinFrameDuration() is only available if the
         // property REQUEST_AVAILABLE_CAPABILITIES_MANUAL_SENSOR is set.
         boolean minFrameDurationAvailable = false;
         for (int cap : capabilities) {
             if (cap == CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES_MANUAL_SENSOR) {
                 minFrameDurationAvailable = true;
@@ skipping 20 matching lines @@
                     // Hint: perhaps using SCALER_AVAILABLE_PROCESSED_MIN_DURATIONS.
                     minFrameRate = 0.0;
                 }
                 formatList.add(new VideoCaptureFormat(
                         size.getWidth(), size.getHeight(), (int) minFrameRate, 0));
             }
         }
         return formatList.toArray(new VideoCaptureFormat[formatList.size()]);
     }
 
-    VideoCaptureCamera2(Context context, int id, long nativeVideoCaptureDeviceAndroid) {
-        super(context, id, nativeVideoCaptureDeviceAndroid);
-        final CameraCharacteristics cameraCharacteristics = getCameraCharacteristics(context, id);
+    VideoCaptureCamera2(int id, long nativeVideoCaptureDeviceAndroid) {
+        super(id, nativeVideoCaptureDeviceAndroid);
+        final CameraCharacteristics cameraCharacteristics = getCameraCharacteristics(id);
         mMaxZoom =
                 cameraCharacteristics.get(CameraCharacteristics.SCALER_AVAILABLE_MAX_DIGITAL_ZOOM);
     }
 
     @Override
     public boolean allocate(int width, int height, int frameRate) {
         Log.d(TAG, "allocate: requested (%d x %d) @%dfps", width, height, frameRate);
         synchronized (mCameraStateLock) {
             if (mCameraState == CameraState.OPENING || mCameraState == CameraState.CONFIGURING) {
                 Log.e(TAG, "allocate() invoked while Camera is busy opening/configuring.");
                 return false;
             }
         }
-        final CameraCharacteristics cameraCharacteristics = getCameraCharacteristics(mContext, mId);
+        final CameraCharacteristics cameraCharacteristics = getCameraCharacteristics(mId);
         final StreamConfigurationMap streamMap =
                 cameraCharacteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);
 
         // Find closest supported size.
         final Size[] supportedSizes = streamMap.getOutputSizes(ImageFormat.YUV_420_888);
         final Size closestSupportedSize = findClosestSizeInArray(supportedSizes, width, height);
         if (closestSupportedSize == null) {
             Log.e(TAG, "No supported resolutions.");
             return false;
         }
@@ skipping 31 matching lines @@
                 cameraCharacteristics.get(CameraCharacteristics.LENS_FACING)
                 == CameraCharacteristics.LENS_FACING_BACK;
         return true;
     }
 
     @Override
     public boolean startCapture() {
         Log.d(TAG, "startCapture");
         changeCameraStateAndNotify(CameraState.OPENING);
         final CameraManager manager =
-                (CameraManager) mContext.getSystemService(Context.CAMERA_SERVICE);
+                (CameraManager) ContextUtils.getApplicationContext().getSystemService(
+                        Context.CAMERA_SERVICE);
 
         if (!mUseBackgroundThreadForTesting) {
-            mMainHandler = new Handler(mContext.getMainLooper());
+            mMainHandler = new Handler(ContextUtils.getApplicationContext().getMainLooper());
         } else {
-            // Usually we deliver frames on |mContext|s thread, but unit tests
+            // Usually we deliver frames on application context thread, but unit tests
             // occupy its Looper; deliver frames on a background thread instead.
             HandlerThread thread = new HandlerThread("CameraPicture");
             thread.start();
             mMainHandler = new Handler(thread.getLooper());
         }
 
         final CrStateListener stateListener = new CrStateListener();
         try {
             manager.openCamera(Integer.toString(mId), stateListener, mMainHandler);
         } catch (CameraAccessException | IllegalArgumentException | SecurityException ex) {
@@ skipping 33 matching lines @@
 
         if (mUseBackgroundThreadForTesting) mMainHandler.getLooper().quit();
 
         changeCameraStateAndNotify(CameraState.STOPPED);
         mCropRect = new Rect();
         return true;
     }
 
     @Override
     public PhotoCapabilities getPhotoCapabilities() {
-        final CameraCharacteristics cameraCharacteristics = getCameraCharacteristics(mContext, mId);
+        final CameraCharacteristics cameraCharacteristics = getCameraCharacteristics(mId);
         PhotoCapabilities.Builder builder = new PhotoCapabilities.Builder();
 
         int minIso = 0;
         int maxIso = 0;
         final Range<Integer> iso_range =
                 cameraCharacteristics.get(CameraCharacteristics.SENSOR_INFO_SENSITIVITY_RANGE);
         if (iso_range != null) {
             minIso = iso_range.getLower();
             maxIso = iso_range.getUpper();
         }
@@ skipping 174 matching lines @@
 
         return builder.build();
     }
 
     @Override
     public void setPhotoOptions(double zoom, int focusMode, int exposureMode, double width,
             double height, float[] pointsOfInterest2D, boolean hasExposureCompensation,
             double exposureCompensation, int whiteBalanceMode, double iso,
             boolean hasRedEyeReduction, boolean redEyeReduction, int fillLightMode,
             boolean hasTorch, boolean torch, double colorTemperature) {
-        final CameraCharacteristics cameraCharacteristics = getCameraCharacteristics(mContext, mId);
+        final CameraCharacteristics cameraCharacteristics = getCameraCharacteristics(mId);
         final Rect canvas =
                 cameraCharacteristics.get(CameraCharacteristics.SENSOR_INFO_ACTIVE_ARRAY_SIZE);
 
         if (zoom != 0) {
             final float normalizedZoom = Math.max(1.0f, Math.min((float) zoom, mMaxZoom));
             final float cropFactor = (normalizedZoom - 1) / (2 * normalizedZoom);
 
             mCropRect = new Rect(Math.round(canvas.width() * cropFactor),
                     Math.round(canvas.height() * cropFactor),
                     Math.round(canvas.width() * (1 - cropFactor)),
@@ skipping 52 matching lines @@
         }
         if (iso > 0) mIso = (int) Math.round(iso);
         if (mWhiteBalanceMode == AndroidMeteringMode.FIXED && colorTemperature > 0) {
             mColorTemperature = (int) Math.round(colorTemperature);
         }
 
         if (hasRedEyeReduction) mRedEyeReduction = redEyeReduction;
         if (fillLightMode != AndroidFillLightMode.NOT_SET) mFillLightMode = fillLightMode;
         if (hasTorch) mTorch = torch;
 
-        final Handler mainHandler = new Handler(mContext.getMainLooper());
+        final Handler mainHandler =
+                new Handler(ContextUtils.getApplicationContext().getMainLooper());
         mainHandler.removeCallbacks(mRestartCapture);
         mainHandler.post(mRestartCapture);
     }
 
     @Override
     public boolean takePhoto(final long callbackId) {
         Log.d(TAG, "takePhoto");
         if (mCameraDevice == null || mCameraState != CameraState.STARTED) return false;
 
-        final CameraCharacteristics cameraCharacteristics = getCameraCharacteristics(mContext, mId);
+        final CameraCharacteristics cameraCharacteristics = getCameraCharacteristics(mId);
         final StreamConfigurationMap streamMap =
                 cameraCharacteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);
         final Size[] supportedSizes = streamMap.getOutputSizes(ImageFormat.JPEG);
         final Size closestSize = findClosestSizeInArray(supportedSizes, mPhotoWidth, mPhotoHeight);
 
         Log.d(TAG, "requested resolution: (%dx%d)", mPhotoWidth, mPhotoHeight);
         if (closestSize != null) {
             Log.d(TAG, " matched (%dx%d)", closestSize.getWidth(), closestSize.getHeight());
         }
         final ImageReader imageReader = ImageReader.newInstance(
@@ skipping 39 matching lines @@
             return false;
         }
         return true;
     }
 
     @Override
     public void deallocate() {
         Log.d(TAG, "deallocate");
     }
 }