Add event listening function to openvr device

device/vr/openvr/openvr_device.cc

 // Copyright (c) 2017 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.
 
 #define _USE_MATH_DEFINES  // for M_PI
 #include "device/vr/openvr/openvr_device.h"
 #include <math.h>
 #include "third_party/openvr/src/headers/openvr.h"
 
 namespace {
@@ skipping 58 matching lines @@
   transform[13] = mat.m[1][3];
   transform[14] = mat.m[2][3];
   transform[15] = 1.0f;
   return transform;
 }
 
 }  // namespace
 
 namespace device {
 
-OpenVRDevice::OpenVRDevice() {}
+OpenVRDevice::OpenVRDevice() : weak_ptr_factory_(this) {}
 OpenVRDevice::~OpenVRDevice() {}
 
 void OpenVRDevice::CreateVRDisplayInfo(
     const base::Callback<void(mojom::VRDisplayInfoPtr)>& on_created) {
   vr::EVRInitError init_error;
   auto vr_system =
       vr::VR_Init(&init_error, vr::EVRApplicationType::VRApplication_Scene);
 
   if (init_error != vr::VRInitError_None) {
     LOG(ERROR) << vr::VR_GetVRInitErrorAsEnglishDescription(init_error);
@@ skipping 52 matching lines @@
   if (chaperone) {
     chaperone->GetPlayAreaSize(&device->stageParameters->sizeX,
                                &device->stageParameters->sizeZ);
   } else {
     device->stageParameters->sizeX = 0.0f;
     device->stageParameters->sizeZ = 0.0f;
   }
 
   render_loop_ = std::make_unique<OpenVRRenderLoop>(vr_system);
 
+  render_loop_->RegistPollingEventCallback(base::Bind(
+      &OpenVRDevice::OnPollingEvent, weak_ptr_factory_.GetWeakPtr()));
+
   on_created.Run(std::move(device));
 }
 
 void OpenVRDevice::RequestPresent(mojom::VRSubmitFrameClientPtr submit_client,
                                   const base::Callback<void(bool)>& callback) {
   callback.Run(false);
   // We don't support presentation currently.
 }
 
 void OpenVRDevice::SetSecureOrigin(bool secure_origin) {
@@ skipping 10 matching lines @@
 }
 
 void OpenVRDevice::UpdateLayerBounds(int16_t frame_index,
                                      mojom::VRLayerBoundsPtr left_bounds,
                                      mojom::VRLayerBoundsPtr right_bounds,
                                      int16_t source_width,
                                      int16_t source_height) {
   // We don't support presentation currently, so don't do anything.
 }
 
+// TODO(shaobo): OnConnect and OnDisconnect need to be added to VrDisplayClient
+// in vr_service.mojom
+void OpenVRDevice::OnPollingEvent(OpenVRDevice::VREvent event) {
+  switch (event) {
+    case OpenVRDevice::VREvent::CONNECTED:
+    case OpenVRDevice::VREvent::DISCONNECTED:
+      break;
+
+    case OpenVRDevice::VREvent::CHANGED:
+      OnChanged();

[shaobo.yan, 2017/04/24 02:27:27]

I just find that this will cause vr_system created several times based on
current logic. I'll update it but I questioned that vr_system is reasonable to
be held in either OpenVRRenderLoop or OpenVRDevice(maybe a utility class is
better?) 

+      break;
+
+    default:
+      break;
+  }
+}
+
 void OpenVRDevice::GetVRVSyncProvider(mojom::VRVSyncProviderRequest request) {
   render_loop_->Bind(std::move(request));
 }
 
 OpenVRDevice::OpenVRRenderLoop::OpenVRRenderLoop(vr::IVRSystem* vr_system)
     : vr_system_(vr_system),
       binding_(this),
       base::SimpleThread("OpenVRRenderLoop") {}
 
 void OpenVRDevice::OpenVRRenderLoop::Bind(
@@ skipping 39 matching lines @@
     pose->position.value()[1] = m[1][3];
     pose->position.value()[2] = m[2][3];
 
     pose->linearVelocity = HmdVector3ToWebVR(hmdPose.vVelocity);
     pose->angularVelocity = HmdVector3ToWebVR(hmdPose.vAngularVelocity);
   }
 
   return std::move(pose);
 }
 
+// Only deal with event which will cause displayInfo changed now.
+void OpenVRDevice::OpenVRRenderLoop::PollEvent() {
+  if (!vr_system_ || on_polling_event_.is_null())
+    return;
+
+  vr::VREvent_t event;
+  bool is_changed = false;
+  while (vr_system_->PollNextEvent(&event, sizeof(event))) {
+    if (event.trackedDeviceIndex != vr::k_unTrackedDeviceIndex_Hmd &&
+        event.trackedDeviceIndex != vr::k_unTrackedDeviceIndexInvalid) {
+      continue;
+    }
+
+    switch (event.eventType) {
+      case vr::VREvent_TrackedDeviceActivated:
+        on_polling_event_.Run(OpenVRDevice::VREvent::CONNECTED);
+        break;
+
+      case vr::VREvent_TrackedDeviceDeactivated:
+        on_polling_event_.Run(OpenVRDevice::VREvent::DISCONNECTED);
+        break;
+
+      case vr::VREvent_TrackedDeviceUpdated:
+      case vr::VREvent_IpdChanged:
+      case vr::VREvent_ChaperoneDataHasChanged:
+      case vr::VREvent_ChaperoneSettingsHaveChanged:
+      case vr::VREvent_ChaperoneUniverseHasChanged:
+        is_changed = true;

[nhu, 2017/04/24 01:47:06]

If there is the only one place to trigger Changed event, can we call
VRDevice::OnChanged right here?

[shaobo.yan, 2017/04/24 02:27:27]

I introduce this bool variable here for the situation that OnChanged may be
called several times in one rAF call. Since each call of OnChanged will cause
vrdisplayInfo updated (fetch new data, transfer data and update on blink side),
I think combine them and call OnChanged only once per rAF is a performance
optimization. Pls correct me if any mistake :)

+        break;
+
+      default:
+        break;
+    }
+  }
+
+  if (is_changed) {
+    on_polling_event_.Run(OpenVRDevice::VREvent::CHANGED);
+  }
+}
+
+// Regist a callback function to deal with system event.
+void OpenVRDevice::OpenVRRenderLoop::RegistPollingEventCallback(
+    const base::Callback<void(OpenVRDevice::VREvent)>& onPollingEvent) {
+  if (onPollingEvent.is_null())
+    return;
+
+  on_polling_event_ = onPollingEvent;
+}
+
+void OpenVRDevice::OpenVRRenderLoop::UnregistPollingEventCallback() {
+  on_polling_event_.Reset();
+}
+
 void OpenVRDevice::OpenVRRenderLoop::GetVSync(
     const mojom::VRVSyncProvider::GetVSyncCallback& callback) {
   static int16_t next_frame = 0;
   int16_t frame = next_frame++;
 
+  // VSync could be used as a signal to poll event.
+  PollEvent();
+
   // TODO(BillOrr): Give real values when VSync loop is hooked up.  This is the
   // presentation time for the frame. Just returning a default value for now
   // since we don't have VSync hooked up.
   base::TimeDelta time = base::TimeDelta::FromSecondsD(2.0);
 
   device::mojom::VRPosePtr pose = getPose();
   Sleep(11);  // TODO (billorr): Use real vsync timing instead of a sleep (this
               // sleep just throttles vsyncs so we don't fill message queues).
   callback.Run(std::move(pose), time, frame,
                device::mojom::VRVSyncProvider::Status::SUCCESS);
 }
 
 }  // namespace device