diff options
Diffstat (limited to '')
25 files changed, 4769 insertions, 0 deletions
diff --git a/xbmc/peripherals/devices/CMakeLists.txt b/xbmc/peripherals/devices/CMakeLists.txt new file mode 100644 index 0000000..57795f5 --- /dev/null +++ b/xbmc/peripherals/devices/CMakeLists.txt @@ -0,0 +1,30 @@ +set(SOURCES Peripheral.cpp + PeripheralBluetooth.cpp + PeripheralDisk.cpp + PeripheralHID.cpp + PeripheralImon.cpp + PeripheralJoystick.cpp + PeripheralKeyboard.cpp + PeripheralMouse.cpp + PeripheralNIC.cpp + PeripheralNyxboard.cpp + PeripheralTuner.cpp) + +set(HEADERS Peripheral.h + PeripheralBluetooth.h + PeripheralDisk.h + PeripheralHID.h + PeripheralImon.h + PeripheralJoystick.h + PeripheralKeyboard.h + PeripheralMouse.h + PeripheralNIC.h + PeripheralNyxboard.h + PeripheralTuner.h) + +if(CEC_FOUND) + list(APPEND SOURCES PeripheralCecAdapter.cpp) + list(APPEND HEADERS PeripheralCecAdapter.h) +endif() + +core_add_library(peripherals_devices) diff --git a/xbmc/peripherals/devices/Peripheral.cpp b/xbmc/peripherals/devices/Peripheral.cpp new file mode 100644 index 0000000..6c3f779 --- /dev/null +++ b/xbmc/peripherals/devices/Peripheral.cpp @@ -0,0 +1,771 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "Peripheral.h" + +#include "Util.h" +#include "XBDateTime.h" +#include "games/controllers/Controller.h" +#include "games/controllers/ControllerLayout.h" +#include "guilib/LocalizeStrings.h" +#include "input/joysticks/interfaces/IInputHandler.h" +#include "peripherals/Peripherals.h" +#include "peripherals/addons/AddonButtonMapping.h" +#include "peripherals/addons/AddonInputHandling.h" +#include "peripherals/addons/PeripheralAddon.h" +#include "peripherals/bus/PeripheralBus.h" +#include "peripherals/bus/virtual/PeripheralBusAddon.h" +#include "settings/SettingAddon.h" +#include "settings/lib/Setting.h" +#include "utils/FileUtils.h" +#include "utils/StringUtils.h" +#include "utils/XBMCTinyXML.h" +#include "utils/XMLUtils.h" +#include "utils/log.h" + +#include <utility> + +using namespace KODI; +using namespace JOYSTICK; +using namespace PERIPHERALS; + +struct SortBySettingsOrder +{ + bool operator()(const PeripheralDeviceSetting& left, const PeripheralDeviceSetting& right) + { + return left.m_order < right.m_order; + } +}; + +CPeripheral::CPeripheral(CPeripherals& manager, + const PeripheralScanResult& scanResult, + CPeripheralBus* bus) + : m_manager(manager), + m_type(scanResult.m_mappedType), + m_busType(scanResult.m_busType), + m_mappedBusType(scanResult.m_mappedBusType), + m_strLocation(scanResult.m_strLocation), + m_strDeviceName(scanResult.m_strDeviceName), + m_iVendorId(scanResult.m_iVendorId), + m_iProductId(scanResult.m_iProductId), + m_strVersionInfo(g_localizeStrings.Get(13205)), // "unknown" + m_bInitialised(false), + m_bHidden(false), + m_bError(false), + m_bus(bus) +{ + PeripheralTypeTranslator::FormatHexString(scanResult.m_iVendorId, m_strVendorId); + PeripheralTypeTranslator::FormatHexString(scanResult.m_iProductId, m_strProductId); + if (scanResult.m_iSequence > 0) + { + m_strFileLocation = + StringUtils::Format("peripherals://{}/{}_{}.dev", + PeripheralTypeTranslator::BusTypeToString(scanResult.m_busType), + scanResult.m_strLocation, scanResult.m_iSequence); + } + else + { + m_strFileLocation = StringUtils::Format( + "peripherals://{}/{}.dev", PeripheralTypeTranslator::BusTypeToString(scanResult.m_busType), + scanResult.m_strLocation); + } +} + +CPeripheral::~CPeripheral(void) +{ + PersistSettings(true); + + m_subDevices.clear(); + + ClearSettings(); +} + +bool CPeripheral::operator==(const CPeripheral& right) const +{ + return m_type == right.m_type && m_strLocation == right.m_strLocation && + m_iVendorId == right.m_iVendorId && m_iProductId == right.m_iProductId; +} + +bool CPeripheral::operator!=(const CPeripheral& right) const +{ + return !(*this == right); +} + +bool CPeripheral::HasFeature(const PeripheralFeature feature) const +{ + bool bReturn(false); + + for (unsigned int iFeaturePtr = 0; iFeaturePtr < m_features.size(); iFeaturePtr++) + { + if (m_features.at(iFeaturePtr) == feature) + { + bReturn = true; + break; + } + } + + if (!bReturn) + { + for (unsigned int iSubdevicePtr = 0; iSubdevicePtr < m_subDevices.size(); iSubdevicePtr++) + { + if (m_subDevices.at(iSubdevicePtr)->HasFeature(feature)) + { + bReturn = true; + break; + } + } + } + + return bReturn; +} + +void CPeripheral::GetFeatures(std::vector<PeripheralFeature>& features) const +{ + for (unsigned int iFeaturePtr = 0; iFeaturePtr < m_features.size(); iFeaturePtr++) + features.push_back(m_features.at(iFeaturePtr)); + + for (unsigned int iSubdevicePtr = 0; iSubdevicePtr < m_subDevices.size(); iSubdevicePtr++) + m_subDevices.at(iSubdevicePtr)->GetFeatures(features); +} + +bool CPeripheral::Initialise(void) +{ + bool bReturn(false); + + if (m_bError) + return bReturn; + + bReturn = true; + if (m_bInitialised) + return bReturn; + + m_manager.GetSettingsFromMapping(*this); + + std::string safeDeviceName = m_strDeviceName; + StringUtils::Replace(safeDeviceName, ' ', '_'); + + if (m_iVendorId == 0x0000 && m_iProductId == 0x0000) + { + m_strSettingsFile = + StringUtils::Format("special://profile/peripheral_data/{}_{}.xml", + PeripheralTypeTranslator::BusTypeToString(m_mappedBusType), + CUtil::MakeLegalFileName(safeDeviceName, LEGAL_WIN32_COMPAT)); + } + else + { + // Backwards compatibility - old settings files didn't include the device name + m_strSettingsFile = StringUtils::Format( + "special://profile/peripheral_data/{}_{}_{}.xml", + PeripheralTypeTranslator::BusTypeToString(m_mappedBusType), m_strVendorId, m_strProductId); + + if (!CFileUtils::Exists(m_strSettingsFile)) + m_strSettingsFile = StringUtils::Format( + "special://profile/peripheral_data/{}_{}_{}_{}.xml", + PeripheralTypeTranslator::BusTypeToString(m_mappedBusType), m_strVendorId, m_strProductId, + CUtil::MakeLegalFileName(safeDeviceName, LEGAL_WIN32_COMPAT)); + } + + LoadPersistedSettings(); + + for (unsigned int iFeaturePtr = 0; iFeaturePtr < m_features.size(); iFeaturePtr++) + { + PeripheralFeature feature = m_features.at(iFeaturePtr); + bReturn &= InitialiseFeature(feature); + } + + for (unsigned int iSubdevicePtr = 0; iSubdevicePtr < m_subDevices.size(); iSubdevicePtr++) + bReturn &= m_subDevices.at(iSubdevicePtr)->Initialise(); + + if (bReturn) + { + CLog::Log(LOGDEBUG, "{} - initialised peripheral on '{}' with {} features and {} sub devices", + __FUNCTION__, m_strLocation, (int)m_features.size(), (int)m_subDevices.size()); + m_bInitialised = true; + } + + return bReturn; +} + +void CPeripheral::GetSubdevices(PeripheralVector& subDevices) const +{ + subDevices = m_subDevices; +} + +bool CPeripheral::IsMultiFunctional(void) const +{ + return m_subDevices.size() > 0; +} + +std::vector<std::shared_ptr<CSetting>> CPeripheral::GetSettings(void) const +{ + std::vector<PeripheralDeviceSetting> tmpSettings; + tmpSettings.reserve(m_settings.size()); + for (const auto& it : m_settings) + tmpSettings.push_back(it.second); + sort(tmpSettings.begin(), tmpSettings.end(), SortBySettingsOrder()); + + std::vector<std::shared_ptr<CSetting>> settings; + settings.reserve(tmpSettings.size()); + for (const auto& it : tmpSettings) + settings.push_back(it.m_setting); + return settings; +} + +void CPeripheral::AddSetting(const std::string& strKey, const SettingConstPtr& setting, int order) +{ + if (!setting) + { + CLog::Log(LOGERROR, "{} - invalid setting", __FUNCTION__); + return; + } + + if (!HasSetting(strKey)) + { + PeripheralDeviceSetting deviceSetting = {NULL, order}; + switch (setting->GetType()) + { + case SettingType::Boolean: + { + std::shared_ptr<const CSettingBool> mappedSetting = + std::static_pointer_cast<const CSettingBool>(setting); + std::shared_ptr<CSettingBool> boolSetting = + std::make_shared<CSettingBool>(strKey, *mappedSetting); + if (boolSetting) + { + boolSetting->SetVisible(mappedSetting->IsVisible()); + deviceSetting.m_setting = boolSetting; + } + } + break; + case SettingType::Integer: + { + std::shared_ptr<const CSettingInt> mappedSetting = + std::static_pointer_cast<const CSettingInt>(setting); + std::shared_ptr<CSettingInt> intSetting = + std::make_shared<CSettingInt>(strKey, *mappedSetting); + if (intSetting) + { + intSetting->SetVisible(mappedSetting->IsVisible()); + deviceSetting.m_setting = intSetting; + } + } + break; + case SettingType::Number: + { + std::shared_ptr<const CSettingNumber> mappedSetting = + std::static_pointer_cast<const CSettingNumber>(setting); + std::shared_ptr<CSettingNumber> floatSetting = + std::make_shared<CSettingNumber>(strKey, *mappedSetting); + if (floatSetting) + { + floatSetting->SetVisible(mappedSetting->IsVisible()); + deviceSetting.m_setting = floatSetting; + } + } + break; + case SettingType::String: + { + if (std::dynamic_pointer_cast<const CSettingAddon>(setting)) + { + std::shared_ptr<const CSettingAddon> mappedSetting = + std::static_pointer_cast<const CSettingAddon>(setting); + std::shared_ptr<CSettingAddon> addonSetting = + std::make_shared<CSettingAddon>(strKey, *mappedSetting); + addonSetting->SetVisible(mappedSetting->IsVisible()); + deviceSetting.m_setting = addonSetting; + } + else + { + std::shared_ptr<const CSettingString> mappedSetting = + std::static_pointer_cast<const CSettingString>(setting); + std::shared_ptr<CSettingString> stringSetting = + std::make_shared<CSettingString>(strKey, *mappedSetting); + stringSetting->SetVisible(mappedSetting->IsVisible()); + deviceSetting.m_setting = stringSetting; + } + } + break; + default: + //! @todo add more types if needed + break; + } + + if (deviceSetting.m_setting != NULL) + m_settings.insert(make_pair(strKey, deviceSetting)); + } +} + +bool CPeripheral::HasSetting(const std::string& strKey) const +{ + std::map<std::string, PeripheralDeviceSetting>::const_iterator it = m_settings.find(strKey); + return it != m_settings.end(); +} + +bool CPeripheral::HasSettings(void) const +{ + return !m_settings.empty(); +} + +bool CPeripheral::HasConfigurableSettings(void) const +{ + bool bReturn(false); + std::map<std::string, PeripheralDeviceSetting>::const_iterator it = m_settings.begin(); + while (it != m_settings.end() && !bReturn) + { + if ((*it).second.m_setting->IsVisible()) + { + bReturn = true; + break; + } + + ++it; + } + + return bReturn; +} + +bool CPeripheral::GetSettingBool(const std::string& strKey) const +{ + std::map<std::string, PeripheralDeviceSetting>::const_iterator it = m_settings.find(strKey); + if (it != m_settings.end() && (*it).second.m_setting->GetType() == SettingType::Boolean) + { + std::shared_ptr<CSettingBool> boolSetting = + std::static_pointer_cast<CSettingBool>((*it).second.m_setting); + if (boolSetting) + return boolSetting->GetValue(); + } + + return false; +} + +int CPeripheral::GetSettingInt(const std::string& strKey) const +{ + std::map<std::string, PeripheralDeviceSetting>::const_iterator it = m_settings.find(strKey); + if (it != m_settings.end() && (*it).second.m_setting->GetType() == SettingType::Integer) + { + std::shared_ptr<CSettingInt> intSetting = + std::static_pointer_cast<CSettingInt>((*it).second.m_setting); + if (intSetting) + return intSetting->GetValue(); + } + + return 0; +} + +float CPeripheral::GetSettingFloat(const std::string& strKey) const +{ + std::map<std::string, PeripheralDeviceSetting>::const_iterator it = m_settings.find(strKey); + if (it != m_settings.end() && (*it).second.m_setting->GetType() == SettingType::Number) + { + std::shared_ptr<CSettingNumber> floatSetting = + std::static_pointer_cast<CSettingNumber>((*it).second.m_setting); + if (floatSetting) + return (float)floatSetting->GetValue(); + } + + return 0; +} + +const std::string CPeripheral::GetSettingString(const std::string& strKey) const +{ + std::map<std::string, PeripheralDeviceSetting>::const_iterator it = m_settings.find(strKey); + if (it != m_settings.end() && (*it).second.m_setting->GetType() == SettingType::String) + { + std::shared_ptr<CSettingString> stringSetting = + std::static_pointer_cast<CSettingString>((*it).second.m_setting); + if (stringSetting) + return stringSetting->GetValue(); + } + + return ""; +} + +bool CPeripheral::SetSetting(const std::string& strKey, bool bValue) +{ + bool bChanged(false); + std::map<std::string, PeripheralDeviceSetting>::iterator it = m_settings.find(strKey); + if (it != m_settings.end() && (*it).second.m_setting->GetType() == SettingType::Boolean) + { + std::shared_ptr<CSettingBool> boolSetting = + std::static_pointer_cast<CSettingBool>((*it).second.m_setting); + if (boolSetting) + { + bChanged = boolSetting->GetValue() != bValue; + boolSetting->SetValue(bValue); + if (bChanged && m_bInitialised) + m_changedSettings.insert(strKey); + } + } + return bChanged; +} + +bool CPeripheral::SetSetting(const std::string& strKey, int iValue) +{ + bool bChanged(false); + std::map<std::string, PeripheralDeviceSetting>::iterator it = m_settings.find(strKey); + if (it != m_settings.end() && (*it).second.m_setting->GetType() == SettingType::Integer) + { + std::shared_ptr<CSettingInt> intSetting = + std::static_pointer_cast<CSettingInt>((*it).second.m_setting); + if (intSetting) + { + bChanged = intSetting->GetValue() != iValue; + intSetting->SetValue(iValue); + if (bChanged && m_bInitialised) + m_changedSettings.insert(strKey); + } + } + return bChanged; +} + +bool CPeripheral::SetSetting(const std::string& strKey, float fValue) +{ + bool bChanged(false); + std::map<std::string, PeripheralDeviceSetting>::iterator it = m_settings.find(strKey); + if (it != m_settings.end() && (*it).second.m_setting->GetType() == SettingType::Number) + { + std::shared_ptr<CSettingNumber> floatSetting = + std::static_pointer_cast<CSettingNumber>((*it).second.m_setting); + if (floatSetting) + { + bChanged = floatSetting->GetValue() != static_cast<double>(fValue); + floatSetting->SetValue(static_cast<double>(fValue)); + if (bChanged && m_bInitialised) + m_changedSettings.insert(strKey); + } + } + return bChanged; +} + +void CPeripheral::SetSettingVisible(const std::string& strKey, bool bSetTo) +{ + std::map<std::string, PeripheralDeviceSetting>::iterator it = m_settings.find(strKey); + if (it != m_settings.end()) + (*it).second.m_setting->SetVisible(bSetTo); +} + +bool CPeripheral::IsSettingVisible(const std::string& strKey) const +{ + std::map<std::string, PeripheralDeviceSetting>::const_iterator it = m_settings.find(strKey); + if (it != m_settings.end()) + return (*it).second.m_setting->IsVisible(); + return false; +} + +bool CPeripheral::SetSetting(const std::string& strKey, const std::string& strValue) +{ + bool bChanged(false); + std::map<std::string, PeripheralDeviceSetting>::iterator it = m_settings.find(strKey); + if (it != m_settings.end()) + { + if ((*it).second.m_setting->GetType() == SettingType::String) + { + std::shared_ptr<CSettingString> stringSetting = + std::static_pointer_cast<CSettingString>((*it).second.m_setting); + if (stringSetting) + { + bChanged = !StringUtils::EqualsNoCase(stringSetting->GetValue(), strValue); + stringSetting->SetValue(strValue); + if (bChanged && m_bInitialised) + m_changedSettings.insert(strKey); + } + } + else if ((*it).second.m_setting->GetType() == SettingType::Integer) + bChanged = SetSetting(strKey, strValue.empty() ? 0 : atoi(strValue.c_str())); + else if ((*it).second.m_setting->GetType() == SettingType::Number) + bChanged = SetSetting(strKey, (float)(strValue.empty() ? 0 : atof(strValue.c_str()))); + else if ((*it).second.m_setting->GetType() == SettingType::Boolean) + bChanged = SetSetting(strKey, strValue == "1"); + } + return bChanged; +} + +void CPeripheral::PersistSettings(bool bExiting /* = false */) +{ + CXBMCTinyXML doc; + TiXmlElement node("settings"); + doc.InsertEndChild(node); + for (const auto& itr : m_settings) + { + TiXmlElement nodeSetting("setting"); + nodeSetting.SetAttribute("id", itr.first.c_str()); + std::string strValue; + switch (itr.second.m_setting->GetType()) + { + case SettingType::String: + { + std::shared_ptr<CSettingString> stringSetting = + std::static_pointer_cast<CSettingString>(itr.second.m_setting); + if (stringSetting) + strValue = stringSetting->GetValue(); + } + break; + case SettingType::Integer: + { + std::shared_ptr<CSettingInt> intSetting = + std::static_pointer_cast<CSettingInt>(itr.second.m_setting); + if (intSetting) + strValue = std::to_string(intSetting->GetValue()); + } + break; + case SettingType::Number: + { + std::shared_ptr<CSettingNumber> floatSetting = + std::static_pointer_cast<CSettingNumber>(itr.second.m_setting); + if (floatSetting) + strValue = StringUtils::Format("{:.2f}", floatSetting->GetValue()); + } + break; + case SettingType::Boolean: + { + std::shared_ptr<CSettingBool> boolSetting = + std::static_pointer_cast<CSettingBool>(itr.second.m_setting); + if (boolSetting) + strValue = std::to_string(boolSetting->GetValue() ? 1 : 0); + } + break; + default: + break; + } + nodeSetting.SetAttribute("value", strValue.c_str()); + doc.RootElement()->InsertEndChild(nodeSetting); + } + + doc.SaveFile(m_strSettingsFile); + + if (!bExiting) + { + for (const auto& it : m_changedSettings) + OnSettingChanged(it); + } + m_changedSettings.clear(); +} + +void CPeripheral::LoadPersistedSettings(void) +{ + CXBMCTinyXML doc; + if (doc.LoadFile(m_strSettingsFile)) + { + const TiXmlElement* setting = doc.RootElement()->FirstChildElement("setting"); + while (setting) + { + std::string strId = XMLUtils::GetAttribute(setting, "id"); + std::string strValue = XMLUtils::GetAttribute(setting, "value"); + SetSetting(strId, strValue); + + setting = setting->NextSiblingElement("setting"); + } + } +} + +void CPeripheral::ResetDefaultSettings(void) +{ + ClearSettings(); + m_manager.GetSettingsFromMapping(*this); + + std::map<std::string, PeripheralDeviceSetting>::iterator it = m_settings.begin(); + while (it != m_settings.end()) + { + m_changedSettings.insert((*it).first); + ++it; + } + + PersistSettings(); +} + +void CPeripheral::ClearSettings(void) +{ + m_settings.clear(); +} + +void CPeripheral::RegisterInputHandler(IInputHandler* handler, bool bPromiscuous) +{ + auto it = m_inputHandlers.find(handler); + if (it == m_inputHandlers.end()) + { + PeripheralAddonPtr addon = m_manager.GetAddonWithButtonMap(this); + if (addon) + { + std::unique_ptr<CAddonInputHandling> addonInput = std::make_unique<CAddonInputHandling>( + m_manager, this, std::move(addon), handler, GetDriverReceiver()); + if (addonInput->Load()) + { + RegisterJoystickDriverHandler(addonInput.get(), bPromiscuous); + m_inputHandlers[handler] = std::move(addonInput); + } + } + else + { + CLog::Log(LOGDEBUG, "Failed to locate add-on for \"{}\"", m_strLocation); + } + } +} + +void CPeripheral::UnregisterInputHandler(IInputHandler* handler) +{ + handler->ResetInputReceiver(); + + auto it = m_inputHandlers.find(handler); + if (it != m_inputHandlers.end()) + { + UnregisterJoystickDriverHandler(it->second.get()); + m_inputHandlers.erase(it); + } +} + +void CPeripheral::RegisterKeyboardHandler(KEYBOARD::IKeyboardInputHandler* handler, + bool bPromiscuous) +{ + auto it = m_keyboardHandlers.find(handler); + if (it == m_keyboardHandlers.end()) + { + std::unique_ptr<KODI::KEYBOARD::IKeyboardDriverHandler> keyboardDriverHandler; + + PeripheralAddonPtr addon = m_manager.GetAddonWithButtonMap(this); + if (addon) + { + std::unique_ptr<CAddonInputHandling> addonInput = + std::make_unique<CAddonInputHandling>(m_manager, this, std::move(addon), handler); + if (addonInput->Load()) + keyboardDriverHandler = std::move(addonInput); + } + else + { + CLog::Log(LOGDEBUG, "Failed to locate add-on for \"{}\"", m_strLocation); + } + + if (keyboardDriverHandler) + { + RegisterKeyboardDriverHandler(keyboardDriverHandler.get(), bPromiscuous); + m_keyboardHandlers[handler] = std::move(keyboardDriverHandler); + } + } +} + +void CPeripheral::UnregisterKeyboardHandler(KEYBOARD::IKeyboardInputHandler* handler) +{ + auto it = m_keyboardHandlers.find(handler); + if (it != m_keyboardHandlers.end()) + { + UnregisterKeyboardDriverHandler(it->second.get()); + m_keyboardHandlers.erase(it); + } +} + +void CPeripheral::RegisterMouseHandler(MOUSE::IMouseInputHandler* handler, bool bPromiscuous) +{ + auto it = m_mouseHandlers.find(handler); + if (it == m_mouseHandlers.end()) + { + std::unique_ptr<KODI::MOUSE::IMouseDriverHandler> mouseDriverHandler; + + PeripheralAddonPtr addon = m_manager.GetAddonWithButtonMap(this); + if (addon) + { + std::unique_ptr<CAddonInputHandling> addonInput = + std::make_unique<CAddonInputHandling>(m_manager, this, std::move(addon), handler); + if (addonInput->Load()) + mouseDriverHandler = std::move(addonInput); + } + else + { + CLog::Log(LOGDEBUG, "Failed to locate add-on for \"{}\"", m_strLocation); + } + + if (mouseDriverHandler) + { + RegisterMouseDriverHandler(mouseDriverHandler.get(), bPromiscuous); + m_mouseHandlers[handler] = std::move(mouseDriverHandler); + } + } +} + +void CPeripheral::UnregisterMouseHandler(MOUSE::IMouseInputHandler* handler) +{ + auto it = m_mouseHandlers.find(handler); + if (it != m_mouseHandlers.end()) + { + UnregisterMouseDriverHandler(it->second.get()); + m_mouseHandlers.erase(it); + } +} + +void CPeripheral::RegisterJoystickButtonMapper(IButtonMapper* mapper) +{ + auto it = m_buttonMappers.find(mapper); + if (it == m_buttonMappers.end()) + { + std::unique_ptr<CAddonButtonMapping> addonMapping( + new CAddonButtonMapping(m_manager, this, mapper)); + + RegisterJoystickDriverHandler(addonMapping.get(), false); + RegisterKeyboardDriverHandler(addonMapping.get(), false); + RegisterMouseDriverHandler(addonMapping.get(), false); + + m_buttonMappers[mapper] = std::move(addonMapping); + } +} + +void CPeripheral::UnregisterJoystickButtonMapper(IButtonMapper* mapper) +{ + auto it = m_buttonMappers.find(mapper); + if (it != m_buttonMappers.end()) + { + UnregisterMouseDriverHandler(it->second.get()); + UnregisterKeyboardDriverHandler(it->second.get()); + UnregisterJoystickDriverHandler(it->second.get()); + + m_buttonMappers.erase(it); + } +} + +std::string CPeripheral::GetIcon() const +{ + std::string icon; + + // Try controller profile + const GAME::ControllerPtr controller = ControllerProfile(); + if (controller) + icon = controller->Layout().ImagePath(); + + // Try add-on + if (icon.empty() && m_busType == PERIPHERAL_BUS_ADDON) + { + CPeripheralBusAddon* bus = static_cast<CPeripheralBusAddon*>(m_bus); + + PeripheralAddonPtr addon; + unsigned int index; + if (bus->SplitLocation(m_strLocation, addon, index)) + { + std::string addonIcon = addon->Icon(); + if (!addonIcon.empty()) + icon = std::move(addonIcon); + } + } + + // Fallback + if (icon.empty()) + icon = "DefaultAddon.png"; + + return icon; +} + +bool CPeripheral::operator==(const PeripheralScanResult& right) const +{ + return StringUtils::EqualsNoCase(m_strLocation, right.m_strLocation); +} + +bool CPeripheral::operator!=(const PeripheralScanResult& right) const +{ + return !(*this == right); +} + +CDateTime CPeripheral::LastActive() +{ + return CDateTime(); +} diff --git a/xbmc/peripherals/devices/Peripheral.h b/xbmc/peripherals/devices/Peripheral.h new file mode 100644 index 0000000..8c4049b --- /dev/null +++ b/xbmc/peripherals/devices/Peripheral.h @@ -0,0 +1,306 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "games/controllers/ControllerTypes.h" +#include "input/joysticks/interfaces/IInputProvider.h" +#include "input/keyboard/interfaces/IKeyboardInputProvider.h" +#include "input/mouse/interfaces/IMouseInputProvider.h" +#include "peripherals/PeripheralTypes.h" + +#include <map> +#include <set> +#include <string> +#include <vector> + +class TiXmlDocument; +class CDateTime; +class CSetting; +class IKeymap; + +namespace KODI +{ +namespace JOYSTICK +{ +class IButtonMapper; +class IDriverHandler; +class IDriverReceiver; +class IInputHandler; +} // namespace JOYSTICK + +namespace KEYBOARD +{ +class IKeyboardDriverHandler; +} + +namespace MOUSE +{ +class IMouseDriverHandler; +} +} // namespace KODI + +namespace PERIPHERALS +{ +class CAddonButtonMapping; +class CGUIDialogPeripheralSettings; +class CPeripheralBus; +class CPeripherals; + +typedef enum +{ + STATE_SWITCH_TOGGLE, + STATE_ACTIVATE_SOURCE, + STATE_STANDBY +} CecStateChange; + +class CPeripheral : public KODI::JOYSTICK::IInputProvider, + public KODI::KEYBOARD::IKeyboardInputProvider, + public KODI::MOUSE::IMouseInputProvider +{ + friend class CGUIDialogPeripheralSettings; + +public: + CPeripheral(CPeripherals& manager, const PeripheralScanResult& scanResult, CPeripheralBus* bus); + ~CPeripheral(void) override; + + bool operator==(const CPeripheral& right) const; + bool operator!=(const CPeripheral& right) const; + bool operator==(const PeripheralScanResult& right) const; + bool operator!=(const PeripheralScanResult& right) const; + + const std::string& FileLocation(void) const { return m_strFileLocation; } + const std::string& Location(void) const { return m_strLocation; } + int VendorId(void) const { return m_iVendorId; } + const char* VendorIdAsString(void) const { return m_strVendorId.c_str(); } + int ProductId(void) const { return m_iProductId; } + const char* ProductIdAsString(void) const { return m_strProductId.c_str(); } + PeripheralType Type(void) const { return m_type; } + PeripheralBusType GetBusType(void) const { return m_busType; } + const std::string& DeviceName(void) const { return m_strDeviceName; } + bool IsHidden(void) const { return m_bHidden; } + void SetHidden(bool bSetTo = true) { m_bHidden = bSetTo; } + const std::string& GetVersionInfo(void) const { return m_strVersionInfo; } + + /*! + * @brief Get an icon for this peripheral + * @return Path to an icon, or skin icon file name + */ + virtual std::string GetIcon() const; + + /*! + * @brief Check whether this device has the given feature. + * @param feature The feature to check for. + * @return True when the device has the feature, false otherwise. + */ + bool HasFeature(const PeripheralFeature feature) const; + + /*! + * @brief Get all features that are supported by this device. + * @param features The features. + */ + void GetFeatures(std::vector<PeripheralFeature>& features) const; + + /*! + * @brief Initialises the peripheral. + * @return True when the peripheral has been initialised successfully, false otherwise. + */ + bool Initialise(void); + + /*! + * @brief Initialise one of the features of this peripheral. + * @param feature The feature to initialise. + * @return True when the feature has been initialised successfully, false otherwise. + */ + virtual bool InitialiseFeature(const PeripheralFeature feature) { return true; } + + /*! + * @brief Briefly activate a feature to notify the user + */ + virtual void OnUserNotification() {} + + /*! + * @brief Briefly test one of the features of this peripheral. + * @param feature The feature to test. + * @return True if the test succeeded, false otherwise. + */ + virtual bool TestFeature(PeripheralFeature feature) { return false; } + + /*! + * @brief Called when a setting changed. + * @param strChangedSetting The changed setting. + */ + virtual void OnSettingChanged(const std::string& strChangedSetting) {} + + /*! + * @brief Called when this device is removed, before calling the destructor. + */ + virtual void OnDeviceRemoved(void) {} + + /*! + * @brief Get all subdevices if this device is multifunctional. + * @param subDevices The subdevices. + */ + virtual void GetSubdevices(PeripheralVector& subDevices) const; + + /*! + * @return True when this device is multifunctional, false otherwise. + */ + virtual bool IsMultiFunctional(void) const; + + /*! + * @brief Add a setting to this peripheral. This will overwrite a previous setting with the same + * key. + * @param strKey The key of the setting. + * @param setting The setting. + */ + virtual void AddSetting(const std::string& strKey, + const std::shared_ptr<const CSetting>& setting, + int order); + + /*! + * @brief Check whether a setting is known with the given key. + * @param strKey The key to search. + * @return True when found, false otherwise. + */ + virtual bool HasSetting(const std::string& strKey) const; + + /*! + * @return True when this device has any settings, false otherwise. + */ + virtual bool HasSettings(void) const; + + /*! + * @return True when this device has any configurable settings, false otherwise. + */ + virtual bool HasConfigurableSettings(void) const; + + /*! + * @brief Get the value of a setting. + * @param strKey The key to search. + * @return The value or an empty string if it wasn't found. + */ + virtual const std::string GetSettingString(const std::string& strKey) const; + virtual bool SetSetting(const std::string& strKey, const std::string& strValue); + virtual void SetSettingVisible(const std::string& strKey, bool bSetTo); + virtual bool IsSettingVisible(const std::string& strKey) const; + + virtual int GetSettingInt(const std::string& strKey) const; + virtual bool SetSetting(const std::string& strKey, int iValue); + + virtual bool GetSettingBool(const std::string& strKey) const; + virtual bool SetSetting(const std::string& strKey, bool bValue); + + virtual float GetSettingFloat(const std::string& strKey) const; + virtual bool SetSetting(const std::string& strKey, float fValue); + + virtual void PersistSettings(bool bExiting = false); + virtual void LoadPersistedSettings(void); + virtual void ResetDefaultSettings(void); + + virtual std::vector<std::shared_ptr<CSetting>> GetSettings(void) const; + + virtual bool ErrorOccured(void) const { return m_bError; } + + virtual void RegisterJoystickDriverHandler(KODI::JOYSTICK::IDriverHandler* handler, + bool bPromiscuous) + { + } + virtual void UnregisterJoystickDriverHandler(KODI::JOYSTICK::IDriverHandler* handler) {} + + virtual void RegisterKeyboardDriverHandler(KODI::KEYBOARD::IKeyboardDriverHandler* handler, + bool bPromiscuous) + { + } + virtual void UnregisterKeyboardDriverHandler(KODI::KEYBOARD::IKeyboardDriverHandler* handler) {} + + virtual void RegisterMouseDriverHandler(KODI::MOUSE::IMouseDriverHandler* handler, + bool bPromiscuous) + { + } + virtual void UnregisterMouseDriverHandler(KODI::MOUSE::IMouseDriverHandler* handler) {} + + // implementation of IInputProvider + void RegisterInputHandler(KODI::JOYSTICK::IInputHandler* handler, bool bPromiscuous) override; + void UnregisterInputHandler(KODI::JOYSTICK::IInputHandler* handler) override; + + // implementation of IKeyboardInputProvider + void RegisterKeyboardHandler(KODI::KEYBOARD::IKeyboardInputHandler* handler, + bool bPromiscuous) override; + void UnregisterKeyboardHandler(KODI::KEYBOARD::IKeyboardInputHandler* handler) override; + + // implementation of IMouseInputProvider + void RegisterMouseHandler(KODI::MOUSE::IMouseInputHandler* handler, bool bPromiscuous) override; + void UnregisterMouseHandler(KODI::MOUSE::IMouseInputHandler* handler) override; + + virtual void RegisterJoystickButtonMapper(KODI::JOYSTICK::IButtonMapper* mapper); + virtual void UnregisterJoystickButtonMapper(KODI::JOYSTICK::IButtonMapper* mapper); + + virtual KODI::JOYSTICK::IDriverReceiver* GetDriverReceiver() { return nullptr; } + + virtual IKeymap* GetKeymap(const std::string& controllerId) { return nullptr; } + + /*! + * \brief Return the last time this peripheral was active + * + * \return The time of last activation, or invalid if unknown/never active + */ + virtual CDateTime LastActive(); + + /*! + * \brief Get the controller profile that best represents this peripheral + * + * \return The controller profile, or empty if unknown + */ + virtual KODI::GAME::ControllerPtr ControllerProfile() const { return m_controllerProfile; } + + /*! + * \brief Set the controller profile for this peripheral + * + * \param controller The new controller profile + */ + virtual void SetControllerProfile(const KODI::GAME::ControllerPtr& controller) + { + m_controllerProfile = controller; + } + +protected: + virtual void ClearSettings(void); + + CPeripherals& m_manager; + PeripheralType m_type; + PeripheralBusType m_busType; + PeripheralBusType m_mappedBusType; + std::string m_strLocation; + std::string m_strDeviceName; + std::string m_strSettingsFile; + std::string m_strFileLocation; + int m_iVendorId; + std::string m_strVendorId; + int m_iProductId; + std::string m_strProductId; + std::string m_strVersionInfo; + bool m_bInitialised; + bool m_bHidden; + bool m_bError; + std::vector<PeripheralFeature> m_features; + PeripheralVector m_subDevices; + std::map<std::string, PeripheralDeviceSetting> m_settings; + std::set<std::string> m_changedSettings; + CPeripheralBus* m_bus; + std::map<KODI::JOYSTICK::IInputHandler*, std::unique_ptr<KODI::JOYSTICK::IDriverHandler>> + m_inputHandlers; + std::map<KODI::KEYBOARD::IKeyboardInputHandler*, + std::unique_ptr<KODI::KEYBOARD::IKeyboardDriverHandler>> + m_keyboardHandlers; + std::map<KODI::MOUSE::IMouseInputHandler*, std::unique_ptr<KODI::MOUSE::IMouseDriverHandler>> + m_mouseHandlers; + std::map<KODI::JOYSTICK::IButtonMapper*, std::unique_ptr<CAddonButtonMapping>> m_buttonMappers; + KODI::GAME::ControllerPtr m_controllerProfile; +}; +} // namespace PERIPHERALS diff --git a/xbmc/peripherals/devices/PeripheralBluetooth.cpp b/xbmc/peripherals/devices/PeripheralBluetooth.cpp new file mode 100644 index 0000000..6f3802d --- /dev/null +++ b/xbmc/peripherals/devices/PeripheralBluetooth.cpp @@ -0,0 +1,19 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "PeripheralBluetooth.h" + +using namespace PERIPHERALS; + +CPeripheralBluetooth::CPeripheralBluetooth(CPeripherals& manager, + const PeripheralScanResult& scanResult, + CPeripheralBus* bus) + : CPeripheral(manager, scanResult, bus) +{ + m_features.push_back(FEATURE_BLUETOOTH); +} diff --git a/xbmc/peripherals/devices/PeripheralBluetooth.h b/xbmc/peripherals/devices/PeripheralBluetooth.h new file mode 100644 index 0000000..11fa7ca --- /dev/null +++ b/xbmc/peripherals/devices/PeripheralBluetooth.h @@ -0,0 +1,23 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "Peripheral.h" + +namespace PERIPHERALS +{ +class CPeripheralBluetooth : public CPeripheral +{ +public: + CPeripheralBluetooth(CPeripherals& manager, + const PeripheralScanResult& scanResult, + CPeripheralBus* bus); + ~CPeripheralBluetooth(void) override = default; +}; +} // namespace PERIPHERALS diff --git a/xbmc/peripherals/devices/PeripheralCecAdapter.cpp b/xbmc/peripherals/devices/PeripheralCecAdapter.cpp new file mode 100644 index 0000000..bc62bea --- /dev/null +++ b/xbmc/peripherals/devices/PeripheralCecAdapter.cpp @@ -0,0 +1,1861 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "PeripheralCecAdapter.h" + +#include "ServiceBroker.h" +#include "application/ApplicationComponents.h" +#include "application/ApplicationEnums.h" +#include "application/ApplicationPlayer.h" +#include "application/ApplicationPowerHandling.h" +#include "application/ApplicationVolumeHandling.h" +#include "dialogs/GUIDialogKaiToast.h" +#include "guilib/GUIComponent.h" +#include "guilib/GUIWindowManager.h" +#include "guilib/LocalizeStrings.h" +#include "input/actions/Action.h" +#include "input/actions/ActionIDs.h" +#include "input/remote/IRRemote.h" +#include "messaging/ApplicationMessenger.h" +#include "pictures/GUIWindowSlideShow.h" +#include "utils/JobManager.h" +#include "utils/Variant.h" +#include "utils/log.h" +#include "xbmc/interfaces/AnnouncementManager.h" + +#include <mutex> + +#include <libcec/cec.h> + +using namespace PERIPHERALS; +using namespace CEC; +using namespace ANNOUNCEMENT; +using namespace std::chrono_literals; + +#define CEC_LIB_SUPPORTED_VERSION LIBCEC_VERSION_TO_UINT(4, 0, 0) + +/* time in seconds to ignore standby commands from devices after the screensaver has been activated + */ +#define SCREENSAVER_TIMEOUT 20 +#define VOLUME_CHANGE_TIMEOUT 250 +#define VOLUME_REFRESH_TIMEOUT 100 + +#define LOCALISED_ID_TV 36037 +#define LOCALISED_ID_AVR 36038 +#define LOCALISED_ID_TV_AVR 36039 +#define LOCALISED_ID_STOP 36044 +#define LOCALISED_ID_PAUSE 36045 +#define LOCALISED_ID_POWEROFF 13005 +#define LOCALISED_ID_SUSPEND 13011 +#define LOCALISED_ID_HIBERNATE 13010 +#define LOCALISED_ID_QUIT 13009 +#define LOCALISED_ID_IGNORE 36028 +#define LOCALISED_ID_RECORDING_DEVICE 36051 +#define LOCALISED_ID_PLAYBACK_DEVICE 36052 +#define LOCALISED_ID_TUNER_DEVICE 36053 + +#define LOCALISED_ID_NONE 231 + +/* time in seconds to suppress source activation after receiving OnStop */ +#define CEC_SUPPRESS_ACTIVATE_SOURCE_AFTER_ON_STOP 2 + +CPeripheralCecAdapter::CPeripheralCecAdapter(CPeripherals& manager, + const PeripheralScanResult& scanResult, + CPeripheralBus* bus) + : CPeripheralHID(manager, scanResult, bus), CThread("CECAdapter"), m_cecAdapter(NULL) +{ + ResetMembers(); + m_features.push_back(FEATURE_CEC); + m_strComPort = scanResult.m_strLocation; +} + +CPeripheralCecAdapter::~CPeripheralCecAdapter(void) +{ + { + std::unique_lock<CCriticalSection> lock(m_critSection); + CServiceBroker::GetAnnouncementManager()->RemoveAnnouncer(this); + m_bStop = true; + } + + StopThread(true); + delete m_queryThread; + + if (m_cecAdapter) + { + CECDestroy(m_cecAdapter); + m_cecAdapter = NULL; + } +} + +void CPeripheralCecAdapter::ResetMembers(void) +{ + if (m_cecAdapter) + CECDestroy(m_cecAdapter); + m_cecAdapter = NULL; + m_bStarted = false; + m_bHasButton = false; + m_bIsReady = false; + m_bHasConnectedAudioSystem = false; + m_strMenuLanguage = "???"; + m_lastKeypress = {}; + m_lastChange = VOLUME_CHANGE_NONE; + m_iExitCode = EXITCODE_QUIT; + + //! @todo fetch the correct initial value when system audiostatus is + //! implemented in libCEC + m_bIsMuted = false; + + m_bGoingToStandby = false; + m_bIsRunning = false; + m_bDeviceRemoved = false; + m_bActiveSourcePending = false; + m_bStandbyPending = false; + m_bActiveSourceBeforeStandby = false; + m_bOnPlayReceived = false; + m_bPlaybackPaused = false; + m_queryThread = NULL; + m_bPowerOnScreensaver = false; + m_bUseTVMenuLanguage = false; + m_bSendInactiveSource = false; + m_bPowerOffScreensaver = false; + m_bShutdownOnStandby = false; + + m_currentButton.iButton = 0; + m_currentButton.iDuration = 0; + m_standbySent.SetValid(false); + m_configuration.Clear(); +} + +void CPeripheralCecAdapter::Announce(ANNOUNCEMENT::AnnouncementFlag flag, + const std::string& sender, + const std::string& message, + const CVariant& data) +{ + if (flag == ANNOUNCEMENT::System && sender == CAnnouncementManager::ANNOUNCEMENT_SENDER && + message == "OnQuit" && m_bIsReady) + { + std::unique_lock<CCriticalSection> lock(m_critSection); + m_iExitCode = static_cast<int>(data["exitcode"].asInteger(EXITCODE_QUIT)); + CServiceBroker::GetAnnouncementManager()->RemoveAnnouncer(this); + StopThread(false); + } + else if (flag == ANNOUNCEMENT::GUI && sender == CAnnouncementManager::ANNOUNCEMENT_SENDER && + message == "OnScreensaverDeactivated" && m_bIsReady) + { + bool bIgnoreDeactivate(false); + if (data["shuttingdown"].isBoolean()) + { + // don't respond to the deactivation if we are just going to suspend/shutdown anyway + // the tv will not have time to switch on before being told to standby and + // may not action the standby command. + bIgnoreDeactivate = data["shuttingdown"].asBoolean(); + if (bIgnoreDeactivate) + CLog::Log(LOGDEBUG, "{} - ignoring OnScreensaverDeactivated for power action", + __FUNCTION__); + } + if (m_bPowerOnScreensaver && !bIgnoreDeactivate && m_configuration.bActivateSource) + { + ActivateSource(); + } + } + else if (flag == ANNOUNCEMENT::GUI && sender == CAnnouncementManager::ANNOUNCEMENT_SENDER && + message == "OnScreensaverActivated" && m_bIsReady) + { + // Don't put devices to standby if application is currently playing + const auto& components = CServiceBroker::GetAppComponents(); + const auto appPlayer = components.GetComponent<CApplicationPlayer>(); + if (!appPlayer->IsPlaying() && m_bPowerOffScreensaver) + { + // only power off when we're the active source + if (m_cecAdapter->IsLibCECActiveSource()) + StandbyDevices(); + } + } + else if (flag == ANNOUNCEMENT::System && sender == CAnnouncementManager::ANNOUNCEMENT_SENDER && + message == "OnSleep") + { + // this will also power off devices when we're the active source + { + std::unique_lock<CCriticalSection> lock(m_critSection); + m_bGoingToStandby = true; + } + StopThread(); + } + else if (flag == ANNOUNCEMENT::System && sender == CAnnouncementManager::ANNOUNCEMENT_SENDER && + message == "OnWake") + { + CLog::Log(LOGDEBUG, "{} - reconnecting to the CEC adapter after standby mode", __FUNCTION__); + if (ReopenConnection()) + { + bool bActivate(false); + { + std::unique_lock<CCriticalSection> lock(m_critSection); + bActivate = m_bActiveSourceBeforeStandby; + m_bActiveSourceBeforeStandby = false; + } + if (bActivate) + ActivateSource(); + } + } + else if (flag == ANNOUNCEMENT::Player && sender == CAnnouncementManager::ANNOUNCEMENT_SENDER && + message == "OnStop") + { + std::unique_lock<CCriticalSection> lock(m_critSection); + m_preventActivateSourceOnPlay = CDateTime::GetCurrentDateTime(); + m_bOnPlayReceived = false; + } + else if (flag == ANNOUNCEMENT::Player && sender == CAnnouncementManager::ANNOUNCEMENT_SENDER && + (message == "OnPlay" || message == "OnResume")) + { + // activate the source when playback started, and the option is enabled + bool bActivateSource(false); + { + std::unique_lock<CCriticalSection> lock(m_critSection); + bActivateSource = (m_configuration.bActivateSource && !m_bOnPlayReceived && + !m_cecAdapter->IsLibCECActiveSource() && + (!m_preventActivateSourceOnPlay.IsValid() || + CDateTime::GetCurrentDateTime() - m_preventActivateSourceOnPlay > + CDateTimeSpan(0, 0, 0, CEC_SUPPRESS_ACTIVATE_SOURCE_AFTER_ON_STOP))); + m_bOnPlayReceived = true; + } + if (bActivateSource) + ActivateSource(); + } +} + +bool CPeripheralCecAdapter::InitialiseFeature(const PeripheralFeature feature) +{ + if (feature == FEATURE_CEC && !m_bStarted && GetSettingBool("enabled")) + { + // hide settings that have an override set + if (!GetSettingString("wake_devices_advanced").empty()) + SetSettingVisible("wake_devices", false); + if (!GetSettingString("standby_devices_advanced").empty()) + SetSettingVisible("standby_devices", false); + + SetConfigurationFromSettings(); + m_callbacks.Clear(); + m_callbacks.logMessage = &CecLogMessage; + m_callbacks.keyPress = &CecKeyPress; + m_callbacks.commandReceived = &CecCommand; + m_callbacks.configurationChanged = &CecConfiguration; + m_callbacks.alert = &CecAlert; + m_callbacks.sourceActivated = &CecSourceActivated; + m_configuration.callbackParam = this; + m_configuration.callbacks = &m_callbacks; + + m_cecAdapter = CECInitialise(&m_configuration); + + if (m_configuration.serverVersion < CEC_LIB_SUPPORTED_VERSION) + { + /* unsupported libcec version */ + CLog::Log( + LOGERROR, + "Detected version of libCEC interface ({0:x}) is lower than the supported version {1:x}", + m_cecAdapter ? m_configuration.serverVersion : -1, CEC_LIB_SUPPORTED_VERSION); + + // display warning: incompatible libCEC + std::string strMessage = StringUtils::Format( + g_localizeStrings.Get(36040), m_cecAdapter ? m_configuration.serverVersion : -1, + CEC_LIB_SUPPORTED_VERSION); + CGUIDialogKaiToast::QueueNotification(CGUIDialogKaiToast::Error, g_localizeStrings.Get(36000), + strMessage); + m_bError = true; + if (m_cecAdapter) + CECDestroy(m_cecAdapter); + m_cecAdapter = NULL; + + m_features.clear(); + return false; + } + else + { + CLog::Log(LOGDEBUG, "{} - using libCEC v{}", __FUNCTION__, + m_cecAdapter->VersionToString(m_configuration.serverVersion)); + SetVersionInfo(m_configuration); + } + + m_bStarted = true; + Create(); + } + + return CPeripheral::InitialiseFeature(feature); +} + +void CPeripheralCecAdapter::SetVersionInfo(const libcec_configuration& configuration) +{ + m_strVersionInfo = StringUtils::Format("libCEC {} - firmware v{}", + m_cecAdapter->VersionToString(configuration.serverVersion), + configuration.iFirmwareVersion); + + // append firmware build date + if (configuration.iFirmwareBuildDate != CEC_FW_BUILD_UNKNOWN) + { + CDateTime dt((time_t)configuration.iFirmwareBuildDate); + m_strVersionInfo += StringUtils::Format(" ({})", dt.GetAsDBDate()); + } +} + +bool CPeripheralCecAdapter::OpenConnection(void) +{ + bool bIsOpen(false); + + if (!GetSettingBool("enabled")) + { + CLog::Log(LOGDEBUG, "{} - CEC adapter is disabled in peripheral settings", __FUNCTION__); + m_bStarted = false; + return bIsOpen; + } + + // open the CEC adapter + CLog::Log(LOGDEBUG, "{} - opening a connection to the CEC adapter: {}", __FUNCTION__, + m_strComPort); + + // scanning the CEC bus takes about 5 seconds, so display a notification to inform users that + // we're busy + std::string strMessage = + StringUtils::Format(g_localizeStrings.Get(21336), g_localizeStrings.Get(36000)); + CGUIDialogKaiToast::QueueNotification(CGUIDialogKaiToast::Info, g_localizeStrings.Get(36000), + strMessage); + + bool bConnectionFailedDisplayed(false); + + while (!m_bStop && !bIsOpen) + { + if ((bIsOpen = m_cecAdapter->Open(m_strComPort.c_str(), 10000)) == false) + { + // display warning: couldn't initialise libCEC + CLog::Log(LOGERROR, "{} - could not opening a connection to the CEC adapter", __FUNCTION__); + if (!bConnectionFailedDisplayed) + CGUIDialogKaiToast::QueueNotification( + CGUIDialogKaiToast::Error, g_localizeStrings.Get(36000), g_localizeStrings.Get(36012)); + bConnectionFailedDisplayed = true; + + CThread::Sleep(10000ms); + } + } + + if (bIsOpen) + { + CLog::Log(LOGDEBUG, "{} - connection to the CEC adapter opened", __FUNCTION__); + + // read the configuration + libcec_configuration config; + if (m_cecAdapter->GetCurrentConfiguration(&config)) + { + // update the local configuration + std::unique_lock<CCriticalSection> lock(m_critSection); + SetConfigurationFromLibCEC(config); + } + } + + return bIsOpen; +} + +void CPeripheralCecAdapter::Process(void) +{ + if (!OpenConnection()) + return; + + { + std::unique_lock<CCriticalSection> lock(m_critSection); + m_iExitCode = EXITCODE_QUIT; + m_bGoingToStandby = false; + m_bIsRunning = true; + m_bActiveSourceBeforeStandby = false; + } + + CServiceBroker::GetAnnouncementManager()->AddAnnouncer(this); + + m_queryThread = new CPeripheralCecAdapterUpdateThread(this, &m_configuration); + m_queryThread->Create(false); + + while (!m_bStop) + { + if (!m_bStop) + ProcessVolumeChange(); + + if (!m_bStop) + ProcessActivateSource(); + + if (!m_bStop) + ProcessStandbyDevices(); + + if (!m_bStop) + CThread::Sleep(5ms); + } + + m_queryThread->StopThread(true); + + bool bSendStandbyCommands(false); + { + std::unique_lock<CCriticalSection> lock(m_critSection); + bSendStandbyCommands = m_iExitCode != EXITCODE_REBOOT && m_iExitCode != EXITCODE_RESTARTAPP && + !m_bDeviceRemoved && + (!m_bGoingToStandby || GetSettingBool("standby_tv_on_pc_standby")) && + GetSettingBool("enabled"); + + if (m_bGoingToStandby) + m_bActiveSourceBeforeStandby = m_cecAdapter->IsLibCECActiveSource(); + } + + if (bSendStandbyCommands) + { + if (m_cecAdapter->IsLibCECActiveSource()) + { + if (!m_configuration.powerOffDevices.IsEmpty()) + { + CLog::Log(LOGDEBUG, "{} - sending standby commands", __FUNCTION__); + m_standbySent = CDateTime::GetCurrentDateTime(); + m_cecAdapter->StandbyDevices(); + } + else if (m_bSendInactiveSource) + { + CLog::Log(LOGDEBUG, "{} - sending inactive source commands", __FUNCTION__); + m_cecAdapter->SetInactiveView(); + } + } + else + { + CLog::Log(LOGDEBUG, "{} - XBMC is not the active source, not sending any standby commands", + __FUNCTION__); + } + } + + m_cecAdapter->Close(); + + CLog::Log(LOGDEBUG, "{} - CEC adapter processor thread ended", __FUNCTION__); + + { + std::unique_lock<CCriticalSection> lock(m_critSection); + m_bStarted = false; + m_bIsRunning = false; + } +} + +bool CPeripheralCecAdapter::HasAudioControl(void) +{ + std::unique_lock<CCriticalSection> lock(m_critSection); + return m_bHasConnectedAudioSystem; +} + +void CPeripheralCecAdapter::SetAudioSystemConnected(bool bSetTo) +{ + std::unique_lock<CCriticalSection> lock(m_critSection); + m_bHasConnectedAudioSystem = bSetTo; +} + +void CPeripheralCecAdapter::ProcessVolumeChange(void) +{ + bool bSendRelease(false); + CecVolumeChange pendingVolumeChange = VOLUME_CHANGE_NONE; + { + std::unique_lock<CCriticalSection> lock(m_critSection); + auto now = std::chrono::steady_clock::now(); + auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(now - m_lastKeypress); + if (!m_volumeChangeQueue.empty()) + { + /* get the first change from the queue */ + pendingVolumeChange = m_volumeChangeQueue.front(); + m_volumeChangeQueue.pop(); + + /* remove all dupe entries */ + while (!m_volumeChangeQueue.empty() && m_volumeChangeQueue.front() == pendingVolumeChange) + m_volumeChangeQueue.pop(); + + /* send another keypress after VOLUME_REFRESH_TIMEOUT ms */ + + bool bRefresh(duration.count() > VOLUME_REFRESH_TIMEOUT); + + /* only send the keypress when it hasn't been sent yet */ + if (pendingVolumeChange != m_lastChange) + { + m_lastKeypress = std::chrono::steady_clock::now(); + m_lastChange = pendingVolumeChange; + } + else if (bRefresh) + { + m_lastKeypress = std::chrono::steady_clock::now(); + pendingVolumeChange = m_lastChange; + } + else + pendingVolumeChange = VOLUME_CHANGE_NONE; + } + else if (m_lastKeypress.time_since_epoch().count() > 0 && + duration.count() > VOLUME_CHANGE_TIMEOUT) + { + /* send a key release */ + m_lastKeypress = {}; + bSendRelease = true; + m_lastChange = VOLUME_CHANGE_NONE; + } + } + + switch (pendingVolumeChange) + { + case VOLUME_CHANGE_UP: + m_cecAdapter->SendKeypress(CECDEVICE_AUDIOSYSTEM, CEC_USER_CONTROL_CODE_VOLUME_UP, false); + break; + case VOLUME_CHANGE_DOWN: + m_cecAdapter->SendKeypress(CECDEVICE_AUDIOSYSTEM, CEC_USER_CONTROL_CODE_VOLUME_DOWN, false); + break; + case VOLUME_CHANGE_MUTE: + m_cecAdapter->SendKeypress(CECDEVICE_AUDIOSYSTEM, CEC_USER_CONTROL_CODE_MUTE, false); + { + std::unique_lock<CCriticalSection> lock(m_critSection); + m_bIsMuted = !m_bIsMuted; + } + break; + case VOLUME_CHANGE_NONE: + if (bSendRelease) + m_cecAdapter->SendKeyRelease(CECDEVICE_AUDIOSYSTEM, false); + break; + } +} + +void CPeripheralCecAdapter::VolumeUp(void) +{ + if (HasAudioControl()) + { + std::unique_lock<CCriticalSection> lock(m_critSection); + m_volumeChangeQueue.push(VOLUME_CHANGE_UP); + } +} + +void CPeripheralCecAdapter::VolumeDown(void) +{ + if (HasAudioControl()) + { + std::unique_lock<CCriticalSection> lock(m_critSection); + m_volumeChangeQueue.push(VOLUME_CHANGE_DOWN); + } +} + +void CPeripheralCecAdapter::ToggleMute(void) +{ + if (HasAudioControl()) + { + std::unique_lock<CCriticalSection> lock(m_critSection); + m_volumeChangeQueue.push(VOLUME_CHANGE_MUTE); + } +} + +bool CPeripheralCecAdapter::IsMuted(void) +{ + if (HasAudioControl()) + { + std::unique_lock<CCriticalSection> lock(m_critSection); + return m_bIsMuted; + } + return false; +} + +void CPeripheralCecAdapter::SetMenuLanguage(const char* strLanguage) +{ + if (StringUtils::EqualsNoCase(m_strMenuLanguage, strLanguage)) + return; + + std::string strGuiLanguage; + + if (!strcmp(strLanguage, "bul")) + strGuiLanguage = "bg_bg"; + else if (!strcmp(strLanguage, "hrv")) + strGuiLanguage = "hr_hr"; + else if (!strcmp(strLanguage, "cze")) + strGuiLanguage = "cs_cz"; + else if (!strcmp(strLanguage, "dan")) + strGuiLanguage = "da_dk"; + else if (!strcmp(strLanguage, "deu")) + strGuiLanguage = "de_de"; + else if (!strcmp(strLanguage, "dut")) + strGuiLanguage = "nl_nl"; + else if (!strcmp(strLanguage, "eng")) + strGuiLanguage = "en_gb"; + else if (!strcmp(strLanguage, "fin")) + strGuiLanguage = "fi_fi"; + else if (!strcmp(strLanguage, "fre")) + strGuiLanguage = "fr_fr"; + else if (!strcmp(strLanguage, "ger")) + strGuiLanguage = "de_de"; + else if (!strcmp(strLanguage, "gre")) + strGuiLanguage = "el_gr"; + else if (!strcmp(strLanguage, "hun")) + strGuiLanguage = "hu_hu"; + else if (!strcmp(strLanguage, "ita")) + strGuiLanguage = "it_it"; + else if (!strcmp(strLanguage, "nor")) + strGuiLanguage = "nb_no"; + else if (!strcmp(strLanguage, "pol")) + strGuiLanguage = "pl_pl"; + else if (!strcmp(strLanguage, "por")) + strGuiLanguage = "pt_pt"; + else if (!strcmp(strLanguage, "rum")) + strGuiLanguage = "ro_ro"; + else if (!strcmp(strLanguage, "rus")) + strGuiLanguage = "ru_ru"; + else if (!strcmp(strLanguage, "srp")) + strGuiLanguage = "sr_rs@latin"; + else if (!strcmp(strLanguage, "slo")) + strGuiLanguage = "sk_sk"; + else if (!strcmp(strLanguage, "slv")) + strGuiLanguage = "sl_si"; + else if (!strcmp(strLanguage, "spa")) + strGuiLanguage = "es_es"; + else if (!strcmp(strLanguage, "swe")) + strGuiLanguage = "sv_se"; + else if (!strcmp(strLanguage, "tur")) + strGuiLanguage = "tr_tr"; + + if (!strGuiLanguage.empty()) + { + strGuiLanguage = "resource.language." + strGuiLanguage; + CServiceBroker::GetAppMessenger()->PostMsg(TMSG_SETLANGUAGE, -1, -1, nullptr, strGuiLanguage); + CLog::Log(LOGDEBUG, "{} - language set to '{}'", __FUNCTION__, strGuiLanguage); + } + else + CLog::Log(LOGWARNING, "{} - TV menu language set to unknown value '{}'", __FUNCTION__, + strLanguage); +} + +void CPeripheralCecAdapter::OnTvStandby(void) +{ + int iActionOnTvStandby = GetSettingInt("standby_pc_on_tv_standby"); + switch (iActionOnTvStandby) + { + case LOCALISED_ID_POWEROFF: + m_bStarted = false; + CServiceBroker::GetAppMessenger()->PostMsg(TMSG_SYSTEM_POWERDOWN, TMSG_SHUTDOWN); + break; + case LOCALISED_ID_SUSPEND: + m_bStarted = false; + CServiceBroker::GetAppMessenger()->PostMsg(TMSG_SYSTEM_POWERDOWN, TMSG_SUSPEND); + break; + case LOCALISED_ID_HIBERNATE: + m_bStarted = false; + CServiceBroker::GetAppMessenger()->PostMsg(TMSG_SYSTEM_POWERDOWN, TMSG_HIBERNATE); + break; + case LOCALISED_ID_QUIT: + m_bStarted = false; + CServiceBroker::GetAppMessenger()->PostMsg(TMSG_QUIT); + break; + case LOCALISED_ID_PAUSE: + CServiceBroker::GetAppMessenger()->PostMsg(TMSG_MEDIA_PAUSE_IF_PLAYING); + break; + case LOCALISED_ID_STOP: + { + const auto& components = CServiceBroker::GetAppComponents(); + const auto appPlayer = components.GetComponent<CApplicationPlayer>(); + if (appPlayer->IsPlaying()) + CServiceBroker::GetAppMessenger()->PostMsg(TMSG_MEDIA_STOP); + break; + } + case LOCALISED_ID_IGNORE: + break; + default: + CLog::Log(LOGERROR, "{} - Unexpected [standby_pc_on_tv_standby] setting value", __FUNCTION__); + break; + } +} + +void CPeripheralCecAdapter::CecCommand(void* cbParam, const cec_command* command) +{ + CPeripheralCecAdapter* adapter = static_cast<CPeripheralCecAdapter*>(cbParam); + if (!adapter) + return; + + if (adapter->m_bIsReady) + { + switch (command->opcode) + { + case CEC_OPCODE_STANDBY: + if (command->initiator == CECDEVICE_TV && + (!adapter->m_standbySent.IsValid() || + CDateTime::GetCurrentDateTime() - adapter->m_standbySent > + CDateTimeSpan(0, 0, 0, SCREENSAVER_TIMEOUT))) + { + adapter->OnTvStandby(); + } + break; + case CEC_OPCODE_SET_MENU_LANGUAGE: + if (adapter->m_bUseTVMenuLanguage == 1 && command->initiator == CECDEVICE_TV && + command->parameters.size == 3) + { + char strNewLanguage[4]; + for (int iPtr = 0; iPtr < 3; iPtr++) + strNewLanguage[iPtr] = command->parameters[iPtr]; + strNewLanguage[3] = 0; + adapter->SetMenuLanguage(strNewLanguage); + } + break; + case CEC_OPCODE_DECK_CONTROL: + if (command->initiator == CECDEVICE_TV && command->parameters.size == 1 && + command->parameters[0] == CEC_DECK_CONTROL_MODE_STOP) + { + cec_keypress key; + key.duration = 500; + key.keycode = CEC_USER_CONTROL_CODE_STOP; + adapter->PushCecKeypress(key); + } + break; + case CEC_OPCODE_PLAY: + if (command->initiator == CECDEVICE_TV && command->parameters.size == 1) + { + if (command->parameters[0] == CEC_PLAY_MODE_PLAY_FORWARD) + { + cec_keypress key; + key.duration = 500; + key.keycode = CEC_USER_CONTROL_CODE_PLAY; + adapter->PushCecKeypress(key); + } + else if (command->parameters[0] == CEC_PLAY_MODE_PLAY_STILL) + { + cec_keypress key; + key.duration = 500; + key.keycode = CEC_USER_CONTROL_CODE_PAUSE; + adapter->PushCecKeypress(key); + } + } + break; + default: + break; + } + } +} + +void CPeripheralCecAdapter::CecConfiguration(void* cbParam, const libcec_configuration* config) +{ + CPeripheralCecAdapter* adapter = static_cast<CPeripheralCecAdapter*>(cbParam); + if (!adapter) + return; + + std::unique_lock<CCriticalSection> lock(adapter->m_critSection); + adapter->SetConfigurationFromLibCEC(*config); +} + +void CPeripheralCecAdapter::CecAlert(void* cbParam, + const libcec_alert alert, + const libcec_parameter data) +{ + CPeripheralCecAdapter* adapter = static_cast<CPeripheralCecAdapter*>(cbParam); + if (!adapter) + return; + + bool bReopenConnection(false); + int iAlertString(0); + switch (alert) + { + case CEC_ALERT_SERVICE_DEVICE: + iAlertString = 36027; + break; + case CEC_ALERT_CONNECTION_LOST: + bReopenConnection = true; + iAlertString = 36030; + break; +#if defined(CEC_ALERT_PERMISSION_ERROR) + case CEC_ALERT_PERMISSION_ERROR: + bReopenConnection = true; + iAlertString = 36031; + break; + case CEC_ALERT_PORT_BUSY: + bReopenConnection = true; + iAlertString = 36032; + break; +#endif + default: + break; + } + + // display the alert + if (iAlertString) + { + std::string strLog(g_localizeStrings.Get(iAlertString)); + if (data.paramType == CEC_PARAMETER_TYPE_STRING && data.paramData) + strLog += StringUtils::Format(" - {}", (const char*)data.paramData); + CGUIDialogKaiToast::QueueNotification(CGUIDialogKaiToast::Info, g_localizeStrings.Get(36000), + strLog); + } + + if (bReopenConnection) + { + // Reopen the connection asynchronously. Otherwise a deadlock may occur. + // Reconnect means destruction and recreation of our libcec instance, but libcec + // calls this callback function synchronously and must not be destroyed meanwhile. + adapter->ReopenConnection(true); + } +} + +void CPeripheralCecAdapter::CecKeyPress(void* cbParam, const cec_keypress* key) +{ + CPeripheralCecAdapter* adapter = static_cast<CPeripheralCecAdapter*>(cbParam); + if (!!adapter) + adapter->PushCecKeypress(*key); +} + +void CPeripheralCecAdapter::GetNextKey(void) +{ + std::unique_lock<CCriticalSection> lock(m_critSection); + m_bHasButton = false; + if (m_bIsReady) + { + std::vector<CecButtonPress>::iterator it = m_buttonQueue.begin(); + if (it != m_buttonQueue.end()) + { + m_currentButton = (*it); + m_buttonQueue.erase(it); + m_bHasButton = true; + } + } +} + +void CPeripheralCecAdapter::PushCecKeypress(const CecButtonPress& key) +{ + CLog::Log(LOGDEBUG, "{} - received key {:2x} duration {}", __FUNCTION__, key.iButton, + key.iDuration); + + std::unique_lock<CCriticalSection> lock(m_critSection); + // avoid the queue getting too long + if (m_configuration.iButtonRepeatRateMs && m_buttonQueue.size() > 5) + return; + if (m_configuration.iButtonRepeatRateMs == 0 && key.iDuration > 0) + { + if (m_currentButton.iButton == key.iButton && m_currentButton.iDuration == 0) + { + // update the duration + if (m_bHasButton) + m_currentButton.iDuration = key.iDuration; + // ignore this one, since it's already been handled by xbmc + return; + } + // if we received a keypress with a duration set, try to find the same one without a duration + // set, and replace it + for (std::vector<CecButtonPress>::reverse_iterator it = m_buttonQueue.rbegin(); + it != m_buttonQueue.rend(); ++it) + { + if ((*it).iButton == key.iButton) + { + if ((*it).iDuration == 0) + { + // replace this entry + (*it).iDuration = key.iDuration; + return; + } + // add a new entry + break; + } + } + } + + m_buttonQueue.push_back(key); +} + +void CPeripheralCecAdapter::PushCecKeypress(const cec_keypress& key) +{ + CecButtonPress xbmcKey; + xbmcKey.iDuration = key.duration; + + switch (key.keycode) + { + case CEC_USER_CONTROL_CODE_SELECT: + xbmcKey.iButton = XINPUT_IR_REMOTE_SELECT; + PushCecKeypress(xbmcKey); + break; + case CEC_USER_CONTROL_CODE_UP: + xbmcKey.iButton = XINPUT_IR_REMOTE_UP; + PushCecKeypress(xbmcKey); + break; + case CEC_USER_CONTROL_CODE_DOWN: + xbmcKey.iButton = XINPUT_IR_REMOTE_DOWN; + PushCecKeypress(xbmcKey); + break; + case CEC_USER_CONTROL_CODE_LEFT: + xbmcKey.iButton = XINPUT_IR_REMOTE_LEFT; + PushCecKeypress(xbmcKey); + break; + case CEC_USER_CONTROL_CODE_LEFT_UP: + xbmcKey.iButton = XINPUT_IR_REMOTE_LEFT; + PushCecKeypress(xbmcKey); + xbmcKey.iButton = XINPUT_IR_REMOTE_UP; + PushCecKeypress(xbmcKey); + break; + case CEC_USER_CONTROL_CODE_LEFT_DOWN: + xbmcKey.iButton = XINPUT_IR_REMOTE_LEFT; + PushCecKeypress(xbmcKey); + xbmcKey.iButton = XINPUT_IR_REMOTE_DOWN; + PushCecKeypress(xbmcKey); + break; + case CEC_USER_CONTROL_CODE_RIGHT: + xbmcKey.iButton = XINPUT_IR_REMOTE_RIGHT; + PushCecKeypress(xbmcKey); + break; + case CEC_USER_CONTROL_CODE_RIGHT_UP: + xbmcKey.iButton = XINPUT_IR_REMOTE_RIGHT; + PushCecKeypress(xbmcKey); + xbmcKey.iButton = XINPUT_IR_REMOTE_UP; + PushCecKeypress(xbmcKey); + break; + case CEC_USER_CONTROL_CODE_RIGHT_DOWN: + xbmcKey.iButton = XINPUT_IR_REMOTE_RIGHT; + PushCecKeypress(xbmcKey); + xbmcKey.iButton = XINPUT_IR_REMOTE_DOWN; + PushCecKeypress(xbmcKey); + break; + case CEC_USER_CONTROL_CODE_SETUP_MENU: + xbmcKey.iButton = XINPUT_IR_REMOTE_TITLE; + PushCecKeypress(xbmcKey); + break; + case CEC_USER_CONTROL_CODE_CONTENTS_MENU: + xbmcKey.iButton = XINPUT_IR_REMOTE_CONTENTS_MENU; + PushCecKeypress(xbmcKey); + break; + case CEC_USER_CONTROL_CODE_ROOT_MENU: + xbmcKey.iButton = XINPUT_IR_REMOTE_ROOT_MENU; + PushCecKeypress(xbmcKey); + break; + case CEC_USER_CONTROL_CODE_TOP_MENU: + xbmcKey.iButton = XINPUT_IR_REMOTE_TOP_MENU; + PushCecKeypress(xbmcKey); + break; + case CEC_USER_CONTROL_CODE_DVD_MENU: + xbmcKey.iButton = XINPUT_IR_REMOTE_DVD_MENU; + PushCecKeypress(xbmcKey); + break; + case CEC_USER_CONTROL_CODE_FAVORITE_MENU: + xbmcKey.iButton = XINPUT_IR_REMOTE_MENU; + PushCecKeypress(xbmcKey); + break; + case CEC_USER_CONTROL_CODE_EXIT: + xbmcKey.iButton = XINPUT_IR_REMOTE_BACK; + PushCecKeypress(xbmcKey); + break; + case CEC_USER_CONTROL_CODE_ENTER: + xbmcKey.iButton = XINPUT_IR_REMOTE_ENTER; + PushCecKeypress(xbmcKey); + break; + case CEC_USER_CONTROL_CODE_CHANNEL_DOWN: + xbmcKey.iButton = XINPUT_IR_REMOTE_CHANNEL_MINUS; + PushCecKeypress(xbmcKey); + break; + case CEC_USER_CONTROL_CODE_CHANNEL_UP: + xbmcKey.iButton = XINPUT_IR_REMOTE_CHANNEL_PLUS; + PushCecKeypress(xbmcKey); + break; + case CEC_USER_CONTROL_CODE_PREVIOUS_CHANNEL: + xbmcKey.iButton = XINPUT_IR_REMOTE_TELETEXT; + PushCecKeypress(xbmcKey); + break; + case CEC_USER_CONTROL_CODE_SOUND_SELECT: + xbmcKey.iButton = XINPUT_IR_REMOTE_LANGUAGE; + PushCecKeypress(xbmcKey); + break; + case CEC_USER_CONTROL_CODE_POWER: + case CEC_USER_CONTROL_CODE_POWER_TOGGLE_FUNCTION: + case CEC_USER_CONTROL_CODE_POWER_OFF_FUNCTION: + xbmcKey.iButton = XINPUT_IR_REMOTE_POWER; + PushCecKeypress(xbmcKey); + break; + case CEC_USER_CONTROL_CODE_VOLUME_UP: + xbmcKey.iButton = XINPUT_IR_REMOTE_VOLUME_PLUS; + PushCecKeypress(xbmcKey); + break; + case CEC_USER_CONTROL_CODE_VOLUME_DOWN: + xbmcKey.iButton = XINPUT_IR_REMOTE_VOLUME_MINUS; + PushCecKeypress(xbmcKey); + break; + case CEC_USER_CONTROL_CODE_MUTE: + case CEC_USER_CONTROL_CODE_MUTE_FUNCTION: + case CEC_USER_CONTROL_CODE_RESTORE_VOLUME_FUNCTION: + xbmcKey.iButton = XINPUT_IR_REMOTE_MUTE; + PushCecKeypress(xbmcKey); + break; + case CEC_USER_CONTROL_CODE_PLAY: + xbmcKey.iButton = XINPUT_IR_REMOTE_PLAY; + PushCecKeypress(xbmcKey); + break; + case CEC_USER_CONTROL_CODE_STOP: + xbmcKey.iButton = XINPUT_IR_REMOTE_STOP; + PushCecKeypress(xbmcKey); + break; + case CEC_USER_CONTROL_CODE_PAUSE: + xbmcKey.iButton = XINPUT_IR_REMOTE_PAUSE; + PushCecKeypress(xbmcKey); + break; + case CEC_USER_CONTROL_CODE_REWIND: + xbmcKey.iButton = XINPUT_IR_REMOTE_REVERSE; + PushCecKeypress(xbmcKey); + break; + case CEC_USER_CONTROL_CODE_FAST_FORWARD: + xbmcKey.iButton = XINPUT_IR_REMOTE_FORWARD; + PushCecKeypress(xbmcKey); + break; + case CEC_USER_CONTROL_CODE_NUMBER0: + xbmcKey.iButton = XINPUT_IR_REMOTE_0; + PushCecKeypress(xbmcKey); + break; + case CEC_USER_CONTROL_CODE_NUMBER1: + xbmcKey.iButton = XINPUT_IR_REMOTE_1; + PushCecKeypress(xbmcKey); + break; + case CEC_USER_CONTROL_CODE_NUMBER2: + xbmcKey.iButton = XINPUT_IR_REMOTE_2; + PushCecKeypress(xbmcKey); + break; + case CEC_USER_CONTROL_CODE_NUMBER3: + xbmcKey.iButton = XINPUT_IR_REMOTE_3; + PushCecKeypress(xbmcKey); + break; + case CEC_USER_CONTROL_CODE_NUMBER4: + xbmcKey.iButton = XINPUT_IR_REMOTE_4; + PushCecKeypress(xbmcKey); + break; + case CEC_USER_CONTROL_CODE_NUMBER5: + xbmcKey.iButton = XINPUT_IR_REMOTE_5; + PushCecKeypress(xbmcKey); + break; + case CEC_USER_CONTROL_CODE_NUMBER6: + xbmcKey.iButton = XINPUT_IR_REMOTE_6; + PushCecKeypress(xbmcKey); + break; + case CEC_USER_CONTROL_CODE_NUMBER7: + xbmcKey.iButton = XINPUT_IR_REMOTE_7; + PushCecKeypress(xbmcKey); + break; + case CEC_USER_CONTROL_CODE_NUMBER8: + xbmcKey.iButton = XINPUT_IR_REMOTE_8; + PushCecKeypress(xbmcKey); + break; + case CEC_USER_CONTROL_CODE_NUMBER9: + xbmcKey.iButton = XINPUT_IR_REMOTE_9; + PushCecKeypress(xbmcKey); + break; + case CEC_USER_CONTROL_CODE_RECORD: + xbmcKey.iButton = XINPUT_IR_REMOTE_RECORD; + PushCecKeypress(xbmcKey); + break; + case CEC_USER_CONTROL_CODE_CLEAR: + xbmcKey.iButton = XINPUT_IR_REMOTE_CLEAR; + PushCecKeypress(xbmcKey); + break; + case CEC_USER_CONTROL_CODE_DISPLAY_INFORMATION: + xbmcKey.iButton = XINPUT_IR_REMOTE_INFO; + PushCecKeypress(xbmcKey); + break; + case CEC_USER_CONTROL_CODE_PAGE_UP: + xbmcKey.iButton = XINPUT_IR_REMOTE_CHANNEL_PLUS; + PushCecKeypress(xbmcKey); + break; + case CEC_USER_CONTROL_CODE_PAGE_DOWN: + xbmcKey.iButton = XINPUT_IR_REMOTE_CHANNEL_MINUS; + PushCecKeypress(xbmcKey); + break; + case CEC_USER_CONTROL_CODE_FORWARD: + xbmcKey.iButton = XINPUT_IR_REMOTE_SKIP_PLUS; + PushCecKeypress(xbmcKey); + break; + case CEC_USER_CONTROL_CODE_BACKWARD: + xbmcKey.iButton = XINPUT_IR_REMOTE_SKIP_MINUS; + PushCecKeypress(xbmcKey); + break; + case CEC_USER_CONTROL_CODE_F1_BLUE: + xbmcKey.iButton = XINPUT_IR_REMOTE_BLUE; + PushCecKeypress(xbmcKey); + break; + case CEC_USER_CONTROL_CODE_F2_RED: + xbmcKey.iButton = XINPUT_IR_REMOTE_RED; + PushCecKeypress(xbmcKey); + break; + case CEC_USER_CONTROL_CODE_F3_GREEN: + xbmcKey.iButton = XINPUT_IR_REMOTE_GREEN; + PushCecKeypress(xbmcKey); + break; + case CEC_USER_CONTROL_CODE_F4_YELLOW: + xbmcKey.iButton = XINPUT_IR_REMOTE_YELLOW; + PushCecKeypress(xbmcKey); + break; + case CEC_USER_CONTROL_CODE_ELECTRONIC_PROGRAM_GUIDE: + xbmcKey.iButton = XINPUT_IR_REMOTE_GUIDE; + PushCecKeypress(xbmcKey); + break; + case CEC_USER_CONTROL_CODE_AN_CHANNELS_LIST: + xbmcKey.iButton = XINPUT_IR_REMOTE_LIVE_TV; + PushCecKeypress(xbmcKey); + break; + case CEC_USER_CONTROL_CODE_NEXT_FAVORITE: + case CEC_USER_CONTROL_CODE_DOT: + case CEC_USER_CONTROL_CODE_AN_RETURN: + xbmcKey.iButton = XINPUT_IR_REMOTE_TITLE; // context menu + PushCecKeypress(xbmcKey); + break; + case CEC_USER_CONTROL_CODE_DATA: + xbmcKey.iButton = XINPUT_IR_REMOTE_TELETEXT; + PushCecKeypress(xbmcKey); + break; + case CEC_USER_CONTROL_CODE_SUB_PICTURE: + xbmcKey.iButton = XINPUT_IR_REMOTE_SUBTITLE; + PushCecKeypress(xbmcKey); + break; + case CEC_USER_CONTROL_CODE_EJECT: + xbmcKey.iButton = XINPUT_IR_REMOTE_EJECT; + PushCecKeypress(xbmcKey); + break; + case CEC_USER_CONTROL_CODE_POWER_ON_FUNCTION: + case CEC_USER_CONTROL_CODE_INPUT_SELECT: + case CEC_USER_CONTROL_CODE_INITIAL_CONFIGURATION: + case CEC_USER_CONTROL_CODE_HELP: + case CEC_USER_CONTROL_CODE_STOP_RECORD: + case CEC_USER_CONTROL_CODE_PAUSE_RECORD: + case CEC_USER_CONTROL_CODE_ANGLE: + case CEC_USER_CONTROL_CODE_VIDEO_ON_DEMAND: + case CEC_USER_CONTROL_CODE_TIMER_PROGRAMMING: + case CEC_USER_CONTROL_CODE_PLAY_FUNCTION: + case CEC_USER_CONTROL_CODE_PAUSE_PLAY_FUNCTION: + case CEC_USER_CONTROL_CODE_RECORD_FUNCTION: + case CEC_USER_CONTROL_CODE_PAUSE_RECORD_FUNCTION: + case CEC_USER_CONTROL_CODE_STOP_FUNCTION: + case CEC_USER_CONTROL_CODE_TUNE_FUNCTION: + case CEC_USER_CONTROL_CODE_SELECT_MEDIA_FUNCTION: + case CEC_USER_CONTROL_CODE_SELECT_AV_INPUT_FUNCTION: + case CEC_USER_CONTROL_CODE_SELECT_AUDIO_INPUT_FUNCTION: + case CEC_USER_CONTROL_CODE_F5: + case CEC_USER_CONTROL_CODE_NUMBER_ENTRY_MODE: + case CEC_USER_CONTROL_CODE_NUMBER11: + case CEC_USER_CONTROL_CODE_NUMBER12: + case CEC_USER_CONTROL_CODE_SELECT_BROADCAST_TYPE: + case CEC_USER_CONTROL_CODE_SELECT_SOUND_PRESENTATION: + case CEC_USER_CONTROL_CODE_UNKNOWN: + default: + break; + } +} + +int CPeripheralCecAdapter::GetButton(void) +{ + std::unique_lock<CCriticalSection> lock(m_critSection); + if (!m_bHasButton) + GetNextKey(); + + return m_bHasButton ? m_currentButton.iButton : 0; +} + +unsigned int CPeripheralCecAdapter::GetHoldTime(void) +{ + std::unique_lock<CCriticalSection> lock(m_critSection); + if (!m_bHasButton) + GetNextKey(); + + return m_bHasButton ? m_currentButton.iDuration : 0; +} + +void CPeripheralCecAdapter::ResetButton(void) +{ + std::unique_lock<CCriticalSection> lock(m_critSection); + m_bHasButton = false; + + // wait for the key release if the duration isn't 0 + if (m_currentButton.iDuration > 0) + { + m_currentButton.iButton = 0; + m_currentButton.iDuration = 0; + } +} + +void CPeripheralCecAdapter::OnSettingChanged(const std::string& strChangedSetting) +{ + if (StringUtils::EqualsNoCase(strChangedSetting, "enabled")) + { + bool bEnabled(GetSettingBool("enabled")); + if (!bEnabled && IsRunning()) + { + CLog::Log(LOGDEBUG, "{} - closing the CEC connection", __FUNCTION__); + StopThread(true); + } + else if (bEnabled && !IsRunning()) + { + CLog::Log(LOGDEBUG, "{} - starting the CEC connection", __FUNCTION__); + SetConfigurationFromSettings(); + InitialiseFeature(FEATURE_CEC); + } + } + else if (IsRunning()) + { + if (m_queryThread->IsRunning()) + { + CLog::Log(LOGDEBUG, "{} - sending the updated configuration to libCEC", __FUNCTION__); + SetConfigurationFromSettings(); + m_queryThread->UpdateConfiguration(&m_configuration); + } + } + else + { + CLog::Log(LOGDEBUG, "{} - restarting the CEC connection", __FUNCTION__); + SetConfigurationFromSettings(); + InitialiseFeature(FEATURE_CEC); + } +} + +void CPeripheralCecAdapter::CecSourceActivated(void* cbParam, + const CEC::cec_logical_address address, + const uint8_t activated) +{ + CPeripheralCecAdapter* adapter = static_cast<CPeripheralCecAdapter*>(cbParam); + if (!adapter) + return; + + // wake up the screensaver, so the user doesn't switch to a black screen + if (activated == 1) + { + auto& components = CServiceBroker::GetAppComponents(); + const auto appPower = components.GetComponent<CApplicationPowerHandling>(); + appPower->WakeUpScreenSaverAndDPMS(); + } + + if (adapter->GetSettingInt("pause_or_stop_playback_on_deactivate") != LOCALISED_ID_NONE) + { + bool bShowingSlideshow = + (CServiceBroker::GetGUI()->GetWindowManager().GetActiveWindow() == WINDOW_SLIDESHOW); + CGUIWindowSlideShow* pSlideShow = + bShowingSlideshow + ? CServiceBroker::GetGUI()->GetWindowManager().GetWindow<CGUIWindowSlideShow>( + WINDOW_SLIDESHOW) + : NULL; + + const auto& components = CServiceBroker::GetAppComponents(); + const auto appPlayer = components.GetComponent<CApplicationPlayer>(); + + bool bPlayingAndDeactivated = activated == 0 && ((pSlideShow && pSlideShow->IsPlaying()) || + !appPlayer->IsPausedPlayback()); + bool bPausedAndActivated = + activated == 1 && adapter->m_bPlaybackPaused && + ((pSlideShow && pSlideShow->IsPaused()) || (appPlayer && appPlayer->IsPausedPlayback())); + if (bPlayingAndDeactivated) + adapter->m_bPlaybackPaused = true; + else if (bPausedAndActivated) + adapter->m_bPlaybackPaused = false; + + if ((bPlayingAndDeactivated || bPausedAndActivated) && + adapter->GetSettingInt("pause_or_stop_playback_on_deactivate") == LOCALISED_ID_PAUSE) + { + if (pSlideShow) + // pause/resume slideshow + pSlideShow->OnAction(CAction(ACTION_PAUSE)); + else + // pause/resume player + CServiceBroker::GetAppMessenger()->SendMsg(TMSG_MEDIA_PAUSE); + } + else if (bPlayingAndDeactivated && + adapter->GetSettingInt("pause_or_stop_playback_on_deactivate") == LOCALISED_ID_STOP) + { + if (pSlideShow) + pSlideShow->OnAction(CAction(ACTION_STOP)); + else + CServiceBroker::GetAppMessenger()->SendMsg(TMSG_MEDIA_STOP); + } + } +} + +void CPeripheralCecAdapter::CecLogMessage(void* cbParam, const cec_log_message* message) +{ + CPeripheralCecAdapter* adapter = static_cast<CPeripheralCecAdapter*>(cbParam); + if (!adapter) + return; + + int iLevel = -1; + switch (message->level) + { + case CEC_LOG_ERROR: + iLevel = LOGERROR; + break; + case CEC_LOG_WARNING: + iLevel = LOGWARNING; + break; + case CEC_LOG_NOTICE: + iLevel = LOGDEBUG; + break; + case CEC_LOG_TRAFFIC: + case CEC_LOG_DEBUG: + iLevel = LOGDEBUG; + break; + default: + break; + } + + if (iLevel >= CEC_LOG_NOTICE || + (iLevel >= 0 && CServiceBroker::GetLogging().IsLogLevelLogged(LOGDEBUG))) + CLog::Log(iLevel, LOGCEC, "{} - {}", __FUNCTION__, message->message); +} + +void CPeripheralCecAdapter::SetConfigurationFromLibCEC(const CEC::libcec_configuration& config) +{ + bool bChanged(false); + + // set the primary device type + m_configuration.deviceTypes.Clear(); + m_configuration.deviceTypes.Add(config.deviceTypes[0]); + + // hide the "connected device" and "hdmi port number" settings when the PA was autodetected + bool bPAAutoDetected(config.bAutodetectAddress == 1); + + SetSettingVisible("connected_device", !bPAAutoDetected); + SetSettingVisible("cec_hdmi_port", !bPAAutoDetected); + + // set the connected device + m_configuration.baseDevice = config.baseDevice; + bChanged |= + SetSetting("connected_device", + config.baseDevice == CECDEVICE_AUDIOSYSTEM ? LOCALISED_ID_AVR : LOCALISED_ID_TV); + + // set the HDMI port number + m_configuration.iHDMIPort = config.iHDMIPort; + bChanged |= SetSetting("cec_hdmi_port", config.iHDMIPort); + + // set the physical address, when baseDevice or iHDMIPort are not set + std::string strPhysicalAddress("0"); + if (!bPAAutoDetected && (m_configuration.baseDevice == CECDEVICE_UNKNOWN || + m_configuration.iHDMIPort < CEC_MIN_HDMI_PORTNUMBER || + m_configuration.iHDMIPort > CEC_MAX_HDMI_PORTNUMBER)) + { + m_configuration.iPhysicalAddress = config.iPhysicalAddress; + strPhysicalAddress = StringUtils::Format("{:x}", config.iPhysicalAddress); + } + bChanged |= SetSetting("physical_address", strPhysicalAddress); + + // set the devices to wake when starting + m_configuration.wakeDevices = config.wakeDevices; + bChanged |= WriteLogicalAddresses(config.wakeDevices, "wake_devices", "wake_devices_advanced"); + + // set the devices to power off when stopping + m_configuration.powerOffDevices = config.powerOffDevices; + bChanged |= + WriteLogicalAddresses(config.powerOffDevices, "standby_devices", "standby_devices_advanced"); + + // set the boolean settings + m_configuration.bActivateSource = config.bActivateSource; + bChanged |= SetSetting("activate_source", m_configuration.bActivateSource == 1); + + m_configuration.iDoubleTapTimeoutMs = config.iDoubleTapTimeoutMs; + bChanged |= SetSetting("double_tap_timeout_ms", (int)m_configuration.iDoubleTapTimeoutMs); + + m_configuration.iButtonRepeatRateMs = config.iButtonRepeatRateMs; + bChanged |= SetSetting("button_repeat_rate_ms", (int)m_configuration.iButtonRepeatRateMs); + + m_configuration.iButtonReleaseDelayMs = config.iButtonReleaseDelayMs; + bChanged |= SetSetting("button_release_delay_ms", (int)m_configuration.iButtonReleaseDelayMs); + + m_configuration.bPowerOffOnStandby = config.bPowerOffOnStandby; + + m_configuration.iFirmwareVersion = config.iFirmwareVersion; + + memcpy(m_configuration.strDeviceLanguage, config.strDeviceLanguage, 3); + m_configuration.iFirmwareBuildDate = config.iFirmwareBuildDate; + + SetVersionInfo(m_configuration); + + if (bChanged) + CLog::Log(LOGDEBUG, "SetConfigurationFromLibCEC - settings updated by libCEC"); +} + +void CPeripheralCecAdapter::SetConfigurationFromSettings(void) +{ + // client version matches the version of libCEC that we originally used the API from + m_configuration.clientVersion = LIBCEC_VERSION_TO_UINT(4, 0, 0); + + // device name 'XBMC' + snprintf(m_configuration.strDeviceName, 13, "%s", GetSettingString("device_name").c_str()); + + // set the primary device type + m_configuration.deviceTypes.Clear(); + switch (GetSettingInt("device_type")) + { + case LOCALISED_ID_PLAYBACK_DEVICE: + m_configuration.deviceTypes.Add(CEC_DEVICE_TYPE_PLAYBACK_DEVICE); + break; + case LOCALISED_ID_TUNER_DEVICE: + m_configuration.deviceTypes.Add(CEC_DEVICE_TYPE_TUNER); + break; + case LOCALISED_ID_RECORDING_DEVICE: + default: + m_configuration.deviceTypes.Add(CEC_DEVICE_TYPE_RECORDING_DEVICE); + break; + } + + // always try to autodetect the address. + // when the firmware supports this, it will override the physical address, connected device and + // hdmi port settings + m_configuration.bAutodetectAddress = CEC_DEFAULT_SETTING_AUTODETECT_ADDRESS; + + // set the physical address + // when set, it will override the connected device and hdmi port settings + std::string strPhysicalAddress = GetSettingString("physical_address"); + int iPhysicalAddress; + if (sscanf(strPhysicalAddress.c_str(), "%x", &iPhysicalAddress) && + iPhysicalAddress >= CEC_PHYSICAL_ADDRESS_TV && iPhysicalAddress <= CEC_MAX_PHYSICAL_ADDRESS) + m_configuration.iPhysicalAddress = iPhysicalAddress; + else + m_configuration.iPhysicalAddress = CEC_PHYSICAL_ADDRESS_TV; + + // set the connected device + int iConnectedDevice = GetSettingInt("connected_device"); + if (iConnectedDevice == LOCALISED_ID_AVR) + m_configuration.baseDevice = CECDEVICE_AUDIOSYSTEM; + else if (iConnectedDevice == LOCALISED_ID_TV) + m_configuration.baseDevice = CECDEVICE_TV; + + // set the HDMI port number + int iHDMIPort = GetSettingInt("cec_hdmi_port"); + if (iHDMIPort >= CEC_MIN_HDMI_PORTNUMBER && iHDMIPort <= CEC_MAX_HDMI_PORTNUMBER) + m_configuration.iHDMIPort = iHDMIPort; + + // set the tv vendor override + int iVendor = GetSettingInt("tv_vendor"); + if (iVendor >= CEC_MIN_VENDORID && iVendor <= CEC_MAX_VENDORID) + m_configuration.tvVendor = iVendor; + + // read the devices to wake when starting + std::string strWakeDevices = GetSettingString("wake_devices_advanced"); + StringUtils::Trim(strWakeDevices); + m_configuration.wakeDevices.Clear(); + if (!strWakeDevices.empty()) + ReadLogicalAddresses(strWakeDevices, m_configuration.wakeDevices); + else + ReadLogicalAddresses(GetSettingInt("wake_devices"), m_configuration.wakeDevices); + + // read the devices to power off when stopping + std::string strStandbyDevices = GetSettingString("standby_devices_advanced"); + StringUtils::Trim(strStandbyDevices); + m_configuration.powerOffDevices.Clear(); + if (!strStandbyDevices.empty()) + ReadLogicalAddresses(strStandbyDevices, m_configuration.powerOffDevices); + else + ReadLogicalAddresses(GetSettingInt("standby_devices"), m_configuration.powerOffDevices); + + // read the boolean settings + m_bUseTVMenuLanguage = GetSettingBool("use_tv_menu_language"); + m_configuration.bActivateSource = GetSettingBool("activate_source") ? 1 : 0; + m_bPowerOffScreensaver = GetSettingBool("cec_standby_screensaver"); + m_bPowerOnScreensaver = GetSettingBool("cec_wake_screensaver"); + m_bSendInactiveSource = GetSettingBool("send_inactive_source"); + m_configuration.bAutoWakeAVR = GetSettingBool("power_avr_on_as") ? 1 : 0; + + // read the mutually exclusive boolean settings + int iStandbyAction(GetSettingInt("standby_pc_on_tv_standby")); + m_configuration.bPowerOffOnStandby = + (iStandbyAction == LOCALISED_ID_SUSPEND || iStandbyAction == LOCALISED_ID_HIBERNATE) ? 1 : 0; + m_bShutdownOnStandby = iStandbyAction == LOCALISED_ID_POWEROFF; + + // double tap prevention timeout in ms + m_configuration.iDoubleTapTimeoutMs = GetSettingInt("double_tap_timeout_ms"); + m_configuration.iButtonRepeatRateMs = GetSettingInt("button_repeat_rate_ms"); + m_configuration.iButtonReleaseDelayMs = GetSettingInt("button_release_delay_ms"); + + if (GetSettingBool("pause_playback_on_deactivate")) + { + SetSetting("pause_or_stop_playback_on_deactivate", LOCALISED_ID_PAUSE); + SetSetting("pause_playback_on_deactivate", false); + } +} + +void CPeripheralCecAdapter::ReadLogicalAddresses(const std::string& strString, + cec_logical_addresses& addresses) +{ + for (size_t iPtr = 0; iPtr < strString.size(); iPtr++) + { + std::string strDevice = strString.substr(iPtr, 1); + StringUtils::Trim(strDevice); + if (!strDevice.empty()) + { + int iDevice(0); + if (sscanf(strDevice.c_str(), "%x", &iDevice) == 1 && iDevice >= 0 && iDevice <= 0xF) + addresses.Set((cec_logical_address)iDevice); + } + } +} + +void CPeripheralCecAdapter::ReadLogicalAddresses(int iLocalisedId, cec_logical_addresses& addresses) +{ + addresses.Clear(); + switch (iLocalisedId) + { + case LOCALISED_ID_TV: + addresses.Set(CECDEVICE_TV); + break; + case LOCALISED_ID_AVR: + addresses.Set(CECDEVICE_AUDIOSYSTEM); + break; + case LOCALISED_ID_TV_AVR: + addresses.Set(CECDEVICE_TV); + addresses.Set(CECDEVICE_AUDIOSYSTEM); + break; + case LOCALISED_ID_NONE: + default: + break; + } +} + +bool CPeripheralCecAdapter::WriteLogicalAddresses(const cec_logical_addresses& addresses, + const std::string& strSettingName, + const std::string& strAdvancedSettingName) +{ + bool bChanged(false); + + // only update the advanced setting if it was set by the user + if (!GetSettingString(strAdvancedSettingName).empty()) + { + std::string strPowerOffDevices; + for (unsigned int iPtr = CECDEVICE_TV; iPtr <= CECDEVICE_BROADCAST; iPtr++) + if (addresses[iPtr]) + strPowerOffDevices += StringUtils::Format(" {:X}", iPtr); + StringUtils::Trim(strPowerOffDevices); + bChanged = SetSetting(strAdvancedSettingName, strPowerOffDevices); + } + + int iSettingPowerOffDevices = LOCALISED_ID_NONE; + if (addresses[CECDEVICE_TV] && addresses[CECDEVICE_AUDIOSYSTEM]) + iSettingPowerOffDevices = LOCALISED_ID_TV_AVR; + else if (addresses[CECDEVICE_TV]) + iSettingPowerOffDevices = LOCALISED_ID_TV; + else if (addresses[CECDEVICE_AUDIOSYSTEM]) + iSettingPowerOffDevices = LOCALISED_ID_AVR; + return SetSetting(strSettingName, iSettingPowerOffDevices) || bChanged; +} + +CPeripheralCecAdapterUpdateThread::CPeripheralCecAdapterUpdateThread( + CPeripheralCecAdapter* adapter, libcec_configuration* configuration) + : CThread("CECAdapterUpdate"), + m_adapter(adapter), + m_configuration(*configuration), + m_bNextConfigurationScheduled(false), + m_bIsUpdating(true) +{ + m_nextConfiguration.Clear(); + m_event.Reset(); +} + +CPeripheralCecAdapterUpdateThread::~CPeripheralCecAdapterUpdateThread(void) +{ + StopThread(false); + m_event.Set(); + StopThread(true); +} + +void CPeripheralCecAdapterUpdateThread::Signal(void) +{ + m_event.Set(); +} + +bool CPeripheralCecAdapterUpdateThread::UpdateConfiguration(libcec_configuration* configuration) +{ + std::unique_lock<CCriticalSection> lock(m_critSection); + if (!configuration) + return false; + + if (m_bIsUpdating) + { + m_bNextConfigurationScheduled = true; + m_nextConfiguration = *configuration; + } + else + { + m_configuration = *configuration; + m_event.Set(); + } + return true; +} + +bool CPeripheralCecAdapterUpdateThread::WaitReady(void) +{ + // don't wait if we're not powering up anything + if (m_configuration.wakeDevices.IsEmpty() && m_configuration.bActivateSource == 0) + return true; + + // wait for the TV if we're configured to become the active source. + // wait for the first device in the wake list otherwise. + cec_logical_address waitFor = + (m_configuration.bActivateSource == 1) ? CECDEVICE_TV : m_configuration.wakeDevices.primary; + + cec_power_status powerStatus(CEC_POWER_STATUS_UNKNOWN); + bool bContinue(true); + while (bContinue && !m_adapter->m_bStop && !m_bStop && powerStatus != CEC_POWER_STATUS_ON) + { + powerStatus = m_adapter->m_cecAdapter->GetDevicePowerStatus(waitFor); + if (powerStatus != CEC_POWER_STATUS_ON) + bContinue = !m_event.Wait(1000ms); + } + + return powerStatus == CEC_POWER_STATUS_ON; +} + +void CPeripheralCecAdapterUpdateThread::UpdateMenuLanguage(void) +{ + // request the menu language of the TV + if (m_adapter->m_bUseTVMenuLanguage == 1) + { + CLog::Log(LOGDEBUG, "{} - requesting the menu language of the TV", __FUNCTION__); + std::string language(m_adapter->m_cecAdapter->GetDeviceMenuLanguage(CECDEVICE_TV)); + m_adapter->SetMenuLanguage(language.c_str()); + } + else + { + CLog::Log(LOGDEBUG, "{} - using TV menu language is disabled", __FUNCTION__); + } +} + +std::string CPeripheralCecAdapterUpdateThread::UpdateAudioSystemStatus(void) +{ + std::string strAmpName; + + /* disable the mute setting when an amp is found, because the amp handles the mute setting and + set PCM output to 100% */ + if (m_adapter->m_cecAdapter->IsActiveDeviceType(CEC_DEVICE_TYPE_AUDIO_SYSTEM)) + { + // request the OSD name of the amp + std::string ampName(m_adapter->m_cecAdapter->GetDeviceOSDName(CECDEVICE_AUDIOSYSTEM)); + CLog::Log(LOGDEBUG, + "{} - CEC capable amplifier found ({}). volume will be controlled on the amp", + __FUNCTION__, ampName); + strAmpName += ampName; + + // set amp present + m_adapter->SetAudioSystemConnected(true); + auto& components = CServiceBroker::GetAppComponents(); + const auto appVolume = components.GetComponent<CApplicationVolumeHandling>(); + appVolume->SetMute(false); + appVolume->SetVolume(CApplicationVolumeHandling::VOLUME_MAXIMUM, false); + } + else + { + // set amp present + CLog::Log(LOGDEBUG, "{} - no CEC capable amplifier found", __FUNCTION__); + m_adapter->SetAudioSystemConnected(false); + } + + return strAmpName; +} + +bool CPeripheralCecAdapterUpdateThread::SetInitialConfiguration(void) +{ + // the option to make XBMC the active source is set + if (m_configuration.bActivateSource == 1) + m_adapter->m_cecAdapter->SetActiveSource(); + + // devices to wake are set + cec_logical_addresses tvOnly; + tvOnly.Clear(); + tvOnly.Set(CECDEVICE_TV); + if (!m_configuration.wakeDevices.IsEmpty() && + (m_configuration.wakeDevices != tvOnly || m_configuration.bActivateSource == 0)) + m_adapter->m_cecAdapter->PowerOnDevices(CECDEVICE_BROADCAST); + + // wait until devices are powered up + if (!WaitReady()) + return false; + + UpdateMenuLanguage(); + + // request the OSD name of the TV + std::string strNotification; + std::string tvName(m_adapter->m_cecAdapter->GetDeviceOSDName(CECDEVICE_TV)); + strNotification = StringUtils::Format("{}: {}", g_localizeStrings.Get(36016), tvName); + + std::string strAmpName = UpdateAudioSystemStatus(); + if (!strAmpName.empty()) + strNotification += StringUtils::Format("- {}", strAmpName); + + m_adapter->m_bIsReady = true; + + // and let the gui know that we're done + CGUIDialogKaiToast::QueueNotification(CGUIDialogKaiToast::Info, g_localizeStrings.Get(36000), + strNotification); + + std::unique_lock<CCriticalSection> lock(m_critSection); + m_bIsUpdating = false; + return true; +} + +bool CPeripheralCecAdapter::IsRunning(void) const +{ + std::unique_lock<CCriticalSection> lock(m_critSection); + return m_bIsRunning; +} + +void CPeripheralCecAdapterUpdateThread::Process(void) +{ + // set the initial configuration + if (!SetInitialConfiguration()) + return; + + // and wait for updates + bool bUpdate(false); + while (!m_bStop) + { + // update received + if (bUpdate || m_event.Wait(500ms)) + { + if (m_bStop) + return; + // set the new configuration + libcec_configuration configuration; + { + std::unique_lock<CCriticalSection> lock(m_critSection); + configuration = m_configuration; + m_bIsUpdating = false; + } + + CLog::Log(LOGDEBUG, "{} - updating the configuration", __FUNCTION__); + bool bConfigSet(m_adapter->m_cecAdapter->SetConfiguration(&configuration)); + // display message: config updated / failed to update + if (!bConfigSet) + CLog::Log(LOGERROR, "{} - libCEC couldn't set the new configuration", __FUNCTION__); + else + { + UpdateMenuLanguage(); + UpdateAudioSystemStatus(); + } + + CGUIDialogKaiToast::QueueNotification(CGUIDialogKaiToast::Info, g_localizeStrings.Get(36000), + g_localizeStrings.Get(bConfigSet ? 36023 : 36024)); + + { + std::unique_lock<CCriticalSection> lock(m_critSection); + if ((bUpdate = m_bNextConfigurationScheduled) == true) + { + // another update is scheduled + m_bNextConfigurationScheduled = false; + m_configuration = m_nextConfiguration; + } + else + { + // nothing left to do, wait for updates + m_bIsUpdating = false; + m_event.Reset(); + } + } + } + } +} + +void CPeripheralCecAdapter::OnDeviceRemoved(void) +{ + std::unique_lock<CCriticalSection> lock(m_critSection); + m_bDeviceRemoved = true; +} + +namespace PERIPHERALS +{ + +class CPeripheralCecAdapterReopenJob : public CJob +{ +public: + CPeripheralCecAdapterReopenJob(CPeripheralCecAdapter* adapter) : m_adapter(adapter) {} + ~CPeripheralCecAdapterReopenJob() override = default; + + bool DoWork(void) override { return m_adapter->ReopenConnection(false); } + +private: + CPeripheralCecAdapter* m_adapter; +}; + +}; // namespace PERIPHERALS + +bool CPeripheralCecAdapter::ReopenConnection(bool bAsync /* = false */) +{ + if (bAsync) + { + CServiceBroker::GetJobManager()->AddJob(new CPeripheralCecAdapterReopenJob(this), nullptr, + CJob::PRIORITY_NORMAL); + return true; + } + + // stop running thread + { + std::unique_lock<CCriticalSection> lock(m_critSection); + m_iExitCode = EXITCODE_RESTARTAPP; + CServiceBroker::GetAnnouncementManager()->RemoveAnnouncer(this); + StopThread(false); + } + StopThread(); + + // reset all members to their defaults + ResetMembers(); + + // reopen the connection + return InitialiseFeature(FEATURE_CEC); +} + +void CPeripheralCecAdapter::ActivateSource(void) +{ + std::unique_lock<CCriticalSection> lock(m_critSection); + m_bActiveSourcePending = true; +} + +void CPeripheralCecAdapter::ProcessActivateSource(void) +{ + bool bActivate(false); + + { + std::unique_lock<CCriticalSection> lock(m_critSection); + bActivate = m_bActiveSourcePending; + m_bActiveSourcePending = false; + } + + if (bActivate) + m_cecAdapter->SetActiveSource(); +} + +void CPeripheralCecAdapter::StandbyDevices(void) +{ + std::unique_lock<CCriticalSection> lock(m_critSection); + m_bStandbyPending = true; +} + +void CPeripheralCecAdapter::ProcessStandbyDevices(void) +{ + bool bStandby(false); + + { + std::unique_lock<CCriticalSection> lock(m_critSection); + bStandby = m_bStandbyPending; + m_bStandbyPending = false; + if (bStandby) + m_bGoingToStandby = true; + } + + if (bStandby) + { + if (!m_configuration.powerOffDevices.IsEmpty()) + { + m_standbySent = CDateTime::GetCurrentDateTime(); + m_cecAdapter->StandbyDevices(CECDEVICE_BROADCAST); + } + else if (m_bSendInactiveSource == 1) + { + CLog::Log(LOGDEBUG, "{} - sending inactive source commands", __FUNCTION__); + m_cecAdapter->SetInactiveView(); + } + } +} + +bool CPeripheralCecAdapter::ToggleDeviceState(CecStateChange mode /*= STATE_SWITCH_TOGGLE */, + bool forceType /*= false */) +{ + if (!IsRunning()) + return false; + if (m_cecAdapter->IsLibCECActiveSource() && + (mode == STATE_SWITCH_TOGGLE || mode == STATE_STANDBY)) + { + CLog::Log(LOGDEBUG, "{} - putting CEC device on standby...", __FUNCTION__); + StandbyDevices(); + return false; + } + else if (mode == STATE_SWITCH_TOGGLE || mode == STATE_ACTIVATE_SOURCE) + { + CLog::Log(LOGDEBUG, "{} - waking up CEC device...", __FUNCTION__); + ActivateSource(); + return true; + } + + return false; +} diff --git a/xbmc/peripherals/devices/PeripheralCecAdapter.h b/xbmc/peripherals/devices/PeripheralCecAdapter.h new file mode 100644 index 0000000..b3755b3 --- /dev/null +++ b/xbmc/peripherals/devices/PeripheralCecAdapter.h @@ -0,0 +1,226 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#if !defined(HAVE_LIBCEC) +#include "Peripheral.h" + +// an empty implementation, so CPeripherals can be compiled without a bunch of #ifdef's when libCEC +// is not available +namespace PERIPHERALS +{ +class CPeripheralCecAdapter : public CPeripheral +{ +public: + bool HasAudioControl(void) { return false; } + void VolumeUp(void) {} + void VolumeDown(void) {} + bool IsMuted(void) { return false; } + void ToggleMute(void) {} + bool ToggleDeviceState(CecStateChange mode = STATE_SWITCH_TOGGLE, bool forceType = false) + { + return false; + } + + int GetButton(void) { return 0; } + unsigned int GetHoldTime(void) { return 0; } + void ResetButton(void) {} +}; +} // namespace PERIPHERALS + +#else + +#include "PeripheralHID.h" +#include "XBDateTime.h" +#include "interfaces/AnnouncementManager.h" +#include "threads/CriticalSection.h" +#include "threads/Thread.h" + +#include <chrono> +#include <queue> +#include <vector> + +// undefine macro isset, it collides with function in cectypes.h +#ifdef isset +#undef isset +#endif +#include <libcec/cectypes.h> + +class CVariant; + +namespace CEC +{ +class ICECAdapter; +}; + +namespace PERIPHERALS +{ +class CPeripheralCecAdapterUpdateThread; +class CPeripheralCecAdapterReopenJob; + +typedef struct +{ + int iButton; + unsigned int iDuration; +} CecButtonPress; + +typedef enum +{ + VOLUME_CHANGE_NONE, + VOLUME_CHANGE_UP, + VOLUME_CHANGE_DOWN, + VOLUME_CHANGE_MUTE +} CecVolumeChange; + +class CPeripheralCecAdapter : public CPeripheralHID, + public ANNOUNCEMENT::IAnnouncer, + private CThread +{ + friend class CPeripheralCecAdapterUpdateThread; + friend class CPeripheralCecAdapterReopenJob; + +public: + CPeripheralCecAdapter(CPeripherals& manager, + const PeripheralScanResult& scanResult, + CPeripheralBus* bus); + ~CPeripheralCecAdapter(void) override; + + void Announce(ANNOUNCEMENT::AnnouncementFlag flag, + const std::string& sender, + const std::string& message, + const CVariant& data) override; + + // audio control + bool HasAudioControl(void); + void VolumeUp(void); + void VolumeDown(void); + void ToggleMute(void); + bool IsMuted(void); + + // CPeripheral callbacks + void OnSettingChanged(const std::string& strChangedSetting) override; + void OnDeviceRemoved(void) override; + + // input + int GetButton(void); + unsigned int GetHoldTime(void); + void ResetButton(void); + + // public CEC methods + void ActivateSource(void); + void StandbyDevices(void); + bool ToggleDeviceState(CecStateChange mode = STATE_SWITCH_TOGGLE, bool forceType = false); + +private: + bool InitialiseFeature(const PeripheralFeature feature) override; + void ResetMembers(void); + void Process(void) override; + bool IsRunning(void) const; + + bool OpenConnection(void); + bool ReopenConnection(bool bAsync = false); + + void SetConfigurationFromSettings(void); + void SetConfigurationFromLibCEC(const CEC::libcec_configuration& config); + void SetVersionInfo(const CEC::libcec_configuration& configuration); + + static void ReadLogicalAddresses(const std::string& strString, + CEC::cec_logical_addresses& addresses); + static void ReadLogicalAddresses(int iLocalisedId, CEC::cec_logical_addresses& addresses); + bool WriteLogicalAddresses(const CEC::cec_logical_addresses& addresses, + const std::string& strSettingName, + const std::string& strAdvancedSettingName); + + void ProcessActivateSource(void); + void ProcessStandbyDevices(void); + void ProcessVolumeChange(void); + + void PushCecKeypress(const CEC::cec_keypress& key); + void PushCecKeypress(const CecButtonPress& key); + void GetNextKey(void); + + void SetAudioSystemConnected(bool bSetTo); + void SetMenuLanguage(const char* strLanguage); + void OnTvStandby(void); + + // callbacks from libCEC + static void CecLogMessage(void* cbParam, const CEC::cec_log_message* message); + static void CecCommand(void* cbParam, const CEC::cec_command* command); + static void CecConfiguration(void* cbParam, const CEC::libcec_configuration* config); + static void CecAlert(void* cbParam, + const CEC::libcec_alert alert, + const CEC::libcec_parameter data); + static void CecSourceActivated(void* param, + const CEC::cec_logical_address address, + const uint8_t activated); + static void CecKeyPress(void* cbParam, const CEC::cec_keypress* key); + + CEC::ICECAdapter* m_cecAdapter; + bool m_bStarted; + bool m_bHasButton; + bool m_bIsReady; + bool m_bHasConnectedAudioSystem; + std::string m_strMenuLanguage; + CDateTime m_standbySent; + std::vector<CecButtonPress> m_buttonQueue; + CecButtonPress m_currentButton; + std::queue<CecVolumeChange> m_volumeChangeQueue; + std::chrono::time_point<std::chrono::steady_clock> m_lastKeypress; + CecVolumeChange m_lastChange; + int m_iExitCode; + bool m_bIsMuted; + bool m_bGoingToStandby; + bool m_bIsRunning; + bool m_bDeviceRemoved; + CPeripheralCecAdapterUpdateThread* m_queryThread; + CEC::ICECCallbacks m_callbacks; + mutable CCriticalSection m_critSection; + CEC::libcec_configuration m_configuration; + bool m_bActiveSourcePending; + bool m_bStandbyPending; + CDateTime m_preventActivateSourceOnPlay; + bool m_bActiveSourceBeforeStandby; + bool m_bOnPlayReceived; + bool m_bPlaybackPaused; + std::string m_strComPort; + bool m_bPowerOnScreensaver; + bool m_bUseTVMenuLanguage; + bool m_bSendInactiveSource; + bool m_bPowerOffScreensaver; + bool m_bShutdownOnStandby; +}; + +class CPeripheralCecAdapterUpdateThread : public CThread +{ +public: + CPeripheralCecAdapterUpdateThread(CPeripheralCecAdapter* adapter, + CEC::libcec_configuration* configuration); + ~CPeripheralCecAdapterUpdateThread(void) override; + + void Signal(void); + bool UpdateConfiguration(CEC::libcec_configuration* configuration); + +protected: + void UpdateMenuLanguage(void); + std::string UpdateAudioSystemStatus(void); + bool WaitReady(void); + bool SetInitialConfiguration(void); + void Process(void) override; + + CPeripheralCecAdapter* m_adapter; + CEvent m_event; + CCriticalSection m_critSection; + CEC::libcec_configuration m_configuration; + CEC::libcec_configuration m_nextConfiguration; + bool m_bNextConfigurationScheduled; + bool m_bIsUpdating; +}; +} // namespace PERIPHERALS + +#endif diff --git a/xbmc/peripherals/devices/PeripheralDisk.cpp b/xbmc/peripherals/devices/PeripheralDisk.cpp new file mode 100644 index 0000000..9b0682c --- /dev/null +++ b/xbmc/peripherals/devices/PeripheralDisk.cpp @@ -0,0 +1,23 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "PeripheralDisk.h" + +#include "guilib/LocalizeStrings.h" + +using namespace PERIPHERALS; + +CPeripheralDisk::CPeripheralDisk(CPeripherals& manager, + const PeripheralScanResult& scanResult, + CPeripheralBus* bus) + : CPeripheral(manager, scanResult, bus) +{ + m_strDeviceName = scanResult.m_strDeviceName.empty() ? g_localizeStrings.Get(35003) + : scanResult.m_strDeviceName; + m_features.push_back(FEATURE_DISK); +} diff --git a/xbmc/peripherals/devices/PeripheralDisk.h b/xbmc/peripherals/devices/PeripheralDisk.h new file mode 100644 index 0000000..f81b31e --- /dev/null +++ b/xbmc/peripherals/devices/PeripheralDisk.h @@ -0,0 +1,23 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "Peripheral.h" + +namespace PERIPHERALS +{ +class CPeripheralDisk : public CPeripheral +{ +public: + CPeripheralDisk(CPeripherals& manager, + const PeripheralScanResult& scanResult, + CPeripheralBus* bus); + ~CPeripheralDisk(void) override = default; +}; +} // namespace PERIPHERALS diff --git a/xbmc/peripherals/devices/PeripheralHID.cpp b/xbmc/peripherals/devices/PeripheralHID.cpp new file mode 100644 index 0000000..e3d061b --- /dev/null +++ b/xbmc/peripherals/devices/PeripheralHID.cpp @@ -0,0 +1,86 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "PeripheralHID.h" + +#include "guilib/LocalizeStrings.h" +#include "input/InputManager.h" +#include "peripherals/Peripherals.h" +#include "utils/log.h" + +using namespace PERIPHERALS; + +CPeripheralHID::CPeripheralHID(CPeripherals& manager, + const PeripheralScanResult& scanResult, + CPeripheralBus* bus) + : CPeripheral(manager, scanResult, bus) +{ + m_strDeviceName = scanResult.m_strDeviceName.empty() ? g_localizeStrings.Get(35001) + : scanResult.m_strDeviceName; + m_features.push_back(FEATURE_HID); +} + +CPeripheralHID::~CPeripheralHID(void) +{ + if (!m_strKeymap.empty() && !GetSettingBool("do_not_use_custom_keymap")) + { + CLog::Log(LOGDEBUG, "{} - switching active keymapping to: default", __FUNCTION__); + m_manager.GetInputManager().RemoveKeymap(m_strKeymap); + } +} + +bool CPeripheralHID::InitialiseFeature(const PeripheralFeature feature) +{ + if (feature == FEATURE_HID && !m_bInitialised) + { + m_bInitialised = true; + + if (HasSetting("keymap")) + m_strKeymap = GetSettingString("keymap"); + + if (m_strKeymap.empty()) + { + m_strKeymap = StringUtils::Format("v{}p{}", VendorIdAsString(), ProductIdAsString()); + SetSetting("keymap", m_strKeymap); + } + + if (!IsSettingVisible("keymap")) + SetSettingVisible("do_not_use_custom_keymap", false); + + if (!m_strKeymap.empty()) + { + bool bKeymapEnabled(!GetSettingBool("do_not_use_custom_keymap")); + if (bKeymapEnabled) + { + CLog::Log(LOGDEBUG, "{} - adding keymapping for: {}", __FUNCTION__, m_strKeymap); + m_manager.GetInputManager().AddKeymap(m_strKeymap); + } + else + { + CLog::Log(LOGDEBUG, "{} - removing keymapping for: {}", __FUNCTION__, m_strKeymap); + m_manager.GetInputManager().RemoveKeymap(m_strKeymap); + } + } + + CLog::Log(LOGDEBUG, "{} - initialised HID device ({}:{})", __FUNCTION__, m_strVendorId, + m_strProductId); + } + + return CPeripheral::InitialiseFeature(feature); +} + +void CPeripheralHID::OnSettingChanged(const std::string& strChangedSetting) +{ + if (m_bInitialised && ((StringUtils::EqualsNoCase(strChangedSetting, "keymap") && + !GetSettingBool("do_not_use_custom_keymap")) || + StringUtils::EqualsNoCase(strChangedSetting, "keymap_enabled"))) + { + m_bInitialised = false; + InitialiseFeature(FEATURE_HID); + } +} diff --git a/xbmc/peripherals/devices/PeripheralHID.h b/xbmc/peripherals/devices/PeripheralHID.h new file mode 100644 index 0000000..3b35dfd --- /dev/null +++ b/xbmc/peripherals/devices/PeripheralHID.h @@ -0,0 +1,33 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "Peripheral.h" +#include "input/XBMC_keyboard.h" + +namespace PERIPHERALS +{ +class CPeripheralHID : public CPeripheral +{ +public: + CPeripheralHID(CPeripherals& manager, + const PeripheralScanResult& scanResult, + CPeripheralBus* bus); + ~CPeripheralHID(void) override; + bool InitialiseFeature(const PeripheralFeature feature) override; + virtual bool LookupSymAndUnicode(XBMC_keysym& keysym, uint8_t* key, char* unicode) + { + return false; + } + void OnSettingChanged(const std::string& strChangedSetting) override; + +protected: + std::string m_strKeymap; +}; +} // namespace PERIPHERALS diff --git a/xbmc/peripherals/devices/PeripheralImon.cpp b/xbmc/peripherals/devices/PeripheralImon.cpp new file mode 100644 index 0000000..6683f8b --- /dev/null +++ b/xbmc/peripherals/devices/PeripheralImon.cpp @@ -0,0 +1,90 @@ +/* + * Copyright (C) 2012-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "PeripheralImon.h" + +#include "input/InputManager.h" +#include "settings/Settings.h" +#include "utils/log.h" + +using namespace PERIPHERALS; + +std::atomic<long> CPeripheralImon::m_lCountOfImonsConflictWithDInput(0L); + +CPeripheralImon::CPeripheralImon(CPeripherals& manager, + const PeripheralScanResult& scanResult, + CPeripheralBus* bus) + : CPeripheralHID(manager, scanResult, bus) +{ + m_features.push_back(FEATURE_IMON); + m_bImonConflictsWithDInput = false; +} + +void CPeripheralImon::OnDeviceRemoved() +{ + if (m_bImonConflictsWithDInput) + { + if (--m_lCountOfImonsConflictWithDInput == 0) + ActionOnImonConflict(false); + } +} + +bool CPeripheralImon::InitialiseFeature(const PeripheralFeature feature) +{ + if (feature == FEATURE_IMON) + { +#if defined(TARGET_WINDOWS) + if (HasSetting("disable_winjoystick") && GetSettingBool("disable_winjoystick")) + m_bImonConflictsWithDInput = true; + else +#endif // TARGET_WINDOWS + m_bImonConflictsWithDInput = false; + + if (m_bImonConflictsWithDInput) + { + ++m_lCountOfImonsConflictWithDInput; + ActionOnImonConflict(true); + } + return CPeripheral::InitialiseFeature(feature); + } + + return CPeripheralHID::InitialiseFeature(feature); +} + +void CPeripheralImon::AddSetting(const std::string& strKey, + const std::shared_ptr<const CSetting>& setting, + int order) +{ +#if !defined(TARGET_WINDOWS) + if (strKey.compare("disable_winjoystick") != 0) +#endif // !TARGET_WINDOWS + CPeripheralHID::AddSetting(strKey, setting, order); +} + +void CPeripheralImon::OnSettingChanged(const std::string& strChangedSetting) +{ + if (strChangedSetting.compare("disable_winjoystick") == 0) + { + if (m_bImonConflictsWithDInput && !GetSettingBool("disable_winjoystick")) + { + m_bImonConflictsWithDInput = false; + if (--m_lCountOfImonsConflictWithDInput == 0) + ActionOnImonConflict(false); + } + else if (!m_bImonConflictsWithDInput && GetSettingBool("disable_winjoystick")) + { + m_bImonConflictsWithDInput = true; + ++m_lCountOfImonsConflictWithDInput; + ActionOnImonConflict(true); + } + } +} + +void CPeripheralImon::ActionOnImonConflict(bool deviceInserted /*= true*/) +{ +} diff --git a/xbmc/peripherals/devices/PeripheralImon.h b/xbmc/peripherals/devices/PeripheralImon.h new file mode 100644 index 0000000..612d059 --- /dev/null +++ b/xbmc/peripherals/devices/PeripheralImon.h @@ -0,0 +1,43 @@ +/* + * Copyright (C) 2012-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "PeripheralHID.h" + +#include <atomic> + +class CSetting; + +namespace PERIPHERALS +{ +class CPeripheralImon : public CPeripheralHID +{ +public: + CPeripheralImon(CPeripherals& manager, + const PeripheralScanResult& scanResult, + CPeripheralBus* bus); + ~CPeripheralImon(void) override = default; + bool InitialiseFeature(const PeripheralFeature feature) override; + void OnSettingChanged(const std::string& strChangedSetting) override; + void OnDeviceRemoved() override; + void AddSetting(const std::string& strKey, + const std::shared_ptr<const CSetting>& setting, + int order) override; + inline bool IsImonConflictsWithDInput() { return m_bImonConflictsWithDInput; } + static inline long GetCountOfImonsConflictWithDInput() + { + return m_lCountOfImonsConflictWithDInput; + } + static void ActionOnImonConflict(bool deviceInserted = true); + +private: + bool m_bImonConflictsWithDInput; + static std::atomic<long> m_lCountOfImonsConflictWithDInput; +}; +} // namespace PERIPHERALS diff --git a/xbmc/peripherals/devices/PeripheralJoystick.cpp b/xbmc/peripherals/devices/PeripheralJoystick.cpp new file mode 100644 index 0000000..bccad91 --- /dev/null +++ b/xbmc/peripherals/devices/PeripheralJoystick.cpp @@ -0,0 +1,538 @@ +/* + * Copyright (C) 2014-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "PeripheralJoystick.h" + +#include "ServiceBroker.h" +#include "addons/AddonInstaller.h" +#include "addons/AddonManager.h" +#include "application/Application.h" +#include "games/GameServices.h" +#include "games/controllers/Controller.h" +#include "games/controllers/ControllerIDs.h" +#include "games/controllers/ControllerManager.h" +#include "input/InputManager.h" +#include "input/joysticks/DeadzoneFilter.h" +#include "input/joysticks/JoystickMonitor.h" +#include "input/joysticks/JoystickTranslator.h" +#include "input/joysticks/RumbleGenerator.h" +#include "input/joysticks/interfaces/IDriverHandler.h" +#include "input/joysticks/keymaps/KeymapHandling.h" +#include "peripherals/Peripherals.h" +#include "peripherals/addons/AddonButtonMap.h" +#include "peripherals/bus/virtual/PeripheralBusAddon.h" +#include "utils/log.h" + +#include <algorithm> +#include <mutex> + +using namespace KODI; +using namespace JOYSTICK; +using namespace PERIPHERALS; + +CPeripheralJoystick::CPeripheralJoystick(CPeripherals& manager, + const PeripheralScanResult& scanResult, + CPeripheralBus* bus) + : CPeripheral(manager, scanResult, bus), + m_requestedPort(JOYSTICK_PORT_UNKNOWN), + m_buttonCount(0), + m_hatCount(0), + m_axisCount(0), + m_motorCount(0), + m_supportsPowerOff(false), + m_rumbleGenerator(new CRumbleGenerator) +{ + m_features.push_back(FEATURE_JOYSTICK); + // FEATURE_RUMBLE conditionally added via SetMotorCount() +} + +CPeripheralJoystick::~CPeripheralJoystick(void) +{ + if (m_rumbleGenerator) + { + m_rumbleGenerator->AbortRumble(); + m_rumbleGenerator.reset(); + } + + if (m_joystickMonitor) + { + UnregisterInputHandler(m_joystickMonitor.get()); + m_joystickMonitor.reset(); + } + + m_appInput.reset(); + m_deadzoneFilter.reset(); + m_buttonMap.reset(); + + // Wait for remaining install tasks + for (std::future<void>& task : m_installTasks) + task.wait(); +} + +bool CPeripheralJoystick::InitialiseFeature(const PeripheralFeature feature) +{ + bool bSuccess = false; + + if (CPeripheral::InitialiseFeature(feature)) + { + if (feature == FEATURE_JOYSTICK) + { + // Ensure an add-on is present to translate input + PeripheralAddonPtr addon = m_manager.GetAddonWithButtonMap(this); + if (!addon) + { + CLog::Log(LOGERROR, "CPeripheralJoystick: No button mapping add-on for {}", m_strLocation); + } + else + { + if (m_bus->InitializeProperties(*this)) + bSuccess = true; + else + CLog::Log(LOGERROR, "CPeripheralJoystick: Invalid location ({})", m_strLocation); + } + + if (bSuccess) + { + m_buttonMap = + std::make_unique<CAddonButtonMap>(this, addon, DEFAULT_CONTROLLER_ID, m_manager); + if (m_buttonMap->Load()) + { + InitializeDeadzoneFiltering(*m_buttonMap); + InitializeControllerProfile(*m_buttonMap); + } + else + { + CLog::Log(LOGERROR, "CPeripheralJoystick: Failed to load button map for {}", + m_strLocation); + m_buttonMap.reset(); + } + + // Give joystick monitor priority over default controller + m_appInput.reset( + new CKeymapHandling(this, false, m_manager.GetInputManager().KeymapEnvironment())); + m_joystickMonitor.reset(new CJoystickMonitor); + RegisterInputHandler(m_joystickMonitor.get(), false); + } + } + else if (feature == FEATURE_RUMBLE) + { + bSuccess = true; // Nothing to do + } + else if (feature == FEATURE_POWER_OFF) + { + bSuccess = true; // Nothing to do + } + } + + return bSuccess; +} + +void CPeripheralJoystick::InitializeDeadzoneFiltering(IButtonMap& buttonMap) +{ + m_deadzoneFilter.reset(new CDeadzoneFilter(&buttonMap, this)); +} + +void CPeripheralJoystick::InitializeControllerProfile(IButtonMap& buttonMap) +{ + const std::string controllerId = buttonMap.GetAppearance(); + if (controllerId.empty()) + return; + + auto controller = m_manager.GetControllerProfiles().GetController(controllerId); + if (controller) + CPeripheral::SetControllerProfile(controller); + else + { + std::unique_lock<CCriticalSection> lock(m_controllerInstallMutex); + + // Deposit controller into queue + m_controllersToInstall.emplace(controllerId); + + // Clean up finished install tasks + m_installTasks.erase(std::remove_if(m_installTasks.begin(), m_installTasks.end(), + [](std::future<void>& task) { + return task.wait_for(std::chrono::seconds(0)) == + std::future_status::ready; + }), + m_installTasks.end()); + + // Install controller off-thread + std::future<void> installTask = std::async(std::launch::async, [this]() { + // Withdraw controller from queue + std::string controllerToInstall; + { + std::unique_lock<CCriticalSection> lock(m_controllerInstallMutex); + if (!m_controllersToInstall.empty()) + { + controllerToInstall = m_controllersToInstall.front(); + m_controllersToInstall.pop(); + } + } + + // Do the install + GAME::ControllerPtr controller = InstallAsync(controllerToInstall); + if (controller) + CPeripheral::SetControllerProfile(controller); + }); + + // Hold the task to prevent the destructor from completing during an install + m_installTasks.emplace_back(std::move(installTask)); + } +} + +void CPeripheralJoystick::OnUserNotification() +{ + IInputReceiver* inputReceiver = m_appInput->GetInputReceiver(m_rumbleGenerator->ControllerID()); + m_rumbleGenerator->NotifyUser(inputReceiver); +} + +bool CPeripheralJoystick::TestFeature(PeripheralFeature feature) +{ + bool bSuccess = false; + + switch (feature) + { + case FEATURE_RUMBLE: + { + IInputReceiver* inputReceiver = + m_appInput->GetInputReceiver(m_rumbleGenerator->ControllerID()); + bSuccess = m_rumbleGenerator->DoTest(inputReceiver); + break; + } + case FEATURE_POWER_OFF: + if (m_supportsPowerOff) + { + PowerOff(); + bSuccess = true; + } + break; + default: + break; + } + + return bSuccess; +} + +void CPeripheralJoystick::PowerOff() +{ + m_bus->PowerOff(m_strLocation); +} + +void CPeripheralJoystick::RegisterJoystickDriverHandler(IDriverHandler* handler, bool bPromiscuous) +{ + std::unique_lock<CCriticalSection> lock(m_handlerMutex); + + DriverHandler driverHandler = {handler, bPromiscuous}; + m_driverHandlers.insert(m_driverHandlers.begin(), driverHandler); +} + +void CPeripheralJoystick::UnregisterJoystickDriverHandler(IDriverHandler* handler) +{ + std::unique_lock<CCriticalSection> lock(m_handlerMutex); + + m_driverHandlers.erase(std::remove_if(m_driverHandlers.begin(), m_driverHandlers.end(), + [handler](const DriverHandler& driverHandler) { + return driverHandler.handler == handler; + }), + m_driverHandlers.end()); +} + +IKeymap* CPeripheralJoystick::GetKeymap(const std::string& controllerId) +{ + return m_appInput->GetKeymap(controllerId); +} + +GAME::ControllerPtr CPeripheralJoystick::ControllerProfile() const +{ + // Button map has the freshest state + if (m_buttonMap) + { + const std::string controllerId = m_buttonMap->GetAppearance(); + if (!controllerId.empty()) + { + auto controller = m_manager.GetControllerProfiles().GetController(controllerId); + if (controller) + return controller; + } + } + + // Fall back to last set controller profile + if (m_controllerProfile) + return m_controllerProfile; + + // Fall back to default controller + return m_manager.GetControllerProfiles().GetDefaultController(); +} + +void CPeripheralJoystick::SetControllerProfile(const KODI::GAME::ControllerPtr& controller) +{ + CPeripheral::SetControllerProfile(controller); + + // Save preference to buttonmap + if (m_buttonMap) + { + if (m_buttonMap->SetAppearance(controller->ID())) + m_buttonMap->SaveButtonMap(); + } +} + +bool CPeripheralJoystick::OnButtonMotion(unsigned int buttonIndex, bool bPressed) +{ + // Silence debug log if controllers are not enabled + if (m_manager.GetInputManager().IsControllerEnabled()) + { + CLog::Log(LOGDEBUG, "BUTTON [ {} ] on \"{}\" {}", buttonIndex, DeviceName(), + bPressed ? "pressed" : "released"); + } + + // Avoid sending activated input if the app is in the background + if (bPressed && !g_application.IsAppFocused()) + return false; + + m_lastActive = CDateTime::GetCurrentDateTime(); + + std::unique_lock<CCriticalSection> lock(m_handlerMutex); + + // Check GUI setting and send button release if controllers are disabled + if (!m_manager.GetInputManager().IsControllerEnabled()) + { + for (std::vector<DriverHandler>::iterator it = m_driverHandlers.begin(); + it != m_driverHandlers.end(); ++it) + it->handler->OnButtonMotion(buttonIndex, false); + return true; + } + + // Process promiscuous handlers + for (auto& it : m_driverHandlers) + { + if (it.bPromiscuous) + it.handler->OnButtonMotion(buttonIndex, bPressed); + } + + bool bHandled = false; + + // Process regular handlers until one is handled + for (auto& it : m_driverHandlers) + { + if (!it.bPromiscuous) + { + bHandled |= it.handler->OnButtonMotion(buttonIndex, bPressed); + + // If button is released, force bHandled to false to notify all handlers. + // This avoids "sticking". + if (!bPressed) + bHandled = false; + + // Once a button is handled, we're done + if (bHandled) + break; + } + } + + return bHandled; +} + +bool CPeripheralJoystick::OnHatMotion(unsigned int hatIndex, HAT_STATE state) +{ + // Silence debug log if controllers are not enabled + if (m_manager.GetInputManager().IsControllerEnabled()) + { + CLog::Log(LOGDEBUG, "HAT [ {} ] on \"{}\" {}", hatIndex, DeviceName(), + CJoystickTranslator::HatStateToString(state)); + } + + // Avoid sending activated input if the app is in the background + if (state != HAT_STATE::NONE && !g_application.IsAppFocused()) + return false; + + m_lastActive = CDateTime::GetCurrentDateTime(); + + std::unique_lock<CCriticalSection> lock(m_handlerMutex); + + // Check GUI setting and send hat unpressed if controllers are disabled + if (!m_manager.GetInputManager().IsControllerEnabled()) + { + for (std::vector<DriverHandler>::iterator it = m_driverHandlers.begin(); + it != m_driverHandlers.end(); ++it) + it->handler->OnHatMotion(hatIndex, HAT_STATE::NONE); + return true; + } + + // Process promiscuous handlers + for (auto& it : m_driverHandlers) + { + if (it.bPromiscuous) + it.handler->OnHatMotion(hatIndex, state); + } + + bool bHandled = false; + + // Process regular handlers until one is handled + for (auto& it : m_driverHandlers) + { + if (!it.bPromiscuous) + { + bHandled |= it.handler->OnHatMotion(hatIndex, state); + + // If hat is centered, force bHandled to false to notify all handlers. + // This avoids "sticking". + if (state == HAT_STATE::NONE) + bHandled = false; + + // Once a hat is handled, we're done + if (bHandled) + break; + } + } + + return bHandled; +} + +bool CPeripheralJoystick::OnAxisMotion(unsigned int axisIndex, float position) +{ + // Get axis properties + int center = 0; + unsigned int range = 1; + if (m_buttonMap) + m_buttonMap->GetAxisProperties(axisIndex, center, range); + + // Apply deadzone filtering + if (center == 0 && m_deadzoneFilter) + position = m_deadzoneFilter->FilterAxis(axisIndex, position); + + // Avoid sending activated input if the app is in the background + if (position != static_cast<float>(center) && !g_application.IsAppFocused()) + return false; + + std::unique_lock<CCriticalSection> lock(m_handlerMutex); + + // Check GUI setting and send analog axis centered if controllers are disabled + if (!m_manager.GetInputManager().IsControllerEnabled()) + { + for (std::vector<DriverHandler>::iterator it = m_driverHandlers.begin(); + it != m_driverHandlers.end(); ++it) + it->handler->OnAxisMotion(axisIndex, static_cast<float>(center), center, range); + return true; + } + + // Process promiscuous handlers + for (auto& it : m_driverHandlers) + { + if (it.bPromiscuous) + it.handler->OnAxisMotion(axisIndex, position, center, range); + } + + bool bHandled = false; + + // Process regular handlers until one is handled + for (auto& it : m_driverHandlers) + { + if (!it.bPromiscuous) + { + bHandled |= it.handler->OnAxisMotion(axisIndex, position, center, range); + + // If axis is centered, force bHandled to false to notify all handlers. + // This avoids "sticking". + if (position == static_cast<float>(center)) + bHandled = false; + + // Once an axis is handled, we're done + if (bHandled) + break; + } + } + + if (bHandled) + m_lastActive = CDateTime::GetCurrentDateTime(); + + return bHandled; +} + +void CPeripheralJoystick::OnInputFrame(void) +{ + std::unique_lock<CCriticalSection> lock(m_handlerMutex); + + for (auto& it : m_driverHandlers) + it.handler->OnInputFrame(); +} + +bool CPeripheralJoystick::SetMotorState(unsigned int motorIndex, float magnitude) +{ + bool bHandled = false; + + if (m_mappedBusType == PERIPHERAL_BUS_ADDON) + { + CPeripheralBusAddon* addonBus = static_cast<CPeripheralBusAddon*>(m_bus); + if (addonBus) + { + bHandled = addonBus->SendRumbleEvent(m_strLocation, motorIndex, magnitude); + } + } + return bHandled; +} + +void CPeripheralJoystick::SetMotorCount(unsigned int motorCount) +{ + m_motorCount = motorCount; + + if (m_motorCount == 0) + m_features.erase(std::remove(m_features.begin(), m_features.end(), FEATURE_RUMBLE), + m_features.end()); + else if (std::find(m_features.begin(), m_features.end(), FEATURE_RUMBLE) == m_features.end()) + m_features.push_back(FEATURE_RUMBLE); +} + +void CPeripheralJoystick::SetSupportsPowerOff(bool bSupportsPowerOff) +{ + m_supportsPowerOff = bSupportsPowerOff; + + if (!m_supportsPowerOff) + m_features.erase(std::remove(m_features.begin(), m_features.end(), FEATURE_POWER_OFF), + m_features.end()); + else if (std::find(m_features.begin(), m_features.end(), FEATURE_POWER_OFF) == m_features.end()) + m_features.push_back(FEATURE_POWER_OFF); +} + +GAME::ControllerPtr CPeripheralJoystick::InstallAsync(const std::string& controllerId) +{ + GAME::ControllerPtr controller; + + // Only 1 install at a time. Remaining installs will wake when this one + // is done. + std::unique_lock<CCriticalSection> lockInstall(m_manager.GetAddonInstallMutex()); + + CLog::LogF(LOGDEBUG, "Installing {}", controllerId); + + if (InstallSync(controllerId)) + controller = m_manager.GetControllerProfiles().GetController(controllerId); + else + CLog::LogF(LOGERROR, "Failed to install {}", controllerId); + + return controller; +} + +bool CPeripheralJoystick::InstallSync(const std::string& controllerId) +{ + // If the addon isn't installed we need to install it + bool installed = CServiceBroker::GetAddonMgr().IsAddonInstalled(controllerId); + if (!installed) + { + ADDON::AddonPtr installedAddon; + installed = ADDON::CAddonInstaller::GetInstance().InstallModal( + controllerId, installedAddon, ADDON::InstallModalPrompt::CHOICE_NO); + } + + if (installed) + { + // Make sure add-on is enabled + if (CServiceBroker::GetAddonMgr().IsAddonDisabled(controllerId)) + CServiceBroker::GetAddonMgr().EnableAddon(controllerId); + } + + return installed; +} diff --git a/xbmc/peripherals/devices/PeripheralJoystick.h b/xbmc/peripherals/devices/PeripheralJoystick.h new file mode 100644 index 0000000..aa55ad7 --- /dev/null +++ b/xbmc/peripherals/devices/PeripheralJoystick.h @@ -0,0 +1,150 @@ +/* + * Copyright (C) 2014-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "Peripheral.h" +#include "XBDateTime.h" +#include "games/controllers/ControllerTypes.h" +#include "input/joysticks/JoystickTypes.h" +#include "input/joysticks/interfaces/IDriverReceiver.h" +#include "threads/CriticalSection.h" + +#include <future> +#include <memory> +#include <queue> +#include <string> +#include <vector> + +#define JOYSTICK_PORT_UNKNOWN (-1) + +namespace KODI +{ +namespace JOYSTICK +{ +class CDeadzoneFilter; +class CKeymapHandling; +class CRumbleGenerator; +class IButtonMap; +class IDriverHandler; +class IInputHandler; +} // namespace JOYSTICK +} // namespace KODI + +namespace PERIPHERALS +{ +class CPeripherals; + +class CPeripheralJoystick : public CPeripheral, //! @todo extend CPeripheralHID + public KODI::JOYSTICK::IDriverReceiver +{ +public: + CPeripheralJoystick(CPeripherals& manager, + const PeripheralScanResult& scanResult, + CPeripheralBus* bus); + + ~CPeripheralJoystick(void) override; + + // implementation of CPeripheral + bool InitialiseFeature(const PeripheralFeature feature) override; + void OnUserNotification() override; + bool TestFeature(PeripheralFeature feature) override; + void RegisterJoystickDriverHandler(KODI::JOYSTICK::IDriverHandler* handler, + bool bPromiscuous) override; + void UnregisterJoystickDriverHandler(KODI::JOYSTICK::IDriverHandler* handler) override; + KODI::JOYSTICK::IDriverReceiver* GetDriverReceiver() override { return this; } + IKeymap* GetKeymap(const std::string& controllerId) override; + CDateTime LastActive() override { return m_lastActive; } + KODI::GAME::ControllerPtr ControllerProfile() const override; + void SetControllerProfile(const KODI::GAME::ControllerPtr& controller) override; + + bool OnButtonMotion(unsigned int buttonIndex, bool bPressed); + bool OnHatMotion(unsigned int hatIndex, KODI::JOYSTICK::HAT_STATE state); + bool OnAxisMotion(unsigned int axisIndex, float position); + void OnInputFrame(void); + + // implementation of IDriverReceiver + bool SetMotorState(unsigned int motorIndex, float magnitude) override; + + /*! + * \brief Get the name of the driver or API providing this joystick + */ + const std::string& Provider(void) const { return m_strProvider; } + + /*! + * \brief Get the specific port number requested by this joystick + * + * This could indicate that the joystick is connected to a hardware port + * with a number label; some controllers, such as the Xbox 360 controller, + * also have LEDs that indicate the controller is on a specific port. + * + * \return The 0-indexed port number, or JOYSTICK_PORT_UNKNOWN if no port is requested + */ + int RequestedPort(void) const { return m_requestedPort; } + + /*! + * \brief Get the number of elements reported by the driver + */ + unsigned int ButtonCount(void) const { return m_buttonCount; } + unsigned int HatCount(void) const { return m_hatCount; } + unsigned int AxisCount(void) const { return m_axisCount; } + unsigned int MotorCount(void) const { return m_motorCount; } + bool SupportsPowerOff(void) const { return m_supportsPowerOff; } + + /*! + * \brief Set joystick properties + */ + void SetProvider(const std::string& provider) { m_strProvider = provider; } + void SetRequestedPort(int port) { m_requestedPort = port; } + void SetButtonCount(unsigned int buttonCount) { m_buttonCount = buttonCount; } + void SetHatCount(unsigned int hatCount) { m_hatCount = hatCount; } + void SetAxisCount(unsigned int axisCount) { m_axisCount = axisCount; } + void SetMotorCount(unsigned int motorCount); // specialized to update m_features + void SetSupportsPowerOff(bool bSupportsPowerOff); // specialized to update m_features + +protected: + void InitializeDeadzoneFiltering(KODI::JOYSTICK::IButtonMap& buttonMap); + void InitializeControllerProfile(KODI::JOYSTICK::IButtonMap& buttonMap); + + void PowerOff(); + + // Helper functions + KODI::GAME::ControllerPtr InstallAsync(const std::string& controllerId); + static bool InstallSync(const std::string& controllerId); + + struct DriverHandler + { + KODI::JOYSTICK::IDriverHandler* handler; + bool bPromiscuous; + }; + + // State parameters + std::string m_strProvider; + int m_requestedPort; + unsigned int m_buttonCount; + unsigned int m_hatCount; + unsigned int m_axisCount; + unsigned int m_motorCount; + bool m_supportsPowerOff; + CDateTime m_lastActive; + std::queue<std::string> m_controllersToInstall; + std::vector<std::future<void>> m_installTasks; + + // Input clients + std::unique_ptr<KODI::JOYSTICK::CKeymapHandling> m_appInput; + std::unique_ptr<KODI::JOYSTICK::CRumbleGenerator> m_rumbleGenerator; + std::unique_ptr<KODI::JOYSTICK::IInputHandler> m_joystickMonitor; + std::unique_ptr<KODI::JOYSTICK::IButtonMap> m_buttonMap; + std::unique_ptr<KODI::JOYSTICK::CDeadzoneFilter> m_deadzoneFilter; + std::vector<DriverHandler> m_driverHandlers; + + // Synchronization parameters + CCriticalSection m_handlerMutex; + CCriticalSection m_controllerInstallMutex; +}; +} // namespace PERIPHERALS diff --git a/xbmc/peripherals/devices/PeripheralKeyboard.cpp b/xbmc/peripherals/devices/PeripheralKeyboard.cpp new file mode 100644 index 0000000..271d8b1 --- /dev/null +++ b/xbmc/peripherals/devices/PeripheralKeyboard.cpp @@ -0,0 +1,125 @@ +/* + * Copyright (C) 2017-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "PeripheralKeyboard.h" + +#include "games/GameServices.h" +#include "games/controllers/Controller.h" +#include "games/controllers/ControllerManager.h" +#include "input/InputManager.h" +#include "peripherals/Peripherals.h" + +#include <mutex> +#include <sstream> + +using namespace KODI; +using namespace PERIPHERALS; + +CPeripheralKeyboard::CPeripheralKeyboard(CPeripherals& manager, + const PeripheralScanResult& scanResult, + CPeripheralBus* bus) + : CPeripheral(manager, scanResult, bus) +{ + // Initialize CPeripheral + m_features.push_back(FEATURE_KEYBOARD); +} + +CPeripheralKeyboard::~CPeripheralKeyboard(void) +{ + m_manager.GetInputManager().UnregisterKeyboardDriverHandler(this); +} + +bool CPeripheralKeyboard::InitialiseFeature(const PeripheralFeature feature) +{ + bool bSuccess = false; + + if (CPeripheral::InitialiseFeature(feature)) + { + switch (feature) + { + case FEATURE_KEYBOARD: + { + m_manager.GetInputManager().RegisterKeyboardDriverHandler(this); + break; + } + default: + break; + } + + bSuccess = true; + } + + return bSuccess; +} + +void CPeripheralKeyboard::RegisterKeyboardDriverHandler( + KODI::KEYBOARD::IKeyboardDriverHandler* handler, bool bPromiscuous) +{ + std::unique_lock<CCriticalSection> lock(m_mutex); + + KeyboardHandle handle{handler, bPromiscuous}; + m_keyboardHandlers.insert(m_keyboardHandlers.begin(), handle); +} + +void CPeripheralKeyboard::UnregisterKeyboardDriverHandler( + KODI::KEYBOARD::IKeyboardDriverHandler* handler) +{ + std::unique_lock<CCriticalSection> lock(m_mutex); + + auto it = + std::find_if(m_keyboardHandlers.begin(), m_keyboardHandlers.end(), + [handler](const KeyboardHandle& handle) { return handle.handler == handler; }); + + if (it != m_keyboardHandlers.end()) + m_keyboardHandlers.erase(it); +} + +GAME::ControllerPtr CPeripheralKeyboard::ControllerProfile() const +{ + if (m_controllerProfile) + return m_controllerProfile; + + return m_manager.GetControllerProfiles().GetDefaultKeyboard(); +} + +bool CPeripheralKeyboard::OnKeyPress(const CKey& key) +{ + m_lastActive = CDateTime::GetCurrentDateTime(); + + std::unique_lock<CCriticalSection> lock(m_mutex); + + bool bHandled = false; + + // Process promiscuous handlers + for (const KeyboardHandle& handle : m_keyboardHandlers) + { + if (handle.bPromiscuous) + handle.handler->OnKeyPress(key); + } + + // Process handlers until one is handled + for (const KeyboardHandle& handle : m_keyboardHandlers) + { + if (!handle.bPromiscuous) + { + bHandled = handle.handler->OnKeyPress(key); + if (bHandled) + break; + } + } + + return bHandled; +} + +void CPeripheralKeyboard::OnKeyRelease(const CKey& key) +{ + std::unique_lock<CCriticalSection> lock(m_mutex); + + for (const KeyboardHandle& handle : m_keyboardHandlers) + handle.handler->OnKeyRelease(key); +} diff --git a/xbmc/peripherals/devices/PeripheralKeyboard.h b/xbmc/peripherals/devices/PeripheralKeyboard.h new file mode 100644 index 0000000..2cf2934 --- /dev/null +++ b/xbmc/peripherals/devices/PeripheralKeyboard.h @@ -0,0 +1,52 @@ +/* + * Copyright (C) 2017-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "Peripheral.h" +#include "XBDateTime.h" +#include "input/keyboard/interfaces/IKeyboardDriverHandler.h" +#include "threads/CriticalSection.h" + +#include <vector> + +namespace PERIPHERALS +{ +class CPeripheralKeyboard : public CPeripheral, public KODI::KEYBOARD::IKeyboardDriverHandler +{ +public: + CPeripheralKeyboard(CPeripherals& manager, + const PeripheralScanResult& scanResult, + CPeripheralBus* bus); + + ~CPeripheralKeyboard(void) override; + + // implementation of CPeripheral + bool InitialiseFeature(const PeripheralFeature feature) override; + void RegisterKeyboardDriverHandler(KODI::KEYBOARD::IKeyboardDriverHandler* handler, + bool bPromiscuous) override; + void UnregisterKeyboardDriverHandler(KODI::KEYBOARD::IKeyboardDriverHandler* handler) override; + CDateTime LastActive() override { return m_lastActive; } + KODI::GAME::ControllerPtr ControllerProfile() const override; + + // implementation of IKeyboardDriverHandler + bool OnKeyPress(const CKey& key) override; + void OnKeyRelease(const CKey& key) override; + +private: + struct KeyboardHandle + { + KODI::KEYBOARD::IKeyboardDriverHandler* handler; + bool bPromiscuous; + }; + + std::vector<KeyboardHandle> m_keyboardHandlers; + CCriticalSection m_mutex; + CDateTime m_lastActive; +}; +} // namespace PERIPHERALS diff --git a/xbmc/peripherals/devices/PeripheralMouse.cpp b/xbmc/peripherals/devices/PeripheralMouse.cpp new file mode 100644 index 0000000..4f26236 --- /dev/null +++ b/xbmc/peripherals/devices/PeripheralMouse.cpp @@ -0,0 +1,150 @@ +/* + * Copyright (C) 2017-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "PeripheralMouse.h" + +#include "games/GameServices.h" +#include "games/controllers/Controller.h" +#include "games/controllers/ControllerManager.h" +#include "input/InputManager.h" +#include "peripherals/Peripherals.h" + +#include <mutex> +#include <sstream> + +using namespace KODI; +using namespace PERIPHERALS; + +CPeripheralMouse::CPeripheralMouse(CPeripherals& manager, + const PeripheralScanResult& scanResult, + CPeripheralBus* bus) + : CPeripheral(manager, scanResult, bus) +{ + // Initialize CPeripheral + m_features.push_back(FEATURE_MOUSE); +} + +CPeripheralMouse::~CPeripheralMouse(void) +{ + m_manager.GetInputManager().UnregisterMouseDriverHandler(this); +} + +bool CPeripheralMouse::InitialiseFeature(const PeripheralFeature feature) +{ + bool bSuccess = false; + + if (CPeripheral::InitialiseFeature(feature)) + { + if (feature == FEATURE_MOUSE) + { + m_manager.GetInputManager().RegisterMouseDriverHandler(this); + } + + bSuccess = true; + } + + return bSuccess; +} + +void CPeripheralMouse::RegisterMouseDriverHandler(MOUSE::IMouseDriverHandler* handler, + bool bPromiscuous) +{ + using namespace KEYBOARD; + + std::unique_lock<CCriticalSection> lock(m_mutex); + + MouseHandle handle{handler, bPromiscuous}; + m_mouseHandlers.insert(m_mouseHandlers.begin(), handle); +} + +void CPeripheralMouse::UnregisterMouseDriverHandler(MOUSE::IMouseDriverHandler* handler) +{ + std::unique_lock<CCriticalSection> lock(m_mutex); + + auto it = + std::find_if(m_mouseHandlers.begin(), m_mouseHandlers.end(), + [handler](const MouseHandle& handle) { return handle.handler == handler; }); + + if (it != m_mouseHandlers.end()) + m_mouseHandlers.erase(it); +} + +GAME::ControllerPtr CPeripheralMouse::ControllerProfile() const +{ + if (m_controllerProfile) + return m_controllerProfile; + + return m_manager.GetControllerProfiles().GetDefaultMouse(); +} + +bool CPeripheralMouse::OnPosition(int x, int y) +{ + std::unique_lock<CCriticalSection> lock(m_mutex); + + bool bHandled = false; + + // Process promiscuous handlers + for (const MouseHandle& handle : m_mouseHandlers) + { + if (handle.bPromiscuous) + handle.handler->OnPosition(x, y); + } + + // Process handlers until one is handled + for (const MouseHandle& handle : m_mouseHandlers) + { + if (!handle.bPromiscuous) + { + bHandled = handle.handler->OnPosition(x, y); + if (bHandled) + break; + } + } + + if (bHandled) + m_lastActive = CDateTime::GetCurrentDateTime(); + + return bHandled; +} + +bool CPeripheralMouse::OnButtonPress(MOUSE::BUTTON_ID button) +{ + m_lastActive = CDateTime::GetCurrentDateTime(); + + std::unique_lock<CCriticalSection> lock(m_mutex); + + bool bHandled = false; + + // Process promiscuous handlers + for (const MouseHandle& handle : m_mouseHandlers) + { + if (handle.bPromiscuous) + handle.handler->OnButtonPress(button); + } + + // Process handlers until one is handled + for (const MouseHandle& handle : m_mouseHandlers) + { + if (!handle.bPromiscuous) + { + bHandled = handle.handler->OnButtonPress(button); + if (bHandled) + break; + } + } + + return bHandled; +} + +void CPeripheralMouse::OnButtonRelease(MOUSE::BUTTON_ID button) +{ + std::unique_lock<CCriticalSection> lock(m_mutex); + + for (const MouseHandle& handle : m_mouseHandlers) + handle.handler->OnButtonRelease(button); +} diff --git a/xbmc/peripherals/devices/PeripheralMouse.h b/xbmc/peripherals/devices/PeripheralMouse.h new file mode 100644 index 0000000..b46776d --- /dev/null +++ b/xbmc/peripherals/devices/PeripheralMouse.h @@ -0,0 +1,53 @@ +/* + * Copyright (C) 2017-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "Peripheral.h" +#include "XBDateTime.h" +#include "input/mouse/interfaces/IMouseDriverHandler.h" +#include "threads/CriticalSection.h" + +#include <vector> + +namespace PERIPHERALS +{ +class CPeripheralMouse : public CPeripheral, public KODI::MOUSE::IMouseDriverHandler +{ +public: + CPeripheralMouse(CPeripherals& manager, + const PeripheralScanResult& scanResult, + CPeripheralBus* bus); + + ~CPeripheralMouse(void) override; + + // implementation of CPeripheral + bool InitialiseFeature(const PeripheralFeature feature) override; + void RegisterMouseDriverHandler(KODI::MOUSE::IMouseDriverHandler* handler, + bool bPromiscuous) override; + void UnregisterMouseDriverHandler(KODI::MOUSE::IMouseDriverHandler* handler) override; + CDateTime LastActive() override { return m_lastActive; } + KODI::GAME::ControllerPtr ControllerProfile() const override; + + // implementation of IMouseDriverHandler + bool OnPosition(int x, int y) override; + bool OnButtonPress(KODI::MOUSE::BUTTON_ID button) override; + void OnButtonRelease(KODI::MOUSE::BUTTON_ID button) override; + +private: + struct MouseHandle + { + KODI::MOUSE::IMouseDriverHandler* handler; + bool bPromiscuous; + }; + + std::vector<MouseHandle> m_mouseHandlers; + CCriticalSection m_mutex; + CDateTime m_lastActive; +}; +} // namespace PERIPHERALS diff --git a/xbmc/peripherals/devices/PeripheralNIC.cpp b/xbmc/peripherals/devices/PeripheralNIC.cpp new file mode 100644 index 0000000..a5b5c32 --- /dev/null +++ b/xbmc/peripherals/devices/PeripheralNIC.cpp @@ -0,0 +1,23 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "PeripheralNIC.h" + +#include "guilib/LocalizeStrings.h" + +using namespace PERIPHERALS; + +CPeripheralNIC::CPeripheralNIC(CPeripherals& manager, + const PeripheralScanResult& scanResult, + CPeripheralBus* bus) + : CPeripheral(manager, scanResult, bus) +{ + m_strDeviceName = scanResult.m_strDeviceName.empty() ? g_localizeStrings.Get(35002) + : scanResult.m_strDeviceName; + m_features.push_back(FEATURE_NIC); +} diff --git a/xbmc/peripherals/devices/PeripheralNIC.h b/xbmc/peripherals/devices/PeripheralNIC.h new file mode 100644 index 0000000..01fe5f3 --- /dev/null +++ b/xbmc/peripherals/devices/PeripheralNIC.h @@ -0,0 +1,23 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "Peripheral.h" + +namespace PERIPHERALS +{ +class CPeripheralNIC : public CPeripheral +{ +public: + CPeripheralNIC(CPeripherals& manager, + const PeripheralScanResult& scanResult, + CPeripheralBus* bus); + ~CPeripheralNIC(void) override = default; +}; +} // namespace PERIPHERALS diff --git a/xbmc/peripherals/devices/PeripheralNyxboard.cpp b/xbmc/peripherals/devices/PeripheralNyxboard.cpp new file mode 100644 index 0000000..548d8cf --- /dev/null +++ b/xbmc/peripherals/devices/PeripheralNyxboard.cpp @@ -0,0 +1,55 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "PeripheralNyxboard.h" + +#include "PeripheralHID.h" +#include "application/Application.h" +#include "utils/log.h" + +using namespace PERIPHERALS; + +CPeripheralNyxboard::CPeripheralNyxboard(CPeripherals& manager, + const PeripheralScanResult& scanResult, + CPeripheralBus* bus) + : CPeripheralHID(manager, scanResult, bus) +{ + m_features.push_back(FEATURE_NYXBOARD); +} + +bool CPeripheralNyxboard::LookupSymAndUnicode(XBMC_keysym& keysym, uint8_t* key, char* unicode) +{ + std::string strCommand; + if (keysym.sym == XBMCK_F7 && keysym.mod == XBMCKMOD_NONE && + GetSettingBool("enable_flip_commands")) + { + /* switched to keyboard side */ + CLog::Log(LOGDEBUG, "{} - switched to keyboard side", __FUNCTION__); + strCommand = GetSettingString("flip_keyboard"); + } + else if (keysym.sym == XBMCK_F7 && keysym.mod == XBMCKMOD_LCTRL && + GetSettingBool("enable_flip_commands")) + { + /* switched to remote side */ + CLog::Log(LOGDEBUG, "{} - switched to remote side", __FUNCTION__); + strCommand = GetSettingString("flip_remote"); + } + + if (!strCommand.empty()) + { + CLog::Log(LOGDEBUG, "{} - executing command '{}'", __FUNCTION__, strCommand); + if (g_application.ExecuteXBMCAction(strCommand)) + { + *key = 0; + *unicode = (char)0; + return true; + } + } + + return false; +} diff --git a/xbmc/peripherals/devices/PeripheralNyxboard.h b/xbmc/peripherals/devices/PeripheralNyxboard.h new file mode 100644 index 0000000..f81c3ef --- /dev/null +++ b/xbmc/peripherals/devices/PeripheralNyxboard.h @@ -0,0 +1,24 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "PeripheralHID.h" + +namespace PERIPHERALS +{ +class CPeripheralNyxboard : public CPeripheralHID +{ +public: + CPeripheralNyxboard(CPeripherals& manager, + const PeripheralScanResult& scanResult, + CPeripheralBus* bus); + ~CPeripheralNyxboard(void) override = default; + bool LookupSymAndUnicode(XBMC_keysym& keysym, uint8_t* key, char* unicode) override; +}; +} // namespace PERIPHERALS diff --git a/xbmc/peripherals/devices/PeripheralTuner.cpp b/xbmc/peripherals/devices/PeripheralTuner.cpp new file mode 100644 index 0000000..770656d --- /dev/null +++ b/xbmc/peripherals/devices/PeripheralTuner.cpp @@ -0,0 +1,19 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "PeripheralTuner.h" + +using namespace PERIPHERALS; + +CPeripheralTuner::CPeripheralTuner(CPeripherals& manager, + const PeripheralScanResult& scanResult, + CPeripheralBus* bus) + : CPeripheral(manager, scanResult, bus) +{ + m_features.push_back(FEATURE_TUNER); +} diff --git a/xbmc/peripherals/devices/PeripheralTuner.h b/xbmc/peripherals/devices/PeripheralTuner.h new file mode 100644 index 0000000..aedfc12 --- /dev/null +++ b/xbmc/peripherals/devices/PeripheralTuner.h @@ -0,0 +1,23 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "Peripheral.h" + +namespace PERIPHERALS +{ +class CPeripheralTuner : public CPeripheral +{ +public: + CPeripheralTuner(CPeripherals& manager, + const PeripheralScanResult& scanResult, + CPeripheralBus* bus); + ~CPeripheralTuner(void) override = default; +}; +} // namespace PERIPHERALS |