1// Copyright (c) 2012 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "content/browser/gamepad/gamepad_platform_data_fetcher_linux.h"
6
7#include <fcntl.h>
8#include <libudev.h>
9#include <linux/joystick.h>
10#include <string.h>
11#include <sys/stat.h>
12#include <sys/types.h>
13#include <unistd.h>
14
15#include "base/debug/trace_event.h"
16#include "base/message_loop/message_loop.h"
17#include "base/posix/eintr_wrapper.h"
18#include "base/strings/string_number_conversions.h"
19#include "base/strings/string_util.h"
20#include "base/strings/stringprintf.h"
21#include "base/strings/utf_string_conversions.h"
22#include "content/browser/udev_linux.h"
23
24namespace {
25
26const char kInputSubsystem[] = "input";
27const char kUsbSubsystem[] = "usb";
28const char kUsbDeviceType[] = "usb_device";
29const float kMaxLinuxAxisValue = 32767.0;
30
31void CloseFileDescriptorIfValid(int fd) {
32  if (fd >= 0)
33    close(fd);
34}
35
36bool IsGamepad(udev_device* dev, int* index, std::string* path) {
37  if (!udev_device_get_property_value(dev, "ID_INPUT_JOYSTICK"))
38    return false;
39
40  const char* node_path = udev_device_get_devnode(dev);
41  if (!node_path)
42    return false;
43
44  static const char kJoystickRoot[] = "/dev/input/js";
45  bool is_gamepad = StartsWithASCII(node_path, kJoystickRoot, true);
46  if (!is_gamepad)
47    return false;
48
49  int tmp_idx = -1;
50  const int base_len = sizeof(kJoystickRoot) - 1;
51  base::StringPiece str(&node_path[base_len], strlen(node_path) - base_len);
52  if (!base::StringToInt(str, &tmp_idx))
53    return false;
54  if (tmp_idx < 0 ||
55      tmp_idx >= static_cast<int>(blink::WebGamepads::itemsLengthCap)) {
56    return false;
57  }
58  *index = tmp_idx;
59  *path = node_path;
60  return true;
61}
62
63}  // namespace
64
65namespace content {
66
67using blink::WebGamepad;
68using blink::WebGamepads;
69
70GamepadPlatformDataFetcherLinux::GamepadPlatformDataFetcherLinux() {
71  for (size_t i = 0; i < arraysize(device_fds_); ++i)
72    device_fds_[i] = -1;
73  memset(mappers_, 0, sizeof(mappers_));
74
75  std::vector<UdevLinux::UdevMonitorFilter> filters;
76  filters.push_back(UdevLinux::UdevMonitorFilter(kInputSubsystem, NULL));
77  udev_.reset(
78      new UdevLinux(filters,
79                    base::Bind(&GamepadPlatformDataFetcherLinux::RefreshDevice,
80                               base::Unretained(this))));
81
82  EnumerateDevices();
83}
84
85GamepadPlatformDataFetcherLinux::~GamepadPlatformDataFetcherLinux() {
86  for (size_t i = 0; i < WebGamepads::itemsLengthCap; ++i)
87    CloseFileDescriptorIfValid(device_fds_[i]);
88}
89
90void GamepadPlatformDataFetcherLinux::GetGamepadData(WebGamepads* pads, bool) {
91  TRACE_EVENT0("GAMEPAD", "GetGamepadData");
92
93  data_.length = WebGamepads::itemsLengthCap;
94
95  // Update our internal state.
96  for (size_t i = 0; i < WebGamepads::itemsLengthCap; ++i) {
97    if (device_fds_[i] >= 0) {
98      ReadDeviceData(i);
99    }
100  }
101
102  // Copy to the current state to the output buffer, using the mapping
103  // function, if there is one available.
104  pads->length = data_.length;
105  for (size_t i = 0; i < WebGamepads::itemsLengthCap; ++i) {
106    if (mappers_[i])
107      mappers_[i](data_.items[i], &pads->items[i]);
108    else
109      pads->items[i] = data_.items[i];
110  }
111}
112
113// Used during enumeration, and monitor notifications.
114void GamepadPlatformDataFetcherLinux::RefreshDevice(udev_device* dev) {
115  int index;
116  std::string node_path;
117  if (IsGamepad(dev, &index, &node_path)) {
118    int& device_fd = device_fds_[index];
119    WebGamepad& pad = data_.items[index];
120    GamepadStandardMappingFunction& mapper = mappers_[index];
121
122    CloseFileDescriptorIfValid(device_fd);
123
124    // The device pointed to by dev contains information about the logical
125    // joystick device. In order to get the information about the physical
126    // hardware, get the parent device that is also in the "input" subsystem.
127    // This function should just walk up the tree one level.
128    dev = udev_device_get_parent_with_subsystem_devtype(
129        dev,
130        kInputSubsystem,
131        NULL);
132    if (!dev) {
133      // Unable to get device information, don't use this device.
134      device_fd = -1;
135      pad.connected = false;
136      return;
137    }
138
139    device_fd = HANDLE_EINTR(open(node_path.c_str(), O_RDONLY | O_NONBLOCK));
140    if (device_fd < 0) {
141      // Unable to open device, don't use.
142      pad.connected = false;
143      return;
144    }
145
146    const char* vendor_id = udev_device_get_sysattr_value(dev, "id/vendor");
147    const char* product_id = udev_device_get_sysattr_value(dev, "id/product");
148    mapper = GetGamepadStandardMappingFunction(vendor_id, product_id);
149
150    // Driver returns utf-8 strings here, so combine in utf-8 first and
151    // convert to WebUChar later once we've picked an id string.
152    const char* name = udev_device_get_sysattr_value(dev, "name");
153    std::string name_string = base::StringPrintf("%s", name);
154
155    // In many cases the information the input subsystem contains isn't
156    // as good as the information that the device bus has, walk up further
157    // to the subsystem/device type "usb"/"usb_device" and if this device
158    // has the same vendor/product id, prefer the description from that.
159    struct udev_device *usb_dev = udev_device_get_parent_with_subsystem_devtype(
160        dev,
161        kUsbSubsystem,
162        kUsbDeviceType);
163    if (usb_dev) {
164      const char* usb_vendor_id =
165          udev_device_get_sysattr_value(usb_dev, "idVendor");
166      const char* usb_product_id =
167          udev_device_get_sysattr_value(usb_dev, "idProduct");
168
169      if (strcmp(vendor_id, usb_vendor_id) == 0 &&
170          strcmp(product_id, usb_product_id) == 0) {
171        const char* manufacturer =
172            udev_device_get_sysattr_value(usb_dev, "manufacturer");
173        const char* product = udev_device_get_sysattr_value(usb_dev, "product");
174
175        // Replace the previous name string with one containing the better
176        // information, again driver returns utf-8 strings here so combine
177        // in utf-8 for conversion to WebUChar below.
178        name_string = base::StringPrintf("%s %s", manufacturer, product);
179      }
180    }
181
182    // Append the vendor and product information then convert the utf-8
183    // id string to WebUChar.
184    std::string id = name_string + base::StringPrintf(
185        " (%sVendor: %s Product: %s)",
186        mapper ? "STANDARD GAMEPAD " : "",
187        vendor_id,
188        product_id);
189    base::TruncateUTF8ToByteSize(id, WebGamepad::idLengthCap - 1, &id);
190    base::string16 tmp16 = base::UTF8ToUTF16(id);
191    memset(pad.id, 0, sizeof(pad.id));
192    tmp16.copy(pad.id, arraysize(pad.id) - 1);
193
194    if (mapper) {
195      std::string mapping = "standard";
196      base::TruncateUTF8ToByteSize(mapping, WebGamepad::mappingLengthCap - 1,
197          &mapping);
198      tmp16 = base::UTF8ToUTF16(mapping);
199      memset(pad.mapping, 0, sizeof(pad.mapping));
200      tmp16.copy(pad.mapping, arraysize(pad.mapping) - 1);
201    } else {
202      pad.mapping[0] = 0;
203    }
204
205    pad.connected = true;
206  }
207}
208
209void GamepadPlatformDataFetcherLinux::EnumerateDevices() {
210  udev_enumerate* enumerate = udev_enumerate_new(udev_->udev_handle());
211  if (!enumerate)
212    return;
213  int ret = udev_enumerate_add_match_subsystem(enumerate, kInputSubsystem);
214  if (ret != 0)
215    return;
216  ret = udev_enumerate_scan_devices(enumerate);
217  if (ret != 0)
218    return;
219
220  udev_list_entry* devices = udev_enumerate_get_list_entry(enumerate);
221  for (udev_list_entry* dev_list_entry = devices;
222       dev_list_entry != NULL;
223       dev_list_entry = udev_list_entry_get_next(dev_list_entry)) {
224    // Get the filename of the /sys entry for the device and create a
225    // udev_device object (dev) representing it
226    const char* path = udev_list_entry_get_name(dev_list_entry);
227    udev_device* dev = udev_device_new_from_syspath(udev_->udev_handle(), path);
228    if (!dev)
229      continue;
230    RefreshDevice(dev);
231    udev_device_unref(dev);
232  }
233  // Free the enumerator object
234  udev_enumerate_unref(enumerate);
235}
236
237void GamepadPlatformDataFetcherLinux::ReadDeviceData(size_t index) {
238  // Linker does not like CHECK_LT(index, WebGamepads::itemsLengthCap). =/
239  if (index >= WebGamepads::itemsLengthCap) {
240    CHECK(false);
241    return;
242  }
243
244  const int& fd = device_fds_[index];
245  WebGamepad& pad = data_.items[index];
246  DCHECK_GE(fd, 0);
247
248  js_event event;
249  while (HANDLE_EINTR(read(fd, &event, sizeof(struct js_event))) > 0) {
250    size_t item = event.number;
251    if (event.type & JS_EVENT_AXIS) {
252      if (item >= WebGamepad::axesLengthCap)
253        continue;
254      pad.axes[item] = event.value / kMaxLinuxAxisValue;
255      if (item >= pad.axesLength)
256        pad.axesLength = item + 1;
257    } else if (event.type & JS_EVENT_BUTTON) {
258      if (item >= WebGamepad::buttonsLengthCap)
259        continue;
260      pad.buttons[item].pressed = event.value;
261      pad.buttons[item].value = event.value ? 1.0 : 0.0;
262      if (item >= pad.buttonsLength)
263        pad.buttonsLength = item + 1;
264    }
265    pad.timestamp = event.time;
266  }
267}
268
269}  // namespace content
270