bool CPeripheralBusAddon::InitializeProperties(CPeripheral& peripheral)
{
if (!CPeripheralBus::InitializeProperties(peripheral))
return false;
bool bSuccess = false;
PeripheralAddonPtr addon;
unsigned int index;
if (SplitLocation(peripheral.Location(), addon, index))
{
switch (peripheral.Type())
{
case PERIPHERAL_JOYSTICK:
bSuccess = addon->GetJoystickProperties(index, static_cast<CPeripheralJoystick&>(peripheral));
break;
default:
break;
}
}
return bSuccess;
}
bool CPeripheralBusAddon::GetAddonWithButtonMap(const CPeripheral* device, PeripheralAddonPtr &addon) const
{
CSingleLock lock(m_critSection);
// If device is from an add-on, try to use that add-on
if (device && device->GetBusType() == PERIPHERAL_BUS_ADDON)
{
PeripheralAddonPtr addonWithButtonMap;
unsigned int index;
if (SplitLocation(device->Location(), addonWithButtonMap, index))
{
if (addonWithButtonMap->HasButtonMaps())
addon = std::move(addonWithButtonMap);
else
CLog::Log(LOGDEBUG, "Add-on %s doesn't provide button maps for its controllers", addonWithButtonMap->ID().c_str());
}
}
if (!addon)
{
auto it = std::find_if(m_addons.begin(), m_addons.end(),
[](const PeripheralAddonPtr& addon)
{
return addon->HasButtonMaps();
});
if (it != m_addons.end())
addon = *it;
}
return addon.get() != nullptr;
}
void CPeripheralBusAddon::PowerOff(const std::string& strLocation)
{
PeripheralAddonPtr addon;
unsigned int peripheralIndex;
if (SplitLocation(strLocation, addon, peripheralIndex))
addon->PowerOffJoystick(peripheralIndex);
}
void CPeripheralBusAddon::UnRegisterAddon(const std::string& addonId)
{
CLog::Log(LOGDEBUG, "Add-on bus: Unregistering add-on %s", addonId.c_str());
PeripheralAddonPtr erased;
auto ErasePeripheralAddon = [&addonId, &erased](const PeripheralAddonPtr& addon)
{
if (addon->ID() == addonId)
{
erased = addon;
return true;
}
return false;
};
m_addons.erase(std::remove_if(m_addons.begin(), m_addons.end(), ErasePeripheralAddon), m_addons.end());
if (!erased)
m_failedAddons.erase(std::remove_if(m_failedAddons.begin(), m_failedAddons.end(), ErasePeripheralAddon), m_failedAddons.end());
if (erased)
{
CSingleExit exit(m_critSection);
erased->DestroyAddon();
}
}
bool CPeripheralBusAddon::SendRumbleEvent(const std::string& strLocation, unsigned int motorIndex, float magnitude)
{
bool bHandled = false;
PeripheralAddonPtr addon;
unsigned int peripheralIndex;
if (SplitLocation(strLocation, addon, peripheralIndex))
bHandled = addon->SendRumbleEvent(peripheralIndex, motorIndex, magnitude);
return bHandled;
}
PeripheralPtr CPeripheralBusAddon::GetPeripheral(const std::string &strLocation) const
{
PeripheralPtr peripheral;
PeripheralAddonPtr addon;
unsigned int peripheralIndex;
CSingleLock lock(m_critSection);
if (SplitLocation(strLocation, addon, peripheralIndex))
peripheral = addon->GetPeripheral(peripheralIndex);
return peripheral;
}
bool CPeripheralBusAddon::SplitLocation(const std::string& strLocation, PeripheralAddonPtr& addon, unsigned int& peripheralIndex) const
{
std::vector<std::string> parts = StringUtils::Split(strLocation, "/");
if (parts.size() == 2)
{
addon.reset();
CSingleLock lock(m_critSection);
const std::string& strAddonId = parts[0];
for (const auto& addonIt : m_addons)
{
if (addonIt->ID() == strAddonId)
{
addon = addonIt;
break;
}
}
if (addon)
{
const char* strJoystickIndex = parts[1].c_str();
char* p = NULL;
peripheralIndex = strtol(strJoystickIndex, &p, 10);
if (strJoystickIndex != p)
return true;
}
}
return false;
}
void CPeripheralBusAddon::Register(const PeripheralPtr& peripheral)
{
if (!peripheral)
return;
PeripheralAddonPtr addon;
unsigned int peripheralIndex;
CSingleLock lock(m_critSection);
if (SplitLocation(peripheral->Location(), addon, peripheralIndex))
{
if (addon->Register(peripheralIndex, peripheral))
m_manager.OnDeviceAdded(*this, *peripheral);
}
}
bool CPeripheralBusAddon::RequestRemoval(ADDON::AddonPtr addon)
{
// make sure this is a peripheral addon
PeripheralAddonPtr peripheralAddon = std::dynamic_pointer_cast<CPeripheralAddon>(addon);
if (peripheralAddon == nullptr)
return false;
CSingleLock lock(m_critSection);
// destroy the peripheral addon
peripheralAddon->Destroy();
// remove the peripheral addon from the list of addons
m_addons.erase(std::remove(m_addons.begin(), m_addons.end(), peripheralAddon), m_addons.end());
return true;
}
bool CPeripheralBusAddon::RequestRestart(ADDON::AddonPtr addon, bool datachanged)
{
// make sure this is a peripheral addon
PeripheralAddonPtr peripheralAddon = std::dynamic_pointer_cast<CPeripheralAddon>(addon);
if (peripheralAddon == nullptr)
return false;
if (peripheralAddon->CreateAddon() != ADDON_STATUS_OK)
{
CSingleLock lock(m_critSection);
m_addons.erase(std::remove(m_addons.begin(), m_addons.end(), peripheralAddon), m_addons.end());
m_failedAddons.push_back(peripheralAddon);
}
return true;
}
std::string CPeripheral::GetIcon() const
{
std::string icon = "DefaultAddon.png";
if (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);
}
}
return icon;
}
bool CPeripheralBusAddon::GetAddonWithButtonMap(PeripheralAddonPtr &addon) const
{
CSingleLock lock(m_critSection);
auto it = std::find_if(m_addons.begin(), m_addons.end(),
[](const PeripheralAddonPtr& addon)
{
return addon->HasButtonMaps();
});
if (it != m_addons.end())
{
addon = *it;
return true;
}
return false;
}
void CPeripheralBusAddon::UpdateAddons(void)
{
using namespace ADDON;
auto GetPeripheralAddonID = [](const PeripheralAddonPtr& addon) { return addon->ID(); };
auto GetAddonID = [](const BinaryAddonBasePtr& addon) { return addon->ID(); };
std::set<std::string> currentIds;
std::set<std::string> newIds;
std::set<std::string> added;
std::set<std::string> removed;
// Get new add-ons
BinaryAddonBaseList newAddons;
CServiceBroker::GetBinaryAddonManager().GetAddonInfos(newAddons, true, ADDON_PERIPHERALDLL);
std::transform(newAddons.begin(), newAddons.end(), std::inserter(newIds, newIds.end()), GetAddonID);
CSingleLock lock(m_critSection);
// Get current add-ons
std::transform(m_addons.begin(), m_addons.end(), std::inserter(currentIds, currentIds.end()), GetPeripheralAddonID);
std::transform(m_failedAddons.begin(), m_failedAddons.end(), std::inserter(currentIds, currentIds.end()), GetPeripheralAddonID);
// Differences
std::set_difference(newIds.begin(), newIds.end(), currentIds.begin(), currentIds.end(), std::inserter(added, added.end()));
std::set_difference(currentIds.begin(), currentIds.end(), newIds.begin(), newIds.end(), std::inserter(removed, removed.end()));
// Register new add-ons
for (const std::string& addonId : added)
{
CLog::Log(LOGDEBUG, "Add-on bus: Registering add-on %s", addonId.c_str());
auto GetAddon = [&addonId](const BinaryAddonBasePtr& addon) { return addon->ID() == addonId; };
BinaryAddonBaseList::iterator it = std::find_if(newAddons.begin(), newAddons.end(), GetAddon);
if (it != newAddons.end())
{
PeripheralAddonPtr newAddon = std::make_shared<CPeripheralAddon>(*it, m_manager);
if (newAddon)
{
bool bCreated;
{
CSingleExit exit(m_critSection);
bCreated = newAddon->CreateAddon();
}
if (bCreated)
m_addons.emplace_back(std::move(newAddon));
else
m_failedAddons.emplace_back(std::move(newAddon));
}
}
}
// Destroy removed add-ons
for (const std::string& addonId : removed)
{
UnRegisterAddon(addonId);
}
}
