xbmc/platform/android/peripherals/PeripheralBusAndroid.cpp

   1 /*
   2  *  Copyright (C) 2016-2018 Team Kodi
   3  *  This file is part of Kodi - https://kodi.tv
   4  *
   5  *  SPDX-License-Identifier: GPL-2.0-or-later
   6  *  See LICENSES/README.md for more information.
   7  */
   8
   9 #include "PeripheralBusAndroid.h"
  10
  11 #include "AndroidJoystickTranslator.h"
  12 #include "input/joysticks/JoystickTypes.h"
  13 #include "peripherals/addons/PeripheralAddonTranslator.h"
  14 #include "peripherals/devices/PeripheralJoystick.h"
  15 #include "utils/StringUtils.h"
  16 #include "utils/log.h"
  17
  18 #include "platform/android/activity/XBMCApp.h"
  19 #include "platform/android/peripherals/AndroidJoystickState.h"
  20
  21 #include <algorithm>
  22 #include <mutex>
  23 #include <numeric>
  24
  25 #include <android/input.h>
  26 #include <android/keycodes.h>
  27 #include <androidjni/View.h>
  28
  29 using namespace KODI;
  30 using namespace PERIPHERALS;
  31
  32 #define JOYSTICK_PROVIDER_ANDROID "android"
  33
  34 // Set this to the final key code in android/keycodes.h
  35 const unsigned int KEY_CODE_FINAL = AKEYCODE_DEMO_APP_4;
  36
  37 static const std::string DeviceLocationPrefix = "android/inputdevice/";
  38
  39 CPeripheralBusAndroid::CPeripheralBusAndroid(CPeripherals& manager)
  40   : CPeripheralBus("PeripBusAndroid", manager, PERIPHERAL_BUS_ANDROID)
  41 {
  42   // we don't need polling as we get notified through the IInputDeviceCallbacks interface
  43   m_bNeedsPolling = false;
  44
  45   // register for input device callbacks
  46   CXBMCApp::Get().RegisterInputDeviceCallbacks(this);
  47
  48   // register for input device events
  49   CXBMCApp::Get().RegisterInputDeviceEventHandler(this);
  50
  51   // get all currently connected input devices
  52   m_scanResults = GetInputDevices();
  53 }
  54
  55 CPeripheralBusAndroid::~CPeripheralBusAndroid()
  56 {
  57   // unregister from input device events
  58   CXBMCApp::Get().UnregisterInputDeviceEventHandler();
  59
  60   // unregister from input device callbacks
  61   CXBMCApp::Get().UnregisterInputDeviceCallbacks();
  62 }
  63
  64 bool CPeripheralBusAndroid::InitializeProperties(CPeripheral& peripheral)
  65 {
  66   if (!CPeripheralBus::InitializeProperties(peripheral))
  67     return false;
  68
  69   if (peripheral.Type() != PERIPHERAL_JOYSTICK)
  70   {
  71     CLog::Log(LOGWARNING, "CPeripheralBusAndroid: invalid peripheral type: {}",
  72               PeripheralTypeTranslator::TypeToString(peripheral.Type()));
  73     return false;
  74   }
  75
  76   int deviceId;
  77   if (!GetDeviceId(peripheral.Location(), deviceId))
  78   {
  79     CLog::Log(LOGWARNING,
  80               "CPeripheralBusAndroid: failed to initialize properties for peripheral \"{}\"",
  81               peripheral.Location());
  82     return false;
  83   }
  84
  85   const CJNIViewInputDevice device = CXBMCApp::GetInputDevice(deviceId);
  86   if (!device)
  87   {
  88     CLog::Log(LOGWARNING, "CPeripheralBusAndroid: failed to get input device with ID {}", deviceId);
  89     return false;
  90   }
  91
  92   CPeripheralJoystick& joystick = static_cast<CPeripheralJoystick&>(peripheral);
  93   if (device.getControllerNumber() > 0)
  94     joystick.SetRequestedPort(device.getControllerNumber() - 1);
  95   joystick.SetProvider(JOYSTICK_PROVIDER_ANDROID);
  96
  97   CLog::Log(LOGDEBUG, "CPeripheralBusAndroid: Initializing device {} \"{}\"", deviceId,
  98             peripheral.DeviceName());
  99
 100   // prepare the joystick state
 101   CAndroidJoystickState state;
 102   if (!state.Initialize(device))
 103   {
 104     CLog::Log(
 105         LOGWARNING,
 106         "CPeripheralBusAndroid: failed to initialize the state for input device \"{}\" with ID {}",
 107         joystick.DeviceName(), deviceId);
 108     return false;
 109   }
 110
 111   // fill in the number of buttons, hats and axes
 112   joystick.SetButtonCount(state.GetButtonCount());
 113   joystick.SetAxisCount(state.GetAxisCount());
 114
 115   std::unique_lock<CCriticalSection> lock(m_critSectionStates);
 116
 117   // remember the joystick state
 118   m_joystickStates.insert(std::make_pair(deviceId, std::move(state)));
 119
 120   CLog::Log(LOGDEBUG, "CPeripheralBusAndroid: Device has {} buttons and {} axes",
 121             joystick.ButtonCount(), joystick.AxisCount());
 122
 123   return true;
 124 }
 125
 126 bool CPeripheralBusAndroid::InitializeButtonMap(const CPeripheral& peripheral,
 127                                                 JOYSTICK::IButtonMap& buttonMap) const
 128 {
 129   int deviceId;
 130   if (!GetDeviceId(peripheral.Location(), deviceId))
 131   {
 132     CLog::Log(LOGWARNING,
 133               "CPeripheralBusAndroid: failed to initialize buttonmap due to unknown device ID for "
 134               "peripheral \"{}\"",
 135               peripheral.Location());
 136     return false;
 137   }
 138
 139   std::unique_lock<CCriticalSection> lock(m_critSectionStates);
 140
 141   // get the joystick state
 142   auto it = m_joystickStates.find(deviceId);
 143   if (it == m_joystickStates.end())
 144   {
 145     CLog::Log(LOGWARNING,
 146               "CPeripheralBusAndroid: joystick with device ID {} not found for peripheral \"{}\"",
 147               deviceId, peripheral.Location());
 148     return false;
 149   }
 150
 151   const CAndroidJoystickState& joystick = it->second;
 152   if (joystick.GetButtonCount() == 0 && joystick.GetAxisCount() == 0)
 153   {
 154     CLog::Log(LOGDEBUG,
 155               "CPeripheralBusAndroid: joystick has no buttons or axes for peripheral \"{}\"",
 156               peripheral.Location());
 157     return false;
 158   }
 159
 160   if (!joystick.InitializeButtonMap(buttonMap))
 161   {
 162     CLog::Log(
 163         LOGDEBUG,
 164         "CPeripheralBusAndroid: failed to initialize joystick buttonmap for peripheral \"{}\"",
 165         peripheral.Location());
 166     return false;
 167   }
 168
 169   return true;
 170 }
 171
 172 std::string CPeripheralBusAndroid::GetAppearance(const CPeripheral& peripheral) const
 173 {
 174   int deviceId;
 175   if (!GetDeviceId(peripheral.Location(), deviceId))
 176     return "";
 177
 178   std::unique_lock<CCriticalSection> lock(m_critSectionStates);
 179
 180   auto it = m_joystickStates.find(deviceId);
 181   if (it == m_joystickStates.end())
 182     return "";
 183
 184   const CAndroidJoystickState& joystick = it->second;
 185   return joystick.GetAppearance();
 186 }
 187
 188 void CPeripheralBusAndroid::Initialise(void)
 189 {
 190   CPeripheralBus::Initialise();
 191   TriggerDeviceScan();
 192 }
 193
 194 void CPeripheralBusAndroid::ProcessEvents()
 195 {
 196   std::vector<kodi::addon::PeripheralEvent> events;
 197   {
 198     std::unique_lock<CCriticalSection> lock(m_critSectionStates);
 199     for (auto& joystickState : m_joystickStates)
 200       joystickState.second.GetEvents(events);
 201   }
 202
 203   for (const auto& event : events)
 204   {
 205     PeripheralPtr device = GetPeripheral(GetDeviceLocation(event.PeripheralIndex()));
 206     if (!device || device->Type() != PERIPHERAL_JOYSTICK)
 207       continue;
 208
 209     CPeripheralJoystick* joystick = static_cast<CPeripheralJoystick*>(device.get());
 210     switch (event.Type())
 211     {
 212       case PERIPHERAL_EVENT_TYPE_DRIVER_BUTTON:
 213       {
 214         const bool bPressed = (event.ButtonState() == JOYSTICK_STATE_BUTTON_PRESSED);
 215         joystick->OnButtonMotion(event.DriverIndex(), bPressed);
 216         break;
 217       }
 218       case PERIPHERAL_EVENT_TYPE_DRIVER_AXIS:
 219       {
 220         joystick->OnAxisMotion(event.DriverIndex(), event.AxisState());
 221         break;
 222       }
 223       default:
 224         break;
 225     }
 226   }
 227
 228   {
 229     std::unique_lock<CCriticalSection> lock(m_critSectionStates);
 230     for (const auto& joystickState : m_joystickStates)
 231     {
 232       PeripheralPtr device = GetPeripheral(GetDeviceLocation(joystickState.second.GetDeviceId()));
 233       if (!device || device->Type() != PERIPHERAL_JOYSTICK)
 234         continue;
 235
 236       static_cast<CPeripheralJoystick*>(device.get())->OnInputFrame();
 237     }
 238   }
 239 }
 240
 241 void CPeripheralBusAndroid::OnInputDeviceAdded(int deviceId)
 242 {
 243   const std::string deviceLocation = GetDeviceLocation(deviceId);
 244   {
 245     std::unique_lock<CCriticalSection> lock(m_critSectionResults);
 246     // add the device to the cached result list
 247     const auto& it = std::find_if(m_scanResults.m_results.cbegin(), m_scanResults.m_results.cend(),
 248                                   [&deviceLocation](const PeripheralScanResult& scanResult)
 249                                   { return scanResult.m_strLocation == deviceLocation; });
 250
 251     if (it != m_scanResults.m_results.cend())
 252     {
 253       CLog::Log(LOGINFO,
 254                 "CPeripheralBusAndroid: ignoring added input device with ID {} because we already "
 255                 "know it",
 256                 deviceId);
 257       return;
 258     }
 259
 260     const CJNIViewInputDevice device = CXBMCApp::GetInputDevice(deviceId);
 261     if (!device)
 262     {
 263       CLog::Log(LOGWARNING,
 264                 "CPeripheralBusAndroid: failed to add input device with ID {} because it couldn't "
 265                 "be found",
 266                 deviceId);
 267       return;
 268     }
 269
 270     CLog::Log(LOGDEBUG, "CPeripheralBusAndroid: Device added:");
 271     LogInputDevice(device);
 272
 273     PeripheralScanResult result;
 274     if (!ConvertToPeripheralScanResult(device, result))
 275       return;
 276     m_scanResults.m_results.emplace_back(std::move(result));
 277   }
 278
 279   CLog::Log(LOGDEBUG, "CPeripheralBusAndroid: input device with ID {} added", deviceId);
 280   OnDeviceAdded(deviceLocation);
 281 }
 282
 283 void CPeripheralBusAndroid::OnInputDeviceChanged(int deviceId)
 284 {
 285   bool changed = false;
 286   const std::string deviceLocation = GetDeviceLocation(deviceId);
 287   {
 288     std::unique_lock<CCriticalSection> lock(m_critSectionResults);
 289     // change the device in the cached result list
 290     for (auto result = m_scanResults.m_results.begin(); result != m_scanResults.m_results.end();
 291          ++result)
 292     {
 293       if (result->m_strLocation == deviceLocation)
 294       {
 295         const CJNIViewInputDevice device = CXBMCApp::GetInputDevice(deviceId);
 296         if (!device)
 297         {
 298           CLog::Log(LOGWARNING,
 299                     "CPeripheralBusAndroid: failed to update input device \"{}\" with ID {} "
 300                     "because it couldn't be found",
 301                     result->m_strDeviceName, deviceId);
 302           return;
 303         }
 304
 305         if (!ConvertToPeripheralScanResult(device, *result))
 306           return;
 307
 308         CLog::Log(LOGINFO, "CPeripheralBusAndroid: input device \"{}\" with ID {} updated",
 309                   result->m_strDeviceName, deviceId);
 310         changed = true;
 311         break;
 312       }
 313     }
 314   }
 315
 316   if (changed)
 317     OnDeviceChanged(deviceLocation);
 318   else
 319     CLog::Log(LOGWARNING,
 320               "CPeripheralBusAndroid: failed to update input device with ID {} because it couldn't "
 321               "be found",
 322               deviceId);
 323 }
 324
 325 void CPeripheralBusAndroid::OnInputDeviceRemoved(int deviceId)
 326 {
 327   bool removed = false;
 328   const std::string deviceLocation = GetDeviceLocation(deviceId);
 329   {
 330     std::unique_lock<CCriticalSection> lock(m_critSectionResults);
 331     // remove the device from the cached result list
 332     for (auto result = m_scanResults.m_results.begin(); result != m_scanResults.m_results.end();
 333          ++result)
 334     {
 335       if (result->m_strLocation == deviceLocation)
 336       {
 337         CLog::Log(LOGINFO, "CPeripheralBusAndroid: input device \"{}\" with ID {} removed",
 338                   result->m_strDeviceName, deviceId);
 339         m_scanResults.m_results.erase(result);
 340         removed = true;
 341         break;
 342       }
 343     }
 344   }
 345
 346   if (removed)
 347   {
 348     {
 349       std::unique_lock<CCriticalSection> lock(m_critSectionStates);
 350       m_joystickStates.erase(deviceId);
 351     }
 352
 353     OnDeviceRemoved(deviceLocation);
 354   }
 355   else
 356     CLog::Log(LOGWARNING,
 357               "CPeripheralBusAndroid: failed to remove input device with ID {} because it couldn't "
 358               "be found",
 359               deviceId);
 360 }
 361
 362 bool CPeripheralBusAndroid::OnInputDeviceEvent(const AInputEvent* event)
 363 {
 364   if (event == nullptr)
 365     return false;
 366
 367   std::unique_lock<CCriticalSection> lock(m_critSectionStates);
 368   // get the id of the input device which generated the event
 369   int32_t deviceId = AInputEvent_getDeviceId(event);
 370
 371   // find the matching joystick state
 372   auto joystickState = m_joystickStates.find(deviceId);
 373   if (joystickState == m_joystickStates.end())
 374   {
 375     CLog::Log(LOGDEBUG,
 376               "CPeripheralBusAndroid: ignoring input event for non-joystick device with ID {}",
 377               deviceId);
 378     return false;
 379   }
 380
 381   return joystickState->second.ProcessEvent(event);
 382 }
 383
 384 bool CPeripheralBusAndroid::PerformDeviceScan(PeripheralScanResults& results)
 385 {
 386   std::unique_lock<CCriticalSection> lock(m_critSectionResults);
 387   results = m_scanResults;
 388
 389   return true;
 390 }
 391
 392 PeripheralScanResults CPeripheralBusAndroid::GetInputDevices()
 393 {
 394   CLog::Log(LOGINFO, "CPeripheralBusAndroid: scanning for input devices...");
 395
 396   PeripheralScanResults results;
 397   std::vector<int> deviceIds = CXBMCApp::GetInputDeviceIds();
 398
 399   for (const auto& deviceId : deviceIds)
 400   {
 401     const CJNIViewInputDevice device = CXBMCApp::GetInputDevice(deviceId);
 402     if (!device)
 403     {
 404       CLog::Log(LOGWARNING, "CPeripheralBusAndroid: no input device with ID {} found", deviceId);
 405       continue;
 406     }
 407
 408     CLog::Log(LOGDEBUG, "CPeripheralBusAndroid: Device discovered:");
 409     LogInputDevice(device);
 410
 411     PeripheralScanResult result;
 412     if (!ConvertToPeripheralScanResult(device, result))
 413       continue;
 414
 415     CLog::Log(LOGINFO, "CPeripheralBusAndroid: added input device");
 416     results.m_results.emplace_back(std::move(result));
 417   }
 418
 419   return results;
 420 }
 421
 422 std::string CPeripheralBusAndroid::GetDeviceLocation(int deviceId)
 423 {
 424   return StringUtils::Format("{}{}", DeviceLocationPrefix, deviceId);
 425 }
 426
 427 bool CPeripheralBusAndroid::GetDeviceId(const std::string& deviceLocation, int& deviceId)
 428 {
 429   if (deviceLocation.empty() || !StringUtils::StartsWith(deviceLocation, DeviceLocationPrefix) ||
 430       deviceLocation.size() <= DeviceLocationPrefix.size())
 431     return false;
 432
 433   std::string strDeviceId = deviceLocation.substr(DeviceLocationPrefix.size());
 434   if (!StringUtils::IsNaturalNumber(strDeviceId))
 435     return false;
 436
 437   deviceId = static_cast<int>(strtol(strDeviceId.c_str(), nullptr, 10));
 438   return true;
 439 }
 440
 441 bool CPeripheralBusAndroid::ConvertToPeripheralScanResult(
 442     const CJNIViewInputDevice& inputDevice, PeripheralScanResult& peripheralScanResult)
 443 {
 444   if (inputDevice.isVirtual())
 445   {
 446     CLog::Log(LOGDEBUG, "CPeripheralBusAndroid: ignoring virtual input device");
 447     return false;
 448   }
 449
 450   if (!inputDevice.supportsSource(CJNIViewInputDevice::SOURCE_JOYSTICK) &&
 451       !inputDevice.supportsSource(CJNIViewInputDevice::SOURCE_GAMEPAD))
 452   {
 453     CLog::Log(LOGDEBUG, "CPeripheralBusAndroid: ignoring non-joystick device");
 454     return false;
 455   }
 456
 457   peripheralScanResult.m_type = PERIPHERAL_JOYSTICK;
 458   peripheralScanResult.m_strLocation = GetDeviceLocation(inputDevice.getId());
 459   peripheralScanResult.m_iVendorId = inputDevice.getVendorId();
 460   peripheralScanResult.m_iProductId = inputDevice.getProductId();
 461   peripheralScanResult.m_mappedType = PERIPHERAL_JOYSTICK;
 462   peripheralScanResult.m_strDeviceName = inputDevice.getName();
 463   peripheralScanResult.m_busType = PERIPHERAL_BUS_ANDROID;
 464   peripheralScanResult.m_mappedBusType = PERIPHERAL_BUS_ANDROID;
 465   peripheralScanResult.m_iSequence = 0;
 466
 467   return true;
 468 }
 469
 470 void CPeripheralBusAndroid::LogInputDevice(const CJNIViewInputDevice& device)
 471 {
 472   // Log device properties
 473   CLog::Log(LOGDEBUG, "  Name: \"{}\"", device.getName());
 474   CLog::Log(LOGDEBUG, "    ID: {}", device.getId());
 475   CLog::Log(LOGDEBUG, "    Controller number: {}", device.getControllerNumber());
 476   std::string descriptor = device.getDescriptor();
 477   if (descriptor.size() > 14)
 478     CLog::Log(LOGDEBUG, "    Descriptor: \"{}...\"", descriptor.substr(0, 14));
 479   else
 480     CLog::Log(LOGDEBUG, "    Descriptor: \"{}\"", descriptor);
 481   CLog::Log(LOGDEBUG, "    Product ID: {:04X}", device.getProductId());
 482   CLog::Log(LOGDEBUG, "    Vendor ID: {:04X}", device.getVendorId());
 483   CLog::Log(LOGDEBUG, "    Has microphone: {}", device.hasMicrophone() ? "true" : "false");
 484   CLog::Log(LOGDEBUG, "    Is virtual: {}", device.isVirtual() ? "true" : "false");
 485
 486   // Log device sources
 487   CLog::Log(LOGDEBUG, "    Source flags: {:#08x}", device.getSources());
 488   for (const auto& source : GetInputSources())
 489   {
 490     if (device.supportsSource(source.first))
 491       CLog::Log(LOGDEBUG, "    Has source: {} ({:#08x})", source.second, source.first);
 492   }
 493
 494   // Log device keys
 495   std::vector<int> keys(KEY_CODE_FINAL);
 496   std::iota(keys.begin(), keys.end(), 1);
 497
 498   auto results = device.hasKeys(keys);
 499
 500   if (results.size() != keys.size())
 501   {
 502     CLog::Log(LOGERROR, "Failed to get key status for {} keys", keys.size());
 503   }
 504   else
 505   {
 506     for (unsigned int i = 0; i < keys.size(); i++)
 507     {
 508       if (results[i])
 509         CLog::Log(LOGDEBUG, "    Has key: {} ({})",
 510                   CAndroidJoystickTranslator::TranslateKeyCode(keys[i]), keys[i]);
 511     }
 512   }
 513
 514   // Log analog axes
 515   const CJNIList<CJNIViewInputDeviceMotionRange> motionRanges = device.getMotionRanges();
 516   for (int index = 0; index < motionRanges.size(); ++index)
 517   {
 518     const CJNIViewInputDeviceMotionRange motionRange = motionRanges.get(index);
 519
 520     int axisId = motionRange.getAxis();
 521     CLog::Log(LOGDEBUG, "    Has axis: {} ({})", CAndroidJoystickTranslator::TranslateAxis(axisId),
 522               axisId);
 523     CLog::Log(LOGDEBUG, "      Endpoints: [{:f}, {:f}]", motionRange.getMin(),
 524               motionRange.getMax());
 525     CLog::Log(LOGDEBUG, "      Center: {:f}", motionRange.getFlat());
 526     CLog::Log(LOGDEBUG, "      Fuzz: {:f}", motionRange.getFuzz());
 527   }
 528 }
 529
 530 std::vector<std::pair<int, const char*>> CPeripheralBusAndroid::GetInputSources()
 531 {
 532   std::vector<std::pair<int, const char*>> sources = {
 533       {CJNIViewInputDevice::SOURCE_DPAD, "SOURCE_DPAD"},
 534       {CJNIViewInputDevice::SOURCE_GAMEPAD, "SOURCE_GAMEPAD"},
 535       {CJNIViewInputDevice::SOURCE_HDMI, "SOURCE_HDMI"},
 536       {CJNIViewInputDevice::SOURCE_JOYSTICK, "SOURCE_JOYSTICK"},
 537       {CJNIViewInputDevice::SOURCE_KEYBOARD, "SOURCE_KEYBOARD"},
 538       {CJNIViewInputDevice::SOURCE_MOUSE, "SOURCE_MOUSE"},
 539       {CJNIViewInputDevice::SOURCE_MOUSE_RELATIVE, "SOURCE_MOUSE_RELATIVE"},
 540       {CJNIViewInputDevice::SOURCE_ROTARY_ENCODER, "SOURCE_ROTARY_ENCODER"},
 541       {CJNIViewInputDevice::SOURCE_STYLUS, "SOURCE_STYLUS"},
 542       {CJNIViewInputDevice::SOURCE_TOUCHPAD, "SOURCE_TOUCHPAD"},
 543       {CJNIViewInputDevice::SOURCE_TOUCHSCREEN, "SOURCE_TOUCHSCREEN"},
 544       {CJNIViewInputDevice::SOURCE_TOUCH_NAVIGATION, "SOURCE_TOUCH_NAVIGATION"},
 545       {CJNIViewInputDevice::SOURCE_TRACKBALL, "SOURCE_TRACKBALL"},
 546   };
 547
 548   sources.erase(std::remove_if(sources.begin(), sources.end(),
 549                                [](const std::pair<int, const char*>& source)
 550                                { return source.first == 0; }),
 551                 sources.end());
 552
 553   return sources;
 554 }