Bug 1523351 - Part 4: DS4 GamepadTouch and GamepadLightIndicator implementation in Windows. r=aklotz,baku

These should both be blocking reviewers.

Differential Revision: https://phabricator.services.mozilla.com/D29291

--HG--
extra : moz-landing-system : lando

Author: daoshengmu

dom/gamepad/GamepadRemapping.cpp

@@ -47,6 +47,10 @@ enum CanonicalAxisIndex {
   AXIS_INDEX_COUNT
 };
 
+float NormalizeTouch(long aValue, long aMin, long aMax) {
+  return (2.f * (aValue - aMin) / static_cast<float>(aMax - aMin)) - 1.f;
+}
+
 bool AxisNegativeAsButton(float input) {
   const float value = (input < -0.5f) ? 1.f : 0.f;
   return value > 0.1f;
@@ -363,6 +367,92 @@ class Dualshock4Remapper final : public GamepadRemapper {
     return DUALSHOCK_BUTTON_COUNT;
   }
 
+  virtual uint32_t GetLightIndicatorCount() const override {
+    return LIGHT_INDICATOR_COUNT;
+  }
+
+  virtual void GetLightIndicators(
+      nsTArray<GamepadLightIndicatorType>& aTypes) const override {
+    const uint32_t len = GetLightIndicatorCount();
+    aTypes.SetLength(len);
+    for (uint32_t i = 0; i < len; ++i) {
+      aTypes[i] = GamepadLightIndicatorType::Rgb;
+    }
+  }
+
+  virtual uint32_t GetTouchEventCount() const override {
+    return TOUCH_EVENT_COUNT;
+  }
+
+  virtual void GetLightColorReport(
+      uint8_t aRed, uint8_t aGreen, uint8_t aBlue,
+      std::vector<uint8_t>& aReport) const override {
+    const size_t report_length = 32;
+    aReport.resize(report_length);
+    aReport.assign(report_length, 0);
+
+    aReport[0] = 0x05;  // report ID USB only
+    aReport[1] = 0x02;  // LED only
+    aReport[6] = aRed;
+    aReport[7] = aGreen;
+    aReport[8] = aBlue;
+  }
+
+  virtual void GetTouchData(uint32_t aIndex, void* aInput) override {
+    nsTArray<GamepadTouchState> touches(TOUCH_EVENT_COUNT);
+    touches.SetLength(TOUCH_EVENT_COUNT);
+    uint8_t* rawData = (uint8_t*)aInput;
+
+    bool touch0Pressed = (((rawData[35] & 0xff) >> 7) == 0);
+    bool touch1Pressed = (((rawData[39] & 0xff) >> 7) == 0);
+
+    if (!touch0Pressed && !touch1Pressed) {
+      return;
+    }
+
+    if ((touch0Pressed && (rawData[35] & 0xff) < mLastTouch0Id) ||
+        (touch1Pressed && (rawData[39] & 0xff) < mLastTouch1Id)) {
+      mTouchIdBase += 128;
+    }
+
+    const uint32_t kTouchDimensionX = 1920;
+    const uint32_t kTouchDimensionY = 942;
+
+    touches[0].touchId = mTouchIdBase + (rawData[35] & 0x7f);
+    touches[0].surfaceId = 0;
+    touches[0].position[0] = NormalizeTouch(
+        ((rawData[37] & 0xf) << 8) | rawData[36], 0, (kTouchDimensionX - 1));
+    touches[0].position[1] =
+        NormalizeTouch(rawData[38] << 4 | ((rawData[37] & 0xf0) >> 4), 0,
+                       (kTouchDimensionY - 1));
+    touches[0].surfaceDimensions[0] = kTouchDimensionX;
+    touches[0].surfaceDimensions[1] = kTouchDimensionY;
+    touches[0].isSurfaceDimensionsValid = true;
+    mLastTouch0Id = rawData[35] & 0x7f;
+
+    touches[1].touchId = mTouchIdBase + (rawData[39] & 0x7f);
+    touches[1].surfaceId = 0;
+    touches[1].position[0] =
+        NormalizeTouch(((rawData[41] & 0xf) << 8) | rawData[40] + 1, 0,
+                       (kTouchDimensionX - 1));
+    touches[1].position[1] =
+        NormalizeTouch(rawData[42] << 4 | ((rawData[41] & 0xf0) >> 4), 0,
+                       (kTouchDimensionY - 1));
+    touches[1].surfaceDimensions[0] = kTouchDimensionX;
+    touches[1].surfaceDimensions[1] = kTouchDimensionY;
+    touches[1].isSurfaceDimensionsValid = true;
+    mLastTouch1Id = rawData[39] & 0x7f;
+
+    RefPtr<GamepadPlatformService> service =
+        GamepadPlatformService::GetParentService();
+    if (!service) {
+      return;
+    }
+
+    service->NewMultiTouchEvent(aIndex, 0, touches[0]);
+    service->NewMultiTouchEvent(aIndex, 1, touches[1]);
+  }
+
   virtual void RemapAxisMoveEvent(uint32_t aIndex, uint32_t aAxis,
                                   double aValue) const override {
     RefPtr<GamepadPlatformService> service =
@@ -443,6 +533,13 @@ class Dualshock4Remapper final : public GamepadRemapper {
     DUALSHOCK_BUTTON_TOUCHPAD = BUTTON_INDEX_COUNT,
     DUALSHOCK_BUTTON_COUNT
   };
+
+  static const uint32_t LIGHT_INDICATOR_COUNT = 1;
+  static const uint32_t TOUCH_EVENT_COUNT = 2;
+
+  unsigned long mLastTouch0Id = 0;
+  unsigned long mLastTouch1Id = 0;
+  unsigned long mTouchIdBase = 0;
 };
 
 class LogitechDInputRemapper final : public GamepadRemapper {

dom/gamepad/GamepadRemapping.h

@@ -7,6 +7,8 @@
 #ifndef mozilla_dom_GamepadRemapping_h_
 #define mozilla_dom_GamepadRemapping_h_
 
+#include "mozilla/dom/GamepadLightIndicator.h"
+
 namespace mozilla {
 namespace dom {
 
@@ -70,11 +72,19 @@ class GamepadRemapper {
  public:
   virtual uint32_t GetAxisCount() const = 0;
   virtual uint32_t GetButtonCount() const = 0;
+  virtual uint32_t GetLightIndicatorCount() const { return 0; }
+  virtual void GetLightIndicators(
+      nsTArray<GamepadLightIndicatorType>& aTypes) const {}
+  virtual uint32_t GetTouchEventCount() const { return 0; }
+  virtual void GetLightColorReport(uint8_t aRed, uint8_t aGreen, uint8_t aBlue,
+                                   std::vector<uint8_t>& aReport) const {}
+
   virtual void SetAxisCount(uint32_t aButtonCount) {}
   virtual void SetButtonCount(uint32_t aButtonCount) {}
   virtual GamepadMappingType GetMappingType() const {
     return GamepadMappingType::Standard;
   }
+  virtual void GetTouchData(uint32_t aIndex, void* aInput) {}
   virtual void RemapAxisMoveEvent(uint32_t aIndex, uint32_t aAxis,
                                   double aValue) const = 0;
   virtual void RemapButtonEvent(uint32_t aIndex, uint32_t aButton,

dom/gamepad/windows/WindowsGamepad.cpp

@@ -318,7 +318,9 @@ class WindowsGamepadService {
   void Shutdown();
   // Parse gamepad input from a WM_INPUT message.
   bool HandleRawInput(HRAWINPUT handle);
-
+  void SetLightIndicatorColor(uint32_t aControllerIdx, uint32_t aLightIndex,
+                              uint8_t aRed, uint8_t aGreen, uint8_t aBlue);
+  size_t WriteOutputReport(const std::vector<uint8_t>& aReport);
   static void XInputMessageLoopOnceCallback(nsITimer* aTimer, void* aClosure);
   static void DevicesChangeCallback(nsITimer* aTimer, void* aService);
 
@@ -342,6 +344,7 @@ class WindowsGamepadService {
   nsTArray<Gamepad> mGamepads;
 
   HIDLoader mHID;
+  nsAutoHandle mHidHandle;
   XInputLoader mXInput;
 
   nsCOMPtr<nsITimer> mDirectInputTimer;
@@ -434,7 +437,7 @@ bool WindowsGamepadService::ScanForXInputDevices() {
     gamepad.state = state;
     gamepad.id = service->AddGamepad(
         "xinput", GamepadMappingType::Standard, GamepadHand::_empty,
-        kStandardGamepadButtons, kStandardGamepadAxes,
+        kStandardGamepadButtons, kStandardGamepadAxes, 0, 0,
         0);  // TODO: Bug 680289, implement gamepad haptics for Windows.
     mGamepads.AppendElement(gamepad);
   }
@@ -625,18 +628,19 @@ bool WindowsGamepadService::GetRawGamepad(HANDLE handle) {
   wchar_t name[128] = {0};
   size = sizeof(name);
   nsTArray<char> gamepad_name;
-  const HANDLE hid_handle = CreateFile(
-      devname.Elements(), GENERIC_READ | GENERIC_WRITE,
-      FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL);
-  if (hid_handle) {
-    if (mHID.mHidD_GetProductString(hid_handle, &name, size)) {
+  // Creating this file with FILE_FLAG_OVERLAPPED to perform
+  // an asynchronous request in WriteOutputReport.
+  mHidHandle.own(CreateFile(devname.Elements(), GENERIC_READ | GENERIC_WRITE,
+                            FILE_SHARE_READ | FILE_SHARE_WRITE, nullptr,
+                            OPEN_EXISTING, FILE_FLAG_OVERLAPPED, nullptr));
+  if (mHidHandle != INVALID_HANDLE_VALUE) {
+    if (mHID.mHidD_GetProductString(mHidHandle, &name, size)) {
       int bytes = WideCharToMultiByte(CP_UTF8, 0, name, -1, nullptr, 0, nullptr,
                                       nullptr);
       gamepad_name.SetLength(bytes);
       WideCharToMultiByte(CP_UTF8, 0, name, -1, gamepad_name.Elements(), bytes,
                           nullptr, nullptr);
     }
-    CloseHandle(hid_handle);
   }
   if (gamepad_name.Length() == 0 || !gamepad_name[0]) {
     const char kUnknown[] = "Unknown Gamepad";
@@ -717,9 +721,21 @@ bool WindowsGamepadService::GetRawGamepad(HANDLE handle) {
   }
 
   gamepad.remapper = remapper.forget();
+  // TODO: Bug 680289, implement gamepad haptics for Windows.
   gamepad.id = service->AddGamepad(
       gamepad_id, gamepad.remapper->GetMappingType(), GamepadHand::_empty,
-      gamepad.remapper->GetButtonCount(), gamepad.remapper->GetAxisCount(), 0);
+      gamepad.remapper->GetButtonCount(), gamepad.remapper->GetAxisCount(), 0,
+      gamepad.remapper->GetLightIndicatorCount(),
+      gamepad.remapper->GetTouchEventCount());
+
+  nsTArray<GamepadLightIndicatorType> lightTypes;
+  gamepad.remapper->GetLightIndicators(lightTypes);
+  for (uint32_t i = 0; i < lightTypes.Length(); ++i) {
+    if (lightTypes[i] != GamepadLightIndicator::DefaultType()) {
+      service->NewLightIndicatorTypeEvent(gamepad.id, i, lightTypes[i]);
+    }
+  }
+
   mGamepads.AppendElement(gamepad);
   return true;
 }
@@ -833,9 +849,81 @@ bool WindowsGamepadService::HandleRawInput(HRAWINPUT handle) {
     }
   }
 
+  BYTE* rawData = raw->data.hid.bRawData;
+  gamepad->remapper->GetTouchData(gamepad->id, rawData);
+
   return true;
 }
 
+void WindowsGamepadService::SetLightIndicatorColor(uint32_t aControllerIdx,
+                                                   uint32_t aLightColorIndex,
+                                                   uint8_t aRed, uint8_t aGreen,
+                                                   uint8_t aBlue) {
+  // We get aControllerIdx from GamepadPlatformService::AddGamepad(),
+  // It begins from 1 and is stored at Gamepad.id.
+  const Gamepad* gamepad = nullptr;
+  for (const auto& pad : mGamepads) {
+    if (pad.id == aControllerIdx) {
+      gamepad = &pad;
+      break;
+    }
+  }
+  if (!gamepad) {
+    MOZ_ASSERT(false);
+    return;
+  }
+
+  RefPtr<GamepadRemapper> remapper = gamepad->remapper;
+  if (!remapper || remapper->GetLightIndicatorCount() <= aLightColorIndex) {
+    MOZ_ASSERT(false);
+    return;
+  }
+
+  std::vector<uint8_t> report;
+  remapper->GetLightColorReport(aRed, aGreen, aBlue, report);
+  WriteOutputReport(report);
+}
+
+size_t WindowsGamepadService::WriteOutputReport(
+    const std::vector<uint8_t>& aReport) {
+  DCHECK(static_cast<const void*>(aReport.data()));
+  DCHECK_GE(aReport.size(), 1U);
+  if (!mHidHandle) return 0;
+
+  nsAutoHandle eventHandle(::CreateEvent(nullptr, FALSE, FALSE, nullptr));
+  OVERLAPPED overlapped = {0};
+  overlapped.hEvent = eventHandle;
+
+  // Doing an asynchronous write to allows us to time out
+  // if the write takes too long.
+  DWORD bytesWritten = 0;
+  BOOL writeSuccess =
+      ::WriteFile(mHidHandle, static_cast<const void*>(aReport.data()),
+                  aReport.size(), &bytesWritten, &overlapped);
+  if (!writeSuccess) {
+    DWORD error = ::GetLastError();
+    if (error == ERROR_IO_PENDING) {
+      // Wait for the write to complete. This causes WriteOutputReport to behave
+      // synchronously but with a timeout.
+      DWORD wait_object = ::WaitForSingleObject(overlapped.hEvent, 100);
+      if (wait_object == WAIT_OBJECT_0) {
+        if (!::GetOverlappedResult(mHidHandle, &overlapped, &bytesWritten,
+                                   TRUE)) {
+          return 0;
+        }
+      } else {
+        // Wait failed, or the timeout was exceeded before the write completed.
+        // Cancel the write request.
+        if (::CancelIo(mHidHandle)) {
+          wait_object = ::WaitForSingleObject(overlapped.hEvent, INFINITE);
+          MOZ_ASSERT(wait_object == WAIT_OBJECT_0);
+        }
+      }
+    }
+  }
+  return writeSuccess ? bytesWritten : 0;
+}
+
 void WindowsGamepadService::Startup() { ScanForDevices(); }
 
 void WindowsGamepadService::Shutdown() { Cleanup(); }
@@ -851,6 +939,7 @@ void WindowsGamepadService::Cleanup() {
   if (mDeviceChangeTimer) {
     mDeviceChangeTimer->Cancel();
   }
+
   mGamepads.Clear();
 }
 
@@ -1001,5 +1090,16 @@ void StopGamepadMonitoring() {
   gMonitorThread = nullptr;
 }
 
+void SetGamepadLightIndicatorColor(uint32_t aControllerIdx,
+                                   uint32_t aLightColorIndex, uint8_t aRed,
+                                   uint8_t aGreen, uint8_t aBlue) {
+  MOZ_ASSERT(gService);
+  if (!gService) {
+    return;
+  }
+  gService->SetLightIndicatorColor(aControllerIdx, aLightColorIndex, aRed,
+                                   aGreen, aBlue);
+}
+
 }  // namespace dom
 }  // namespace mozilla