ImageCapture: support exposure mode configuration

media/capture/video/android/video_capture_device_android.cc

 // Copyright (c) 2013 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.
 
 #include "media/capture/video/android/video_capture_device_android.h"
 
 #include <stdint.h>
 #include <utility>
 
 #include "base/android/jni_android.h"
@@ skipping 11 matching lines @@
 using base::android::AttachCurrentThread;
 using base::android::CheckException;
 using base::android::GetClass;
 using base::android::JavaParamRef;
 using base::android::MethodID;
 using base::android::JavaRef;
 using base::android::ScopedJavaLocalRef;
 
 namespace media {
 
+namespace {
+
+mojom::MeteringMode ToMojomMeteringMode(
+    PhotoCapabilities::AndroidMeteringMode android_mode) {
+  if (android_mode == PhotoCapabilities::AndroidMeteringMode::FIXED)
+    return mojom::MeteringMode::MANUAL;
+  else if (android_mode == PhotoCapabilities::AndroidMeteringMode::SINGLE_SHOT)
+    return mojom::MeteringMode::SINGLE_SHOT;
+  else if (android_mode == PhotoCapabilities::AndroidMeteringMode::CONTINUOUS)
+    return mojom::MeteringMode::CONTINUOUS;
+  return mojom::MeteringMode::UNAVAILABLE;
+}
+
+PhotoCapabilities::AndroidMeteringMode ToAndroidMeteringMode(
+    mojom::MeteringMode mojom_mode) {
+  if (mojom_mode == mojom::MeteringMode::MANUAL)
+    return PhotoCapabilities::AndroidMeteringMode::FIXED;
+  else if (mojom_mode == mojom::MeteringMode::SINGLE_SHOT)
+    return PhotoCapabilities::AndroidMeteringMode::SINGLE_SHOT;
+  else if (mojom_mode == mojom::MeteringMode::CONTINUOUS)
+    return PhotoCapabilities::AndroidMeteringMode::CONTINUOUS;
+  return PhotoCapabilities::AndroidMeteringMode::UNAVAILABLE;
+}

[Reilly Grant (use Gerrit), 2016/08/24 18:14:03]

Use switch statements for these functions?

[mcasas, 2016/08/24 18:36:23]

Ooops yes, done.

+
+}  // anonymous namespace
+
 // static
 bool VideoCaptureDeviceAndroid::RegisterVideoCaptureDevice(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 VideoCaptureDeviceAndroid::VideoCaptureDeviceAndroid(
     const VideoCaptureDeviceDescriptor& device_descriptor)
     : main_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       state_(kIdle),
       got_first_frame_(false),
@@ skipping 385 matching lines @@
   photo_capabilities->height->max = caps.getMaxHeight();
   photo_capabilities->height->min = caps.getMinHeight();
   photo_capabilities->width = mojom::Range::New();
   photo_capabilities->width->current = caps.getCurrentWidth();
   photo_capabilities->width->max = caps.getMaxWidth();
   photo_capabilities->width->min = caps.getMinWidth();
   photo_capabilities->zoom = mojom::Range::New();
   photo_capabilities->zoom->current = caps.getCurrentZoom();
   photo_capabilities->zoom->max = caps.getMaxZoom();
   photo_capabilities->zoom->min = caps.getMinZoom();
-  switch (caps.getFocusMode()) {
-    case PhotoCapabilities::AndroidFocusMode::UNAVAILABLE:
-      photo_capabilities->focus_mode = mojom::FocusMode::UNAVAILABLE;
-      break;
-    case PhotoCapabilities::AndroidFocusMode::FIXED:
-      photo_capabilities->focus_mode = mojom::FocusMode::MANUAL;
-      break;
-    case PhotoCapabilities::AndroidFocusMode::SINGLE_SHOT:
-      photo_capabilities->focus_mode = mojom::FocusMode::SINGLE_SHOT;
-      break;
-    case PhotoCapabilities::AndroidFocusMode::CONTINUOUS:
-      photo_capabilities->focus_mode = mojom::FocusMode::CONTINUOUS;
-      break;
-  }
+  photo_capabilities->focus_mode = ToMojomMeteringMode(caps.getFocusMode());
+  photo_capabilities->exposure_mode =
+      ToMojomMeteringMode(caps.getExposureMode());
+
   callback.Run(std::move(photo_capabilities));
 }
 
 void VideoCaptureDeviceAndroid::DoSetPhotoOptions(
     mojom::PhotoSettingsPtr settings,
     SetPhotoOptionsCallback callback) {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 #if DCHECK_IS_ON()
   {
     base::AutoLock lock(lock_);
     DCHECK_EQ(kConfigured, state_);
     DCHECK(got_first_frame_);
   }
 #endif
   JNIEnv* env = AttachCurrentThread();
 
   const int width = settings->has_width ? settings->width : 0;
   const int height = settings->has_height ? settings->height : 0;
   const int zoom = settings->has_zoom ? settings->zoom : 0;
 
-  PhotoCapabilities::AndroidFocusMode focus_mode =
-      PhotoCapabilities::AndroidFocusMode::UNAVAILABLE;
-  if (settings->has_focus_mode) {
-    switch (settings->focus_mode) {
-      case mojom::FocusMode::MANUAL:
-        focus_mode = PhotoCapabilities::AndroidFocusMode::FIXED;
-        break;
-      case mojom::FocusMode::SINGLE_SHOT:
-        focus_mode = PhotoCapabilities::AndroidFocusMode::SINGLE_SHOT;
-        break;
-      case mojom::FocusMode::CONTINUOUS:
-        focus_mode = PhotoCapabilities::AndroidFocusMode::CONTINUOUS;
-        break;
-      case mojom::FocusMode::UNAVAILABLE:
-        focus_mode = PhotoCapabilities::AndroidFocusMode::UNAVAILABLE;
-        break;
-    }
-  }
+  const PhotoCapabilities::AndroidMeteringMode focus_mode =
+      settings->has_focus_mode
+          ? ToAndroidMeteringMode(settings->focus_mode)
+          : PhotoCapabilities::AndroidMeteringMode::NOT_SET;
+
+  const PhotoCapabilities::AndroidMeteringMode exposure_mode =
+      settings->has_exposure_mode
+          ? ToAndroidMeteringMode(settings->exposure_mode)
+          : PhotoCapabilities::AndroidMeteringMode::NOT_SET;
 
   std::vector<float> points_of_interest_marshalled;
   for (const auto& point : settings->points_of_interest) {
     points_of_interest_marshalled.push_back(point->x);
     points_of_interest_marshalled.push_back(point->y);
   }
   ScopedJavaLocalRef<jfloatArray> points_of_interest =
       base::android::ToJavaFloatArray(env, points_of_interest_marshalled);
 
-  Java_VideoCapture_setPhotoOptions(env, j_capture_, zoom,
-                                    static_cast<int>(focus_mode), width, height,
-                                    points_of_interest);
+  Java_VideoCapture_setPhotoOptions(
+      env, j_capture_, zoom, static_cast<int>(focus_mode),
+      static_cast<int>(exposure_mode), width, height, points_of_interest);
 
   callback.Run(true);
 }
 
 }  // namespace media