xbmc/settings/SettingsBase.cpp

   1 /*
   2  *  Copyright (C) 2016-2018 Team Kodi
   3  *  This file is part of Kodi - https://kodi.tv
   4  *
   5  *  SPDX-License-Identifier: GPL-2.0-or-later
   6  *  See LICENSES/README.md for more information.
   7  */
   8
   9 #include "SettingsBase.h"
  10
  11 #include "settings/SettingUtils.h"
  12 #include "settings/SettingsValueXmlSerializer.h"
  13 #include "settings/lib/Setting.h"
  14 #include "settings/lib/SettingsManager.h"
  15 #include "utils/Variant.h"
  16 #include "utils/XBMCTinyXML.h"
  17
  18 #include <mutex>
  19
  20 #define SETTINGS_XML_ROOT   "settings"
  21
  22 CSettingsBase::CSettingsBase()
  23   : m_settingsManager(new CSettingsManager())
  24 { }
  25
  26 CSettingsBase::~CSettingsBase()
  27 {
  28   Uninitialize();
  29
  30   delete m_settingsManager;
  31 }
  32
  33 bool CSettingsBase::Initialize()
  34 {
  35   std::unique_lock<CCriticalSection> lock(m_critical);
  36   if (m_initialized)
  37     return false;
  38
  39   // register custom setting types
  40   InitializeSettingTypes();
  41   // register custom setting controls
  42   InitializeControls();
  43
  44   // option fillers and conditions need to be
  45   // initialized before the setting definitions
  46   InitializeOptionFillers();
  47   InitializeConditions();
  48
  49   // load the settings definitions
  50   if (!InitializeDefinitions())
  51     return false;
  52
  53   InitializeVisibility();
  54   InitializeDefaults();
  55
  56   m_settingsManager->SetInitialized();
  57
  58   InitializeISettingsHandlers();
  59   InitializeISubSettings();
  60   InitializeISettingCallbacks();
  61
  62   m_initialized = true;
  63
  64   return true;
  65 }
  66
  67 bool CSettingsBase::IsInitialized() const
  68 {
  69   return m_initialized && m_settingsManager->IsInitialized();
  70 }
  71
  72 bool CSettingsBase::LoadValuesFromXml(const CXBMCTinyXML& xml, bool& updated)
  73 {
  74   const TiXmlElement* xmlRoot = xml.RootElement();
  75   if (xmlRoot == nullptr || xmlRoot->ValueStr() != SETTINGS_XML_ROOT)
  76     return false;
  77
  78   return m_settingsManager->Load(xmlRoot, updated);
  79 }
  80
  81 bool CSettingsBase::LoadValuesFromXml(const TiXmlElement* root, bool& updated)
  82 {
  83   if (root == nullptr)
  84     return false;
  85
  86   return m_settingsManager->Load(root, updated);
  87 }
  88
  89 bool CSettingsBase::LoadHiddenValuesFromXml(const TiXmlElement* root)
  90 {
  91   if (root == nullptr)
  92     return false;
  93
  94   std::map<std::string, std::shared_ptr<CSetting>> loadedSettings;
  95
  96   bool updated;
  97   // don't trigger events for hidden settings
  98   bool success = m_settingsManager->Load(root, updated, false, &loadedSettings);
  99   if (success)
 100   {
 101     for(std::map<std::string, std::shared_ptr<CSetting>>::const_iterator setting = loadedSettings.begin(); setting != loadedSettings.end(); ++setting)
 102       setting->second->SetVisible(false);
 103   }
 104
 105   return success;
 106 }
 107
 108 void CSettingsBase::SetLoaded()
 109 {
 110   m_settingsManager->SetLoaded();
 111 }
 112
 113 bool CSettingsBase::IsLoaded() const
 114 {
 115   return m_settingsManager->IsLoaded();
 116 }
 117
 118 bool CSettingsBase::SaveValuesToXml(CXBMCTinyXML& xml) const
 119 {
 120   std::string serializedSettings;
 121   auto xmlSerializer = std::make_unique<CSettingsValueXmlSerializer>();
 122   if (!m_settingsManager->Save(xmlSerializer.get(), serializedSettings))
 123     return false;
 124
 125   if (!xml.Parse(serializedSettings))
 126     return false;
 127
 128   return true;
 129 }
 130
 131 void CSettingsBase::Unload()
 132 {
 133   m_settingsManager->Unload();
 134 }
 135
 136 void CSettingsBase::Uninitialize()
 137 {
 138   std::unique_lock<CCriticalSection> lock(m_critical);
 139   if (!m_initialized)
 140     return;
 141
 142   // unregister setting option fillers
 143   UninitializeOptionFillers();
 144
 145   // unregister setting conditions
 146   UninitializeConditions();
 147
 148   // unregister ISettingCallback implementations
 149   UninitializeISettingCallbacks();
 150
 151   // cleanup the settings manager
 152   m_settingsManager->Clear();
 153
 154   // unregister ISubSettings implementations
 155   UninitializeISubSettings();
 156   // unregister ISettingsHandler implementations
 157   UninitializeISettingsHandlers();
 158
 159   m_initialized = false;
 160 }
 161
 162 void CSettingsBase::RegisterCallback(ISettingCallback* callback, const std::set<std::string>& settingList)
 163 {
 164   m_settingsManager->RegisterCallback(callback, settingList);
 165 }
 166
 167 void CSettingsBase::UnregisterCallback(ISettingCallback* callback)
 168 {
 169   m_settingsManager->UnregisterCallback(callback);
 170 }
 171
 172 SettingPtr CSettingsBase::GetSetting(const std::string& id) const
 173 {
 174   if (id.empty())
 175     return nullptr;
 176
 177   return m_settingsManager->GetSetting(id);
 178 }
 179
 180 std::vector<std::shared_ptr<CSettingSection>> CSettingsBase::GetSections() const
 181 {
 182   return m_settingsManager->GetSections();
 183 }
 184
 185 std::shared_ptr<CSettingSection> CSettingsBase::GetSection(const std::string& section) const
 186 {
 187   if (section.empty())
 188     return nullptr;
 189
 190   return m_settingsManager->GetSection(section);
 191 }
 192
 193 bool CSettingsBase::GetBool(const std::string& id) const
 194 {
 195   return m_settingsManager->GetBool(id);
 196 }
 197
 198 bool CSettingsBase::SetBool(const std::string& id, bool value)
 199 {
 200   return m_settingsManager->SetBool(id, value);
 201 }
 202
 203 bool CSettingsBase::ToggleBool(const std::string& id)
 204 {
 205   return m_settingsManager->ToggleBool(id);
 206 }
 207
 208 int CSettingsBase::GetInt(const std::string& id) const
 209 {
 210   return m_settingsManager->GetInt(id);
 211 }
 212
 213 bool CSettingsBase::SetInt(const std::string& id, int value)
 214 {
 215   return m_settingsManager->SetInt(id, value);
 216 }
 217
 218 double CSettingsBase::GetNumber(const std::string& id) const
 219 {
 220   return m_settingsManager->GetNumber(id);
 221 }
 222
 223 bool CSettingsBase::SetNumber(const std::string& id, double value)
 224 {
 225   return m_settingsManager->SetNumber(id, value);
 226 }
 227
 228 std::string CSettingsBase::GetString(const std::string& id) const
 229 {
 230   return m_settingsManager->GetString(id);
 231 }
 232
 233 bool CSettingsBase::SetString(const std::string& id, const std::string& value)
 234 {
 235   return m_settingsManager->SetString(id, value);
 236 }
 237
 238 std::vector<CVariant> CSettingsBase::GetList(const std::string& id) const
 239 {
 240   std::shared_ptr<CSetting> setting = m_settingsManager->GetSetting(id);
 241   if (setting == nullptr || setting->GetType() != SettingType::List)
 242     return std::vector<CVariant>();
 243
 244   return CSettingUtils::GetList(std::static_pointer_cast<CSettingList>(setting));
 245 }
 246
 247 bool CSettingsBase::SetList(const std::string& id, const std::vector<CVariant>& value)
 248 {
 249   std::shared_ptr<CSetting> setting = m_settingsManager->GetSetting(id);
 250   if (setting == nullptr || setting->GetType() != SettingType::List)
 251     return false;
 252
 253   return CSettingUtils::SetList(std::static_pointer_cast<CSettingList>(setting), value);
 254 }
 255
 256 bool CSettingsBase::SetDefault(const std::string &id)
 257 {
 258   return m_settingsManager->SetDefault(id);
 259 }
 260
 261 void CSettingsBase::SetDefaults()
 262 {
 263   m_settingsManager->SetDefaults();
 264 }
 265
 266 bool CSettingsBase::InitializeDefinitionsFromXml(const CXBMCTinyXML& xml)
 267 {
 268   const TiXmlElement* root = xml.RootElement();
 269   if (root == nullptr)
 270     return false;
 271
 272   return m_settingsManager->Initialize(root);
 273 }