void CGUIDialogPeripheralSettings::Save()
{
if (m_item == NULL || m_initialising)
return;
PeripheralPtr peripheral = g_peripherals.GetByPath(m_item->GetPath());
if (!peripheral)
return;
peripheral->PersistSettings();
}
void CGUIDialogPeripheralSettings::OnResetSettings()
{
if (m_item == NULL)
return;
PeripheralPtr peripheral = g_peripherals.GetByPath(m_item->GetPath());
if (!peripheral)
return;
if (!CGUIDialogYesNo::ShowAndGetInput(CVariant{10041}, CVariant{10042}))
return;
// reset the settings in the peripheral
peripheral->ResetDefaultSettings();
// re-create all settings and their controls
SetupView();
}
bool CPeripheralAddon::Register(unsigned int peripheralIndex, const PeripheralPtr& peripheral)
{
if (!peripheral)
return false;
CSingleLock lock(m_critSection);
if (m_peripherals.find(peripheralIndex) == m_peripherals.end())
{
if (peripheral->Type() == PERIPHERAL_JOYSTICK)
{
m_peripherals[peripheralIndex] = std::static_pointer_cast<CPeripheralJoystick>(peripheral);
CLog::Log(LOGNOTICE, "%s - new %s device registered on %s->%s: %s",
__FUNCTION__, PeripheralTypeTranslator::TypeToString(peripheral->Type()),
PeripheralTypeTranslator::BusTypeToString(PERIPHERAL_BUS_ADDON),
peripheral->Location().c_str(), peripheral->DeviceName().c_str());
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);
}
}
void CPeripheralBus::Register(const PeripheralPtr& peripheral)
{
if (!peripheral)
return;
bool bPeripheralAdded = false;
{
CSingleLock lock(m_critSection);
if (!HasPeripheral(peripheral->Location()))
{
m_peripherals.push_back(peripheral);
bPeripheralAdded = true;
}
}
if (bPeripheralAdded)
{
CLog::Log(LOGNOTICE, "%s - new %s device registered on %s->%s: %s (%s:%s)", __FUNCTION__, PeripheralTypeTranslator::TypeToString(peripheral->Type()), PeripheralTypeTranslator::BusTypeToString(m_type), peripheral->Location().c_str(), peripheral->DeviceName().c_str(), peripheral->VendorIdAsString(), peripheral->ProductIdAsString());
m_manager.OnDeviceAdded(*this, *peripheral);
}
}
void CPeripherals::OnSettingAction(const CSetting *setting)
{
if (setting == nullptr)
return;
const std::string &settingId = setting->GetId();
if (settingId == CSettings::SETTING_INPUT_PERIPHERALS)
{
CGUIDialogSelect* pDialog = (CGUIDialogSelect*)g_windowManager.GetWindow(WINDOW_DIALOG_SELECT);
CFileItemList items;
GetDirectory("peripherals://all/", items);
int iPos = -1;
do
{
pDialog->Reset();
pDialog->SetHeading(CVariant{35000});
pDialog->SetUseDetails(true);
pDialog->SetItems(items);
pDialog->SetSelected(iPos);
pDialog->Open();
iPos = pDialog->IsConfirmed() ? pDialog->GetSelectedItem() : -1;
if (iPos >= 0)
{
CFileItemPtr pItem = items.Get(iPos);
// show an error if the peripheral doesn't have any settings
PeripheralPtr peripheral = GetByPath(pItem->GetPath());
if (!peripheral || peripheral->GetSettings().empty())
{
CGUIDialogOK::ShowAndGetInput(CVariant{35000}, CVariant{35004});
continue;
}
CGUIDialogPeripheralSettings *pSettingsDialog = (CGUIDialogPeripheralSettings *)g_windowManager.GetWindow(WINDOW_DIALOG_PERIPHERAL_SETTINGS);
if (pItem && pSettingsDialog)
{
// pass peripheral item properties to settings dialog so skin authors
// can use it to show more detailed information about the device
pSettingsDialog->SetProperty("vendor", pItem->GetProperty("vendor"));
pSettingsDialog->SetProperty("product", pItem->GetProperty("product"));
pSettingsDialog->SetProperty("bus", pItem->GetProperty("bus"));
pSettingsDialog->SetProperty("location", pItem->GetProperty("location"));
pSettingsDialog->SetProperty("class", pItem->GetProperty("class"));
pSettingsDialog->SetProperty("version", pItem->GetProperty("version"));
// open settings dialog
pSettingsDialog->SetFileItem(pItem.get());
pSettingsDialog->Open();
}
}
} while (pDialog->IsConfirmed());
}
else if (settingId == CSettings::SETTING_INPUT_CONTROLLERCONFIG)
g_windowManager.ActivateWindow(WINDOW_DIALOG_GAME_CONTROLLERS);
else if (settingId == CSettings::SETTING_INPUT_TESTRUMBLE)
TestFeature(FEATURE_RUMBLE);
}
void CPeripherals::CreatePeripheral(CPeripheralBus &bus, const PeripheralScanResult& result)
{
PeripheralPtr peripheral;
PeripheralScanResult mappedResult = result;
if (mappedResult.m_busType == PERIPHERAL_BUS_UNKNOWN)
mappedResult.m_busType = bus.Type();
/* check whether there's something mapped in peripherals.xml */
GetMappingForDevice(bus, mappedResult);
switch(mappedResult.m_mappedType)
{
case PERIPHERAL_HID:
peripheral = PeripheralPtr(new CPeripheralHID(mappedResult, &bus));
break;
case PERIPHERAL_NIC:
peripheral = PeripheralPtr(new CPeripheralNIC(mappedResult, &bus));
break;
case PERIPHERAL_DISK:
peripheral = PeripheralPtr(new CPeripheralDisk(mappedResult, &bus));
break;
case PERIPHERAL_NYXBOARD:
peripheral = PeripheralPtr(new CPeripheralNyxboard(mappedResult, &bus));
break;
case PERIPHERAL_TUNER:
peripheral = PeripheralPtr(new CPeripheralTuner(mappedResult, &bus));
break;
case PERIPHERAL_BLUETOOTH:
peripheral = PeripheralPtr(new CPeripheralBluetooth(mappedResult, &bus));
break;
case PERIPHERAL_CEC:
#if defined(HAVE_LIBCEC)
if (bus.Type() == PERIPHERAL_BUS_CEC)
peripheral = PeripheralPtr(new CPeripheralCecAdapter(mappedResult, &bus));
#else
if (!m_bMissingLibCecWarningDisplayed)
{
m_bMissingLibCecWarningDisplayed = true;
CLog::Log(LOGWARNING, "%s - libCEC support has not been compiled in, so the CEC adapter cannot be used.", __FUNCTION__);
CGUIDialogKaiToast::QueueNotification(CGUIDialogKaiToast::Warning, g_localizeStrings.Get(36000), g_localizeStrings.Get(36017));
}
#endif
break;
case PERIPHERAL_IMON:
peripheral = PeripheralPtr(new CPeripheralImon(mappedResult, &bus));
break;
case PERIPHERAL_JOYSTICK:
peripheral = PeripheralPtr(new CPeripheralJoystick(mappedResult, &bus));
break;
default:
break;
}
if (peripheral)
{
/* try to initialise the new peripheral
* Initialise() will make sure that each device is only initialised once */
if (peripheral->Initialise())
bus.Register(peripheral);
else
{
CLog::Log(LOGDEBUG, "%s - failed to initialise peripheral on '%s'", __FUNCTION__, mappedResult.m_strLocation.c_str());
}
}
}
void CGUIDialogPeripheralSettings::InitializeSettings()
{
if (m_item == NULL)
{
m_initialising = false;
return;
}
m_initialising = true;
bool usePopup = g_SkinInfo->HasSkinFile("DialogSlider.xml");
PeripheralPtr peripheral = g_peripherals.GetByPath(m_item->GetPath());
if (!peripheral)
{
CLog::Log(LOGDEBUG, "%s - no peripheral", __FUNCTION__);
m_initialising = false;
return;
}
m_settingsMap.clear();
CGUIDialogSettingsManualBase::InitializeSettings();
CSettingCategory *category = AddCategory("peripheralsettings", -1);
if (category == NULL)
{
CLog::Log(LOGERROR, "CGUIDialogPeripheralSettings: unable to setup settings");
return;
}
CSettingGroup *group = AddGroup(category);
if (group == NULL)
{
CLog::Log(LOGERROR, "CGUIDialogPeripheralSettings: unable to setup settings");
return;
}
std::vector<CSetting*> settings = peripheral->GetSettings();
for (std::vector<CSetting*>::iterator itSetting = settings.begin(); itSetting != settings.end(); ++itSetting)
{
CSetting *setting = *itSetting;
if (setting == NULL)
continue;
if (!setting->IsVisible())
{
CLog::Log(LOGDEBUG, "%s - invisible", __FUNCTION__);
continue;
}
// we need to create a copy of the setting because the CSetting instances
// are destroyed when leaving the dialog
CSetting *settingCopy = NULL;
switch(setting->GetType())
{
case SettingTypeBool:
{
CSettingBool *settingBool = new CSettingBool(setting->GetId(), *static_cast<CSettingBool*>(setting));
settingBool->SetControl(GetCheckmarkControl());
settingCopy = static_cast<CSetting*>(settingBool);
break;
}
case SettingTypeInteger:
{
CSettingInt *settingInt = new CSettingInt(setting->GetId(), *static_cast<CSettingInt*>(setting));
if (settingInt->GetOptions().empty())
settingInt->SetControl(GetSliderControl("integer", false, -1, usePopup, -1, "%i"));
else
settingInt->SetControl(GetSpinnerControl("string"));
settingCopy = static_cast<CSetting*>(settingInt);
break;
}
case SettingTypeNumber:
{
CSettingNumber *settingNumber = new CSettingNumber(setting->GetId(), *static_cast<CSettingNumber*>(setting));
settingNumber->SetControl(GetSliderControl("number", false, -1, usePopup, -1, "%2.2f"));
settingCopy = static_cast<CSetting*>(settingNumber);
break;
}
case SettingTypeString:
{
CSettingString *settingString = new CSettingString(setting->GetId(), *static_cast<CSettingString*>(setting));
settingString->SetControl(GetEditControl("string"));
settingCopy = static_cast<CSetting*>(settingString);
break;
}
default:
//! @todo add more types if needed
CLog::Log(LOGDEBUG, "%s - unknown type", __FUNCTION__);
break;
}
if (settingCopy != NULL && settingCopy->GetControl() != NULL)
{
settingCopy->SetLevel(SettingLevelBasic);
group->AddSetting(settingCopy);
m_settingsMap.insert(std::make_pair(setting->GetId(), setting));
}
}
m_initialising = false;
}
bool CPeripheralAddon::ProcessEvents(void)
{
if (!m_bProvidesJoysticks)
return false;
PERIPHERAL_ERROR retVal;
unsigned int eventCount = 0;
PERIPHERAL_EVENT* pEvents = NULL;
LogError(retVal = m_pStruct->GetEvents(&eventCount, &pEvents), "GetEvents()");
if (retVal == PERIPHERAL_NO_ERROR)
{
for (unsigned int i = 0; i < eventCount; i++)
{
ADDON::PeripheralEvent event(pEvents[i]);
PeripheralPtr device = GetPeripheral(event.PeripheralIndex());
if (!device)
continue;
switch (device->Type())
{
case PERIPHERAL_JOYSTICK:
{
std::shared_ptr<CPeripheralJoystick> joystickDevice = std::static_pointer_cast<CPeripheralJoystick>(device);
switch (event.Type())
{
case PERIPHERAL_EVENT_TYPE_DRIVER_BUTTON:
{
const bool bPressed = (event.ButtonState() == JOYSTICK_STATE_BUTTON_PRESSED);
CLog::Log(LOGDEBUG, "Button [ %u ] on %s %s", event.DriverIndex(),
joystickDevice->DeviceName().c_str(), bPressed ? "pressed" : "released");
if (joystickDevice->OnButtonMotion(event.DriverIndex(), bPressed))
CLog::Log(LOGDEBUG, "Joystick button event handled");
break;
}
case PERIPHERAL_EVENT_TYPE_DRIVER_HAT:
{
const HAT_STATE state = CPeripheralAddonTranslator::TranslateHatState(event.HatState());
CLog::Log(LOGDEBUG, "Hat [ %u ] on %s %s", event.DriverIndex(),
joystickDevice->DeviceName().c_str(), CJoystickTranslator::HatStateToString(state));
if (joystickDevice->OnHatMotion(event.DriverIndex(), state))
CLog::Log(LOGDEBUG, "Joystick hat event handled");
break;
}
case PERIPHERAL_EVENT_TYPE_DRIVER_AXIS:
{
joystickDevice->OnAxisMotion(event.DriverIndex(), event.AxisState());
break;
}
default:
break;
}
break;
}
default:
break;
}
}
for (auto it : m_peripherals)
{
if (it.second->Type() == PERIPHERAL_JOYSTICK)
std::static_pointer_cast<CPeripheralJoystick>(it.second)->ProcessAxisMotions();
}
m_pStruct->FreeEvents(eventCount, pEvents);
return true;
}
return false;
}
