Expose Gamepad API instance for Cardboard button

chrome/browser/android/vr_shell/vr_shell.cc

 // Copyright 2016 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 "chrome/browser/android/vr_shell/vr_shell.h"
 
 #include <android/native_window_jni.h>
 
 #include <string>
 #include <utility>
@@ skipping 24 matching lines @@
 #include "chrome/browser/media/webrtc/media_capture_devices_dispatcher.h"
 #include "chrome/browser/media/webrtc/media_stream_capture_indicator.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/render_widget_host.h"
 #include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/content_features.h"
 #include "content/public/common/referrer.h"
+#include "device/vr/android/gvr/cardboard_gamepad_data_fetcher.h"
 #include "device/vr/android/gvr/gvr_device.h"
 #include "device/vr/android/gvr/gvr_device_provider.h"
 #include "device/vr/android/gvr/gvr_gamepad_data_fetcher.h"
 #include "gpu/command_buffer/common/mailbox.h"
 #include "jni/VrShellImpl_jni.h"
 #include "third_party/WebKit/public/platform/WebInputEvent.h"
 #include "ui/android/view_android.h"
 #include "ui/android/window_android.h"
 #include "ui/base/page_transition_types.h"
 #include "ui/display/display.h"
@@ skipping 119 matching lines @@
   }
 }
 
 bool RegisterVrShell(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 VrShell::~VrShell() {
   DVLOG(1) << __FUNCTION__ << "=" << this;
   poll_capturing_media_task_.Cancel();
-  if (gamepad_source_active_) {
+  if (gvr_gamepad_source_active_) {
     device::GamepadDataFetcherManager::GetInstance()->RemoveSourceFactory(
         device::GAMEPAD_SOURCE_GVR);
   }
 
+  if (cardboard_gamepad_source_active_) {
+    device::GamepadDataFetcherManager::GetInstance()->RemoveSourceFactory(
+        device::GAMEPAD_SOURCE_CARDBOARD);
+  }
+
   delegate_provider_->RemoveDelegate();
   {
     // The GvrLayout is, and must always be, used only on the UI thread, and the
     // GvrApi used for rendering should only be used from the GL thread as it's
     // not thread safe. However, the GvrLayout owns the GvrApi instance, and
     // when it gets shut down it deletes the GvrApi instance with it. Therefore,
     // we need to block shutting down the GvrLayout on stopping our GL thread
     // from using the GvrApi instance.
     // base::Thread::Stop, which is called when destroying the thread, asserts
     // that IO is allowed to prevent jank, but there shouldn't be any concerns
@@ skipping 40 matching lines @@
 void VrShell::NavigateBack() {
   JNIEnv* env = base::android::AttachCurrentThread();
   Java_VrShellImpl_navigateBack(env, j_vr_shell_.obj());
 }
 
 void VrShell::ExitCct() {
   JNIEnv* env = base::android::AttachCurrentThread();
   Java_VrShellImpl_exitCct(env, j_vr_shell_.obj());
 }
 
-void VrShell::OnTriggerEvent(JNIEnv* env, const JavaParamRef<jobject>& obj) {
+void VrShell::ToggleCardboardGamepad(bool enabled) {
+  // enable/disable updating gamepad state
+  if (cardboard_gamepad_source_active_ && !enabled) {
+    device::GamepadDataFetcherManager::GetInstance()->RemoveSourceFactory(
+        device::GAMEPAD_SOURCE_CARDBOARD);
+    cardboard_gamepad_data_fetcher_ = nullptr;
+    cardboard_gamepad_source_active_ = false;
+  }
+
+  if (!cardboard_gamepad_source_active_ && enabled) {
+    // enable the gamepad
+    if (!delegate_provider_->device_provider())
+      return;
+
+    unsigned int device_id =
+        delegate_provider_->device_provider()->Device()->id();
+
+    device::GamepadDataFetcherManager::GetInstance()->AddFactory(
+        new device::CardboardGamepadDataFetcher::Factory(this, device_id));
+    cardboard_gamepad_source_active_ = true;
+  }
+}
+
+void VrShell::OnTriggerEvent(JNIEnv* env,
+                             const JavaParamRef<jobject>& obj,
+                             bool touched) {
   WaitForGlThread();
-  PostToGlThread(FROM_HERE, base::Bind(&VrShellGl::OnTriggerEvent,
-                                       gl_thread_->GetVrShellGl()));
+
+  // Send screen taps over to VrShellGl to be turned into simulated clicks for
+  // cardboard.
+  if (touched)
+    PostToGlThread(FROM_HERE, base::Bind(&VrShellGl::OnTriggerEvent,
+                                         gl_thread_->GetVrShellGl()));
+
+  // If we are running cardboard, update gamepad state.
+  if (cardboard_gamepad_source_active_) {
+    device::CardboardGamepadData pad;
+    pad.timestamp = cardboard_gamepad_timer_++;
+    pad.is_screen_touching = touched;
+    if (cardboard_gamepad_data_fetcher_) {
+      cardboard_gamepad_data_fetcher_->SetGamepadData(pad);
+    }
+  }
 }
 
 void VrShell::OnPause(JNIEnv* env, const JavaParamRef<jobject>& obj) {
   WaitForGlThread();
   PostToGlThread(FROM_HERE,
                  base::Bind(&VrShellGl::OnPause, gl_thread_->GetVrShellGl()));
 
   // exit vr session
   if (metrics_helper_)
     metrics_helper_->SetVRActive(false);
@@ skipping 335 matching lines @@
 void VrShell::ProcessContentGesture(
     std::unique_ptr<blink::WebInputEvent> event) {
   if (input_manager_) {
     input_manager_->ProcessUpdatedGesture(std::move(event));
   } else if (android_ui_gesture_target_) {
     android_ui_gesture_target_->DispatchWebInputEvent(std::move(event));
   }
 }
 
 void VrShell::UpdateGamepadData(device::GvrGamepadData pad) {
-  if (!gamepad_source_active_) {
+  if (!gvr_gamepad_source_active_) {
     if (!delegate_provider_->device_provider())
       return;
 
     unsigned int device_id =
         delegate_provider_->device_provider()->Device()->id();
+
     device::GamepadDataFetcherManager::GetInstance()->AddFactory(
         new device::GvrGamepadDataFetcher::Factory(this, device_id));
-    gamepad_source_active_ = true;
+    gvr_gamepad_source_active_ = true;
   }
-  if (gamepad_data_fetcher_) {
-    gamepad_data_fetcher_->SetGamepadData(pad);
+  if (gvr_gamepad_data_fetcher_) {
+    gvr_gamepad_data_fetcher_->SetGamepadData(pad);
   }
 }
 
-void VrShell::RegisterGamepadDataFetcher(
+void VrShell::RegisterGvrGamepadDataFetcher(
     device::GvrGamepadDataFetcher* fetcher) {
   DVLOG(1) << __FUNCTION__ << "(" << fetcher << ")";
-  gamepad_data_fetcher_ = fetcher;
+  gvr_gamepad_data_fetcher_ = fetcher;
+}
+
+void VrShell::RegisterCardboardGamepadDataFetcher(
+    device::CardboardGamepadDataFetcher* fetcher) {
+  DVLOG(1) << __FUNCTION__ << "(" << fetcher << ")";
+  cardboard_gamepad_data_fetcher_ = fetcher;
 }
 
 bool VrShell::HasDaydreamSupport(JNIEnv* env) {
   return Java_VrShellImpl_hasDaydreamSupport(env, j_vr_shell_.obj());
 }
 
 // ----------------------------------------------------------------------------
 // Native JNI methods
 // ----------------------------------------------------------------------------
 
 jlong Init(JNIEnv* env,
            const JavaParamRef<jobject>& obj,
            const JavaParamRef<jobject>& delegate,
            jlong window_android,
            jboolean for_web_vr,
            jboolean in_cct,
            jlong gvr_api,
            jboolean reprojected_rendering) {
   return reinterpret_cast<intptr_t>(new VrShell(
       env, obj, reinterpret_cast<ui::WindowAndroid*>(window_android),
       for_web_vr, in_cct,
       VrShellDelegate::GetNativeVrShellDelegate(env, delegate),
       reinterpret_cast<gvr_context*>(gvr_api), reprojected_rendering));
 }
 
 }  // namespace vr_shell