code.vuplus.com Git - vuplus_xbmc/blob - xbmc/settings/Settings.cpp

   1 /*
   2  *      Copyright (C) 2005-2013 Team XBMC
   3  *      http://www.xbmc.org
   4  *
   5  *  This Program is free software; you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation; either version 2, or (at your option)
   8  *  any later version.
   9  *
  10  *  This Program is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with XBMC; see the file COPYING.  If not, see
  17  *  <http://www.gnu.org/licenses/>.
  18  *
  19  */
  20
  21 #include "system.h"
  22
  23 #include "Settings.h"
  24 #include "Application.h"
  25 #include "Autorun.h"
  26 #include "GUIPassword.h"
  27 #include "LangInfo.h"
  28 #include "Util.h"
  29 #include "addons/AddonManager.h"
  30 #include "addons/Skin.h"
  31 #include "cores/AudioEngine/AEFactory.h"
  32 #if defined(HAVE_LIBCRYSTALHD)
  33 #include "cores/dvdplayer/DVDCodecs/Video/CrystalHD.h"
  34 #endif // defined(HAVE_LIBCRYSTALHD)
  35 #include "cores/playercorefactory/PlayerCoreFactory.h"
  36 #include "cores/VideoRenderers/BaseRenderer.h"
  37 #include "filesystem/File.h"
  38 #include "guilib/GraphicContext.h"
  39 #include "guilib/GUIAudioManager.h"
  40 #include "guilib/GUIFontManager.h"
  41 #include "guilib/LocalizeStrings.h"
  42 #include "input/MouseStat.h"
  43 #if defined(TARGET_WINDOWS)
  44 #include "input/windows/WINJoystick.h"
  45 #elif defined(HAS_SDL_JOYSTICK)
  46 #include "input/SDLJoystick.h"
  47 #endif // defined(HAS_SDL_JOYSTICK)
  48 #if defined(TARGET_POSIX)
  49 #include "linux/LinuxTimezone.h"
  50 #endif // defined(TARGET_POSIX)
  51 #include "network/NetworkServices.h"
  52 #include "network/upnp/UPnPSettings.h"
  53 #include "network/WakeOnAccess.h"
  54 #if defined(TARGET_DARWIN_OSX)
  55 #include "osx/XBMCHelper.h"
  56 #include "cores/AudioEngine/Engines/CoreAudio/CoreAudioHardware.h"
  57 #endif // defined(TARGET_DARWIN_OSX)
  58 #if defined(TARGET_DARWIN)
  59 #include "osx/DarwinUtils.h"
  60 #endif
  61 #include "peripherals/Peripherals.h"
  62 #include "powermanagement/PowerManager.h"
  63 #include "profiles/ProfilesManager.h"
  64 #include "pvr/PVRManager.h"
  65 #include "pvr/windows/GUIWindowPVRGuide.h"
  66 #include "settings/AdvancedSettings.h"
  67 #include "settings/DisplaySettings.h"
  68 #include "settings/MediaSettings.h"
  69 #include "settings/MediaSourceSettings.h"
  70 #include "settings/SettingAddon.h"
  71 #include "settings/SettingsManager.h"
  72 #include "settings/SettingPath.h"
  73 #include "settings/SkinSettings.h"
  74 #include "threads/SingleLock.h"
  75 #include "utils/CharsetConverter.h"
  76 #include "utils/log.h"
  77 #include "utils/RssManager.h"
  78 #include "utils/StringUtils.h"
  79 #include "utils/SystemInfo.h"
  80 #include "utils/Weather.h"
  81 #include "utils/XBMCTinyXML.h"
  82 #include "view/ViewStateSettings.h"
  83 #include "windowing/WindowingFactory.h"
  84
  85 #define SETTINGS_XML_FOLDER "special://xbmc/system/settings/"
  86 #define SETTINGS_XML_ROOT   "settings"
  87
  88 using namespace XFILE;
  89
  90 bool AddonHasSettings(const std::string &condition, const std::string &value, const std::string &settingId)
  91 {
  92   if (settingId.empty())
  93     return false;
  94
  95   CSettingAddon *setting = (CSettingAddon*)CSettings::Get().GetSetting(settingId);
  96   if (setting == NULL)
  97     return false;
  98
  99   ADDON::AddonPtr addon;
 100   if (!ADDON::CAddonMgr::Get().GetAddon(setting->GetValue(), addon, setting->GetAddonType()) || addon == NULL)
 101     return false;
 102
 103   return addon->HasSettings();
 104 }
 105
 106 bool CheckMasterLock(const std::string &condition, const std::string &value, const std::string &settingId)
 107 {
 108   return g_passwordManager.IsMasterLockUnlocked(StringUtils::EqualsNoCase(value, "true"));
 109 }
 110
 111 bool CheckPVRParentalPin(const std::string &condition, const std::string &value, const std::string &settingId)
 112 {
 113   return PVR::g_PVRManager.CheckParentalPIN(g_localizeStrings.Get(19262).c_str());
 114 }
 115
 116 bool HasPeripherals(const std::string &condition, const std::string &value, const std::string &settingId)
 117 {
 118   return PERIPHERALS::g_peripherals.GetNumberOfPeripherals() > 0;
 119 }
 120
 121 bool IsFullscreen(const std::string &condition, const std::string &value, const std::string &settingId)
 122 {
 123   return g_Windowing.IsFullScreen();
 124 }
 125
 126 bool IsMasterUser(const std::string &condition, const std::string &value, const std::string &settingId)
 127 {
 128   return g_passwordManager.bMasterUser;
 129 }
 130
 131 bool IsUsingTTFSubtitles(const std::string &condition, const std::string &value, const std::string &settingId)
 132 {
 133   return CUtil::IsUsingTTFSubtitles();
 134 }
 135
 136 bool ProfileCanWriteDatabase(const std::string &condition, const std::string &value, const std::string &settingId)
 137 {
 138   return CProfilesManager::Get().GetCurrentProfile().canWriteDatabases();
 139 }
 140
 141 bool ProfileCanWriteSources(const std::string &condition, const std::string &value, const std::string &settingId)
 142 {
 143   return CProfilesManager::Get().GetCurrentProfile().canWriteSources();
 144 }
 145
 146 bool ProfileHasAddons(const std::string &condition, const std::string &value, const std::string &settingId)
 147 {
 148   return CProfilesManager::Get().GetCurrentProfile().hasAddons();
 149 }
 150
 151 bool ProfileHasDatabase(const std::string &condition, const std::string &value, const std::string &settingId)
 152 {
 153   return CProfilesManager::Get().GetCurrentProfile().hasDatabases();
 154 }
 155
 156 bool ProfileHasSources(const std::string &condition, const std::string &value, const std::string &settingId)
 157 {
 158   return CProfilesManager::Get().GetCurrentProfile().hasSources();
 159 }
 160
 161 bool ProfileHasAddonManagerLocked(const std::string &condition, const std::string &value, const std::string &settingId)
 162 {
 163   return CProfilesManager::Get().GetCurrentProfile().addonmanagerLocked();
 164 }
 165
 166 bool ProfileHasFilesLocked(const std::string &condition, const std::string &value, const std::string &settingId)
 167 {
 168   return CProfilesManager::Get().GetCurrentProfile().filesLocked();
 169 }
 170
 171 bool ProfileHasMusicLocked(const std::string &condition, const std::string &value, const std::string &settingId)
 172 {
 173   return CProfilesManager::Get().GetCurrentProfile().musicLocked();
 174 }
 175
 176 bool ProfileHasPicturesLocked(const std::string &condition, const std::string &value, const std::string &settingId)
 177 {
 178   return CProfilesManager::Get().GetCurrentProfile().picturesLocked();
 179 }
 180
 181 bool ProfileHasProgramsLocked(const std::string &condition, const std::string &value, const std::string &settingId)
 182 {
 183   return CProfilesManager::Get().GetCurrentProfile().programsLocked();
 184 }
 185
 186 bool ProfileHasSettingsLocked(const std::string &condition, const std::string &value, const std::string &settingId)
 187 {
 188   return CProfilesManager::Get().GetCurrentProfile().settingsLocked();
 189 }
 190
 191 bool ProfileHasVideosLocked(const std::string &condition, const std::string &value, const std::string &settingId)
 192 {
 193   return CProfilesManager::Get().GetCurrentProfile().videoLocked();
 194 }
 195
 196 bool ProfileLockMode(const std::string &condition, const std::string &value, const std::string &settingId)
 197 {
 198   char *tmp = NULL;
 199   LockType lock = (LockType)strtol(value.c_str(), &tmp, 0);
 200   if (tmp != NULL && *tmp != '\0')
 201     return false;
 202
 203   return CProfilesManager::Get().GetCurrentProfile().getLockMode() == lock;
 204 }
 205
 206 CSettings::CSettings()
 207   : m_initialized(false)
 208 {
 209   m_settingsManager = new CSettingsManager();
 210 }
 211
 212 CSettings::~CSettings()
 213 {
 214   Uninitialize();
 215
 216   delete m_settingsManager;
 217 }
 218
 219 CSettings& CSettings::Get()
 220 {
 221   static CSettings sSettings;
 222   return sSettings;
 223 }
 224
 225 CSetting* CSettings::CreateSetting(const std::string &settingType, const std::string &settingId, CSettingsManager *settingsManager /* = NULL */) const
 226 {
 227   if (StringUtils::EqualsNoCase(settingType, "addon"))
 228     return new CSettingAddon(settingId, settingsManager);
 229   else if (StringUtils::EqualsNoCase(settingType, "path"))
 230     return new CSettingPath(settingId, settingsManager);
 231
 232   return NULL;
 233 }
 234
 235 bool CSettings::Initialize()
 236 {
 237   CSingleLock lock(m_critical);
 238   if (m_initialized)
 239     return false;
 240
 241   // register custom setting types
 242   InitializeSettingTypes();
 243
 244   // option fillers and conditions need to be
 245   // initialized before the setting definitions
 246   InitializeOptionFillers();
 247   InitializeConditions();
 248
 249   // load the settings definitions
 250   if (!InitializeDefinitions())
 251     return false;
 252
 253   m_settingsManager->SetInitialized();
 254
 255   InitializeISettingsHandlers();
 256   InitializeISubSettings();
 257   InitializeISettingCallbacks();
 258
 259   m_initialized = true;
 260
 261   return true;
 262 }
 263
 264 bool CSettings::Load()
 265 {
 266   return Load(CProfilesManager::Get().GetSettingsFile());
 267 }
 268
 269 bool CSettings::Load(const std::string &file)
 270 {
 271   CXBMCTinyXML xmlDoc;
 272   bool updated = false;
 273   if (!XFILE::CFile::Exists(file) || !xmlDoc.LoadFile(file) ||
 274       !m_settingsManager->Load(xmlDoc.RootElement(), updated))
 275   {
 276     CLog::Log(LOGERROR, "CSettingsManager: unable to load settings from %s, creating new default settings", file.c_str());
 277     if (!Reset())
 278       return false;
 279
 280     if (!Load(file))
 281       return false;
 282   }
 283   // if the settings had to be updated, we need to save the changes
 284   else if (updated)
 285     return Save(file);
 286
 287   return true;
 288 }
 289
 290 bool CSettings::Load(const TiXmlElement *root, bool hide /* = false */)
 291 {
 292   if (root == NULL)
 293     return false;
 294
 295   std::map<std::string, CSetting*> *loadedSettings = NULL;
 296   if (hide)
 297     loadedSettings = new std::map<std::string, CSetting*>();
 298
 299   bool updated;
 300   // only trigger settings events if hiding is disabled
 301   bool success = m_settingsManager->Load(root, updated, !hide, loadedSettings);
 302   // if necessary hide all the loaded settings
 303   if (success && hide && loadedSettings != NULL)
 304   {
 305     for(std::map<std::string, CSetting*>::const_iterator setting = loadedSettings->begin(); setting != loadedSettings->end(); ++setting)
 306       setting->second->SetVisible(false);
 307
 308     delete loadedSettings;
 309   }
 310
 311   return success;
 312 }
 313
 314 void CSettings::SetLoaded()
 315 {
 316   m_settingsManager->SetLoaded();
 317 }
 318
 319 bool CSettings::Save()
 320 {
 321   return Save(CProfilesManager::Get().GetSettingsFile());
 322 }
 323
 324 bool CSettings::Save(const std::string &file)
 325 {
 326   CXBMCTinyXML xmlDoc;
 327   TiXmlElement rootElement(SETTINGS_XML_ROOT);
 328   TiXmlNode *root = xmlDoc.InsertEndChild(rootElement);
 329   if (root == NULL)
 330     return false;
 331
 332   if (!m_settingsManager->Save(root))
 333     return false;
 334
 335   return xmlDoc.SaveFile(file);
 336 }
 337
 338 void CSettings::Unload()
 339 {
 340   CSingleLock lock(m_critical);
 341   m_settingsManager->Unload();
 342 }
 343
 344 void CSettings::Uninitialize()
 345 {
 346   CSingleLock lock(m_critical);
 347   if (!m_initialized)
 348     return;
 349
 350   // unregister setting option fillers
 351   m_settingsManager->UnregisterSettingOptionsFiller("audiocdactions");
 352   m_settingsManager->UnregisterSettingOptionsFiller("audiocdencoders");
 353   m_settingsManager->UnregisterSettingOptionsFiller("audiodevices");
 354   m_settingsManager->UnregisterSettingOptionsFiller("audiodevicespassthrough");
 355   m_settingsManager->UnregisterSettingOptionsFiller("audiooutputmodes");
 356   m_settingsManager->UnregisterSettingOptionsFiller("charsets");
 357   m_settingsManager->UnregisterSettingOptionsFiller("epgguideviews");
 358   m_settingsManager->UnregisterSettingOptionsFiller("fontheights");
 359   m_settingsManager->UnregisterSettingOptionsFiller("fonts");
 360   m_settingsManager->UnregisterSettingOptionsFiller("languages");
 361   m_settingsManager->UnregisterSettingOptionsFiller("pvrstartlastchannel");
 362   m_settingsManager->UnregisterSettingOptionsFiller("refreshchangedelays");
 363   m_settingsManager->UnregisterSettingOptionsFiller("refreshrates");
 364   m_settingsManager->UnregisterSettingOptionsFiller("regions");
 365   m_settingsManager->UnregisterSettingOptionsFiller("rendermethods");
 366   m_settingsManager->UnregisterSettingOptionsFiller("resolutions");
 367   m_settingsManager->UnregisterSettingOptionsFiller("screens");
 368   m_settingsManager->UnregisterSettingOptionsFiller("shutdownstates");
 369   m_settingsManager->UnregisterSettingOptionsFiller("startupwindows");
 370   m_settingsManager->UnregisterSettingOptionsFiller("streamlanguages");
 371   m_settingsManager->UnregisterSettingOptionsFiller("skincolors");
 372   m_settingsManager->UnregisterSettingOptionsFiller("skinfonts");
 373   m_settingsManager->UnregisterSettingOptionsFiller("skinsounds");
 374   m_settingsManager->UnregisterSettingOptionsFiller("skinthemes");
 375 #if defined(TARGET_LINUX)
 376   m_settingsManager->UnregisterSettingOptionsFiller("timezonecountries");
 377   m_settingsManager->UnregisterSettingOptionsFiller("timezones");
 378 #endif // defined(TARGET_LINUX)
 379   m_settingsManager->UnregisterSettingOptionsFiller("verticalsyncs");
 380
 381   // unregister ISettingCallback implementations
 382   m_settingsManager->UnregisterCallback(&g_advancedSettings);
 383   m_settingsManager->UnregisterCallback(&CMediaSettings::Get());
 384   m_settingsManager->UnregisterCallback(&CDisplaySettings::Get());
 385   m_settingsManager->UnregisterCallback(&g_application);
 386   m_settingsManager->UnregisterCallback(&g_audioManager);
 387   m_settingsManager->UnregisterCallback(&g_charsetConverter);
 388   m_settingsManager->UnregisterCallback(&g_graphicsContext);
 389   m_settingsManager->UnregisterCallback(&g_langInfo);
 390 #if defined(TARGET_WINDOWS) || defined(HAS_SDL_JOYSTICK)
 391   m_settingsManager->UnregisterCallback(&g_Joystick);
 392 #endif
 393   m_settingsManager->UnregisterCallback(&g_Mouse);
 394   m_settingsManager->UnregisterCallback(&CNetworkServices::Get());
 395   m_settingsManager->UnregisterCallback(&g_passwordManager);
 396   m_settingsManager->UnregisterCallback(&PVR::g_PVRManager);
 397   m_settingsManager->UnregisterCallback(&CRssManager::Get());
 398 #if defined(TARGET_LINUX)
 399   m_settingsManager->UnregisterCallback(&g_timezone);
 400 #endif // defined(TARGET_LINUX)
 401   m_settingsManager->UnregisterCallback(&g_weatherManager);
 402   m_settingsManager->UnregisterCallback(&PERIPHERALS::CPeripherals::Get());
 403
 404   // unregister ISubSettings implementations
 405   m_settingsManager->UnregisterSubSettings(&g_application);
 406   m_settingsManager->UnregisterSubSettings(&CDisplaySettings::Get());
 407   m_settingsManager->UnregisterSubSettings(&CMediaSettings::Get());
 408   m_settingsManager->UnregisterSubSettings(&CSkinSettings::Get());
 409   m_settingsManager->UnregisterSubSettings(&g_sysinfo);
 410   m_settingsManager->UnregisterSubSettings(&CViewStateSettings::Get());
 411
 412   // unregister ISettingsHandler implementations
 413   m_settingsManager->UnregisterSettingsHandler(&CWakeOnAccess::Get());
 414   m_settingsManager->UnregisterSettingsHandler(&g_advancedSettings);
 415   m_settingsManager->UnregisterSettingsHandler(&CMediaSourceSettings::Get());
 416   m_settingsManager->UnregisterSettingsHandler(&CPlayerCoreFactory::Get());
 417   m_settingsManager->UnregisterSettingsHandler(&CRssManager::Get());
 418 #ifdef HAS_UPNP
 419   m_settingsManager->UnregisterSettingsHandler(&CUPnPSettings::Get());
 420 #endif
 421   m_settingsManager->UnregisterSettingsHandler(&CProfilesManager::Get());
 422   m_settingsManager->UnregisterSettingsHandler(&g_application);
 423
 424   // cleanup the settings manager
 425   m_settingsManager->Clear();
 426
 427   m_initialized = false;
 428 }
 429
 430 void CSettings::RegisterCallback(ISettingCallback *callback, const std::set<std::string> &settingList)
 431 {
 432   m_settingsManager->RegisterCallback(callback, settingList);
 433 }
 434
 435 void CSettings::UnregisterCallback(ISettingCallback *callback)
 436 {
 437   m_settingsManager->UnregisterCallback(callback);
 438 }
 439
 440 CSetting* CSettings::GetSetting(const std::string &id) const
 441 {
 442   CSingleLock lock(m_critical);
 443   if (id.empty())
 444     return NULL;
 445
 446   return m_settingsManager->GetSetting(id);
 447 }
 448
 449 CSettingSection* CSettings::GetSection(const std::string &section) const
 450 {
 451   CSingleLock lock(m_critical);
 452   if (section.empty())
 453     return NULL;
 454
 455   return m_settingsManager->GetSection(section);
 456 }
 457
 458 bool CSettings::GetBool(const std::string &id) const
 459 {
 460   return m_settingsManager->GetBool(id);
 461 }
 462
 463 bool CSettings::SetBool(const std::string &id, bool value)
 464 {
 465   return m_settingsManager->SetBool(id, value);
 466 }
 467
 468 bool CSettings::ToggleBool(const std::string &id)
 469 {
 470   return m_settingsManager->ToggleBool(id);
 471 }
 472
 473 int CSettings::GetInt(const std::string &id) const
 474 {
 475   return m_settingsManager->GetInt(id);
 476 }
 477
 478 bool CSettings::SetInt(const std::string &id, int value)
 479 {
 480   return m_settingsManager->SetInt(id, value);
 481 }
 482
 483 double CSettings::GetNumber(const std::string &id) const
 484 {
 485   return m_settingsManager->GetNumber(id);
 486 }
 487
 488 bool CSettings::SetNumber(const std::string &id, double value)
 489 {
 490   return m_settingsManager->SetNumber(id, value);
 491 }
 492
 493 std::string CSettings::GetString(const std::string &id) const
 494 {
 495   return m_settingsManager->GetString(id);
 496 }
 497
 498 bool CSettings::SetString(const std::string &id, const std::string &value)
 499 {
 500   return m_settingsManager->SetString(id, value);
 501 }
 502
 503 bool CSettings::LoadSetting(const TiXmlNode *node, const std::string &settingId)
 504 {
 505   return m_settingsManager->LoadSetting(node, settingId);
 506 }
 507
 508 bool CSettings::Initialize(const std::string &file)
 509 {
 510   CXBMCTinyXML xmlDoc;
 511   if (!xmlDoc.LoadFile(file.c_str()))
 512   {
 513     CLog::Log(LOGERROR, "CSettings: error loading settings definition from %s, Line %d\n%s", file.c_str(), xmlDoc.ErrorRow(), xmlDoc.ErrorDesc());
 514     return false;
 515   }
 516
 517   CLog::Log(LOGDEBUG, "CSettings: loaded settings definition from %s", file.c_str());
 518
 519   TiXmlElement *root = xmlDoc.RootElement();
 520   if (root == NULL)
 521     return false;
 522
 523   return m_settingsManager->Initialize(root);
 524 }
 525
 526 bool CSettings::InitializeDefinitions()
 527 {
 528   if (!Initialize(SETTINGS_XML_FOLDER "settings.xml"))
 529   {
 530     CLog::Log(LOGFATAL, "Unable to load settings definitions");
 531     return false;
 532   }
 533 #if defined(TARGET_WINDOWS)
 534   if (CFile::Exists(SETTINGS_XML_FOLDER "win32.xml") && !Initialize(SETTINGS_XML_FOLDER "win32.xml"))
 535     CLog::Log(LOGFATAL, "Unable to load win32-specific settings definitions");
 536 #elif defined(TARGET_ANDROID)
 537   if (CFile::Exists(SETTINGS_XML_FOLDER "android.xml") && !Initialize(SETTINGS_XML_FOLDER "android.xml"))
 538     CLog::Log(LOGFATAL, "Unable to load android-specific settings definitions");
 539 #elif defined(TARGET_RASPBERRY_PI)
 540   if (CFile::Exists(SETTINGS_XML_FOLDER "rbp.xml") && !Initialize(SETTINGS_XML_FOLDER "rbp.xml"))
 541     CLog::Log(LOGFATAL, "Unable to load rbp-specific settings definitions");
 542 #elif defined(TARGET_FREEBSD)
 543   if (CFile::Exists(SETTINGS_XML_FOLDER "freebsd.xml") && !Initialize(SETTINGS_XML_FOLDER "freebsd.xml"))
 544     CLog::Log(LOGFATAL, "Unable to load freebsd-specific settings definitions");
 545 #elif defined(TARGET_LINUX)
 546   if (CFile::Exists(SETTINGS_XML_FOLDER "linux.xml") && !Initialize(SETTINGS_XML_FOLDER "linux.xml"))
 547     CLog::Log(LOGFATAL, "Unable to load linux-specific settings definitions");
 548 #elif defined(TARGET_DARWIN)
 549   if (CFile::Exists(SETTINGS_XML_FOLDER "darwin.xml") && !Initialize(SETTINGS_XML_FOLDER "darwin.xml"))
 550     CLog::Log(LOGFATAL, "Unable to load darwin-specific settings definitions");
 551 #if defined(TARGET_DARWIN_OSX)
 552   if (CFile::Exists(SETTINGS_XML_FOLDER "darwin_osx.xml") && !Initialize(SETTINGS_XML_FOLDER "darwin_osx.xml"))
 553     CLog::Log(LOGFATAL, "Unable to load osx-specific settings definitions");
 554 #elif defined(TARGET_DARWIN_IOS)
 555   if (CFile::Exists(SETTINGS_XML_FOLDER "darwin_ios.xml") && !Initialize(SETTINGS_XML_FOLDER "darwin_ios.xml"))
 556     CLog::Log(LOGFATAL, "Unable to load ios-specific settings definitions");
 557 #if defined(TARGET_DARWIN_IOS_ATV2)
 558   if (CFile::Exists(SETTINGS_XML_FOLDER "darwin_ios_atv2.xml") && !Initialize(SETTINGS_XML_FOLDER "darwin_ios_atv2.xml"))
 559     CLog::Log(LOGFATAL, "Unable to load atv2-specific settings definitions");
 560 #endif
 561 #endif
 562 #endif
 563
 564   // load any custom visibility and default values before loading the special
 565   // appliance.xml so that appliances are able to overwrite even those values
 566   InitializeVisibility();
 567   InitializeDefaults();
 568
 569   if (CFile::Exists(SETTINGS_XML_FOLDER "appliance.xml") && !Initialize(SETTINGS_XML_FOLDER "appliance.xml"))
 570     CLog::Log(LOGFATAL, "Unable to load appliance-specific settings definitions");
 571
 572   return true;
 573 }
 574
 575 void CSettings::InitializeSettingTypes()
 576 {
 577   // register "addon" and "path" setting types implemented by CSettingAddon
 578   m_settingsManager->RegisterSettingType("addon", this);
 579   m_settingsManager->RegisterSettingType("path", this);
 580 }
 581
 582 void CSettings::InitializeVisibility()
 583 {
 584   // hide some settings if necessary
 585 #if defined(TARGET_DARWIN)
 586   CSettingString* timezonecountry = (CSettingString*)m_settingsManager->GetSetting("locale.timezonecountry");
 587   CSettingString* timezone = (CSettingString*)m_settingsManager->GetSetting("locale.timezone");
 588
 589   if (!g_sysinfo.IsAppleTV2() || GetIOSVersion() >= 4.3)
 590   {
 591     timezonecountry->SetVisible(false);
 592     timezone->SetVisible(false);
 593   }
 594 #endif
 595 }
 596
 597 void CSettings::InitializeDefaults()
 598 {
 599   // set some default values if necessary
 600 #if defined(HAS_SKIN_TOUCHED) && defined(TARGET_DARWIN_IOS) && !defined(TARGET_DARWIN_IOS_ATV2)
 601   ((CSettingAddon*)m_settingsManager->GetSetting("lookandfeel.skin"))->SetDefault("skin.touched");
 602 #endif
 603
 604 #if defined(TARGET_POSIX)
 605   CSettingString* timezonecountry = (CSettingString*)m_settingsManager->GetSetting("locale.timezonecountry");
 606   CSettingString* timezone = (CSettingString*)m_settingsManager->GetSetting("locale.timezone");
 607
 608   if (timezonecountry->IsVisible())
 609     timezonecountry->SetDefault(g_timezone.GetCountryByTimezone(g_timezone.GetOSConfiguredTimezone()));
 610   if (timezone->IsVisible())
 611     timezone->SetDefault(g_timezone.GetOSConfiguredTimezone());
 612 #endif // defined(TARGET_POSIX)
 613
 614 #if defined(TARGET_WINDOWS)
 615   #if defined(HAS_DX)
 616   ((CSettingString*)m_settingsManager->GetSetting("musicplayer.visualisation"))->SetDefault("visualization.milkdrop");
 617   #endif
 618
 619   #if !defined(HAS_GL)
 620   // We prefer a fake fullscreen mode (window covering the screen rather than dedicated fullscreen)
 621   // as it works nicer with switching to other applications. However on some systems vsync is broken
 622   // when we do this (eg non-Aero on ATI in particular) and on others (AppleTV) we can't get XBMC to
 623   // the front
 624   if (g_sysinfo.IsAeroDisabled())
 625     ((CSettingBool*)m_settingsManager->GetSetting("videoscreen.fakefullscreen"))->SetDefault(false);
 626   #endif
 627 #endif
 628
 629 #if defined(TARGET_DARWIN)
 630   #if !defined(TARGET_DARWIN_IOS)
 631   CStdString defaultAudioDeviceName;
 632   CCoreAudioHardware::GetOutputDeviceName(defaultAudioDeviceName);
 633   ((CSettingString*)m_settingsManager->GetSetting("audiooutput.audiodevice"))->SetDefault(defaultAudioDeviceName);
 634   ((CSettingString*)m_settingsManager->GetSetting("audiooutput.passthroughdevice"))->SetDefault(defaultAudioDeviceName);
 635   #endif
 636 #else
 637   ((CSettingString*)m_settingsManager->GetSetting("audiooutput.audiodevice"))->SetDefault(CAEFactory::GetDefaultDevice(false));
 638   ((CSettingString*)m_settingsManager->GetSetting("audiooutput.passthroughdevice"))->SetDefault(CAEFactory::GetDefaultDevice(true));
 639 #endif
 640
 641   if (g_application.IsStandAlone())
 642     ((CSettingInt*)m_settingsManager->GetSetting("powermanagement.shutdownstate"))->SetDefault(POWERSTATE_SHUTDOWN);
 643
 644 #if defined(HAS_WEB_SERVER)
 645   if (CUtil::CanBindPrivileged())
 646     ((CSettingInt*)m_settingsManager->GetSetting("services.webserverport"))->SetDefault(80);
 647 #endif
 648 }
 649
 650 void CSettings::InitializeOptionFillers()
 651 {
 652   // register setting option fillers
 653 #ifdef HAS_DVD_DRIVE
 654   m_settingsManager->RegisterSettingOptionsFiller("audiocdactions", MEDIA_DETECT::CAutorun::SettingOptionAudioCdActionsFiller);
 655   m_settingsManager->RegisterSettingOptionsFiller("audiocdencoders", MEDIA_DETECT::CAutorun::SettingOptionAudioCdEncodersFiller);
 656 #endif
 657   m_settingsManager->RegisterSettingOptionsFiller("audiodevices", CAEFactory::SettingOptionsAudioDevicesFiller);
 658   m_settingsManager->RegisterSettingOptionsFiller("audiodevicespassthrough", CAEFactory::SettingOptionsAudioDevicesPassthroughFiller);
 659   m_settingsManager->RegisterSettingOptionsFiller("audiooutputmodes", CAEFactory::SettingOptionsAudioOutputModesFiller);
 660   m_settingsManager->RegisterSettingOptionsFiller("charsets", CCharsetConverter::SettingOptionsCharsetsFiller);
 661   m_settingsManager->RegisterSettingOptionsFiller("epgguideviews", PVR::CGUIWindowPVRGuide::SettingOptionsEpgGuideViewFiller);
 662   m_settingsManager->RegisterSettingOptionsFiller("fonts", GUIFontManager::SettingOptionsFontsFiller);
 663   m_settingsManager->RegisterSettingOptionsFiller("languages", CLangInfo::SettingOptionsLanguagesFiller);
 664   m_settingsManager->RegisterSettingOptionsFiller("pvrstartlastchannel", PVR::CPVRManager::SettingOptionsPvrStartLastChannelFiller);
 665   m_settingsManager->RegisterSettingOptionsFiller("refreshchangedelays", CDisplaySettings::SettingOptionsRefreshChangeDelaysFiller);
 666   m_settingsManager->RegisterSettingOptionsFiller("refreshrates", CDisplaySettings::SettingOptionsRefreshRatesFiller);
 667   m_settingsManager->RegisterSettingOptionsFiller("regions", CLangInfo::SettingOptionsRegionsFiller);
 668   m_settingsManager->RegisterSettingOptionsFiller("rendermethods", CBaseRenderer::SettingOptionsRenderMethodsFiller);
 669   m_settingsManager->RegisterSettingOptionsFiller("resolutions", CDisplaySettings::SettingOptionsResolutionsFiller);
 670   m_settingsManager->RegisterSettingOptionsFiller("screens", CDisplaySettings::SettingOptionsScreensFiller);
 671   m_settingsManager->RegisterSettingOptionsFiller("shutdownstates", CPowerManager::SettingOptionsShutdownStatesFiller);
 672   m_settingsManager->RegisterSettingOptionsFiller("startupwindows", ADDON::CSkinInfo::SettingOptionsStartupWindowsFiller);
 673   m_settingsManager->RegisterSettingOptionsFiller("streamlanguages", CLangInfo::SettingOptionsStreamLanguagesFiller);
 674   m_settingsManager->RegisterSettingOptionsFiller("skincolors", ADDON::CSkinInfo::SettingOptionsSkinColorsFiller);
 675   m_settingsManager->RegisterSettingOptionsFiller("skinfonts", ADDON::CSkinInfo::SettingOptionsSkinFontsFiller);
 676   m_settingsManager->RegisterSettingOptionsFiller("skinsounds", ADDON::CSkinInfo::SettingOptionsSkinSoundFiller);
 677   m_settingsManager->RegisterSettingOptionsFiller("skinthemes", ADDON::CSkinInfo::SettingOptionsSkinThemesFiller);
 678 #ifdef TARGET_LINUX
 679   m_settingsManager->RegisterSettingOptionsFiller("timezonecountries", CLinuxTimezone::SettingOptionsTimezoneCountriesFiller);
 680   m_settingsManager->RegisterSettingOptionsFiller("timezones", CLinuxTimezone::SettingOptionsTimezonesFiller);
 681 #endif
 682   m_settingsManager->RegisterSettingOptionsFiller("verticalsyncs", CDisplaySettings::SettingOptionsVerticalSyncsFiller);
 683 }
 684
 685 void CSettings::InitializeConditions()
 686 {
 687   // add basic conditions
 688   m_settingsManager->AddCondition("true");
 689 #ifdef HAS_AIRPLAY
 690   m_settingsManager->AddCondition("has_airplay");
 691 #endif
 692 #ifdef HAS_EVENT_SERVER
 693   m_settingsManager->AddCondition("has_event_server");
 694 #endif
 695 #ifdef HAS_GL
 696   m_settingsManager->AddCondition("has_gl");
 697 #endif
 698 #ifdef HAS_GLES
 699   m_settingsManager->AddCondition("has_gles");
 700 #endif
 701 #if HAS_GLES == 2
 702   m_settingsManager->AddCondition("has_glesv2");
 703 #endif
 704 #ifdef HAS_KARAOKE
 705   m_settingsManager->AddCondition("has_karaoke");
 706 #endif
 707 #ifdef HAS_SDL_JOYSTICK
 708   m_settingsManager->AddCondition("has_sdl_joystick");
 709 #endif
 710 #ifdef HAS_SKIN_TOUCHED
 711   m_settingsManager->AddCondition("has_skin_touched");
 712 #endif
 713 #ifdef HAS_TIME_SERVER
 714   m_settingsManager->AddCondition("has_time_server");
 715 #endif
 716 #ifdef HAS_WEB_SERVER
 717   m_settingsManager->AddCondition("has_web_server");
 718 #endif
 719 #ifdef HAS_ZEROCONF
 720   m_settingsManager->AddCondition("has_zeroconf");
 721 #endif
 722 #ifdef HAVE_LIBCRYSTALHD
 723   m_settingsManager->AddCondition("have_libcrystalhd");
 724   if (CCrystalHD::GetInstance()->DevicePresent())
 725     m_settingsManager->AddCondition("hascrystalhddevice");
 726 #endif
 727 #ifdef HAVE_LIBOPENMAX
 728   m_settingsManager->AddCondition("have_libopenmax");
 729 #endif
 730 #ifdef HAVE_LIBVA
 731   m_settingsManager->AddCondition("have_libva");
 732 #endif
 733 #ifdef HAVE_LIBVDPAU
 734   m_settingsManager->AddCondition("have_libvdpau");
 735 #endif
 736 #ifdef HAVE_VIDEOTOOLBOXDECODER
 737   m_settingsManager->AddCondition("have_videotoolboxdecoder");
 738   if (g_sysinfo.HasVideoToolBoxDecoder())
 739     m_settingsManager->AddCondition("hasvideotoolboxdecoder");
 740 #endif
 741 #ifdef TARGET_DARWIN_IOS_ATV2
 742   if (g_sysinfo.IsAppleTV2())
 743     m_settingsManager->AddCondition("isappletv2");
 744 #endif
 745 #if defined(TARGET_WINDOWS) && defined(HAS_DX)
 746   m_settingsManager->AddCondition("has_dx");
 747   if (g_sysinfo.IsWindowsVersionAtLeast(CSysInfo::WindowsVersionVista))
 748     m_settingsManager->AddCondition("hasdxva2");
 749 #endif
 750
 751   if (g_application.IsStandAlone())
 752     m_settingsManager->AddCondition("isstandalone");
 753
 754   // add more complex conditions
 755   m_settingsManager->AddCondition("addonhassettings", AddonHasSettings);
 756   m_settingsManager->AddCondition("checkmasterlock", CheckMasterLock);
 757   m_settingsManager->AddCondition("checkpvrparentalpin", CheckPVRParentalPin);
 758   m_settingsManager->AddCondition("hasperipherals", HasPeripherals);
 759   m_settingsManager->AddCondition("isfullscreen", IsFullscreen);
 760   m_settingsManager->AddCondition("ismasteruser", IsMasterUser);
 761   m_settingsManager->AddCondition("isusingttfsubtitles", IsUsingTTFSubtitles);
 762   m_settingsManager->AddCondition("profilecanwritedatabase", ProfileCanWriteDatabase);
 763   m_settingsManager->AddCondition("profilecanwritesources", ProfileCanWriteSources);
 764   m_settingsManager->AddCondition("profilehasaddons", ProfileHasAddons);
 765   m_settingsManager->AddCondition("profilehasdatabase", ProfileHasDatabase);
 766   m_settingsManager->AddCondition("profilehassources", ProfileHasSources);
 767   m_settingsManager->AddCondition("profilehasaddonmanagerlocked", ProfileHasAddonManagerLocked);
 768   m_settingsManager->AddCondition("profilehasfileslocked", ProfileHasFilesLocked);
 769   m_settingsManager->AddCondition("profilehasmusiclocked", ProfileHasMusicLocked);
 770   m_settingsManager->AddCondition("profilehaspictureslocked", ProfileHasPicturesLocked);
 771   m_settingsManager->AddCondition("profilehasprogramslocked", ProfileHasProgramsLocked);
 772   m_settingsManager->AddCondition("profilehassettingslocked", ProfileHasSettingsLocked);
 773   m_settingsManager->AddCondition("profilehasvideoslocked", ProfileHasVideosLocked);
 774   m_settingsManager->AddCondition("profilelockmode", ProfileLockMode);
 775 }
 776
 777 void CSettings::InitializeISettingsHandlers()
 778 {
 779   // register ISettingsHandler implementations
 780   m_settingsManager->RegisterSettingsHandler(&g_application);
 781   m_settingsManager->RegisterSettingsHandler(&CProfilesManager::Get());
 782   m_settingsManager->RegisterSettingsHandler(&g_advancedSettings);
 783   m_settingsManager->RegisterSettingsHandler(&CMediaSourceSettings::Get());
 784   m_settingsManager->RegisterSettingsHandler(&CPlayerCoreFactory::Get());
 785   m_settingsManager->RegisterSettingsHandler(&CRssManager::Get());
 786 #ifdef HAS_UPNP
 787   m_settingsManager->RegisterSettingsHandler(&CUPnPSettings::Get());
 788 #endif
 789   m_settingsManager->RegisterSettingsHandler(&CWakeOnAccess::Get());
 790 }
 791
 792 void CSettings::InitializeISubSettings()
 793 {
 794   // register ISubSettings implementations
 795   m_settingsManager->RegisterSubSettings(&g_application);
 796   m_settingsManager->RegisterSubSettings(&CDisplaySettings::Get());
 797   m_settingsManager->RegisterSubSettings(&CMediaSettings::Get());
 798   m_settingsManager->RegisterSubSettings(&CSkinSettings::Get());
 799   m_settingsManager->RegisterSubSettings(&g_sysinfo);
 800   m_settingsManager->RegisterSubSettings(&CViewStateSettings::Get());
 801 }
 802
 803 void CSettings::InitializeISettingCallbacks()
 804 {
 805   // register any ISettingCallback implementations
 806   std::set<std::string> settingSet;
 807   settingSet.insert("debug.showloginfo");
 808   settingSet.insert("debug.setextraloglevel");
 809   m_settingsManager->RegisterCallback(&g_advancedSettings, settingSet);
 810
 811   settingSet.clear();
 812   settingSet.insert("karaoke.export");
 813   settingSet.insert("karaoke.importcsv");
 814   settingSet.insert("musiclibrary.cleanup");
 815   settingSet.insert("musiclibrary.export");
 816   settingSet.insert("musiclibrary.import");
 817   settingSet.insert("musicfiles.trackformat");
 818   settingSet.insert("musicfiles.trackformatright");
 819   settingSet.insert("videolibrary.flattentvshows");
 820   settingSet.insert("videolibrary.removeduplicates");
 821   settingSet.insert("videolibrary.groupmoviesets");
 822   settingSet.insert("videolibrary.cleanup");
 823   settingSet.insert("videolibrary.import");
 824   settingSet.insert("videolibrary.export");
 825   m_settingsManager->RegisterCallback(&CMediaSettings::Get(), settingSet);
 826
 827   settingSet.clear();
 828   settingSet.insert("videoscreen.screen");
 829   settingSet.insert("videoscreen.resolution");
 830   settingSet.insert("videoscreen.screenmode");
 831   m_settingsManager->RegisterCallback(&CDisplaySettings::Get(), settingSet);
 832
 833   settingSet.clear();
 834   settingSet.insert("audiooutput.channels");
 835   settingSet.insert("audiooutput.guisoundmode");
 836   settingSet.insert("lookandfeel.skin");
 837   settingSet.insert("lookandfeel.skinsettings");
 838   settingSet.insert("lookandfeel.font");
 839   settingSet.insert("lookandfeel.skintheme");
 840   settingSet.insert("lookandfeel.skincolors");
 841   settingSet.insert("lookandfeel.skinzoom");
 842   settingSet.insert("musicplayer.replaygainpreamp");
 843   settingSet.insert("musicplayer.replaygainnogainpreamp");
 844   settingSet.insert("musicplayer.replaygaintype");
 845   settingSet.insert("musicplayer.replaygainavoidclipping");
 846   settingSet.insert("scrapers.musicvideosdefault");
 847   settingSet.insert("screensaver.mode");
 848   settingSet.insert("screensaver.preview");
 849   settingSet.insert("screensaver.settings");
 850   settingSet.insert("videoscreen.guicalibration");
 851   settingSet.insert("videoscreen.testpattern");
 852   m_settingsManager->RegisterCallback(&g_application, settingSet);
 853
 854   settingSet.clear();
 855   settingSet.insert("lookandfeel.soundskin");
 856   m_settingsManager->RegisterCallback(&g_audioManager, settingSet);
 857
 858   settingSet.clear();
 859   settingSet.insert("subtitles.charset");
 860   settingSet.insert("karaoke.charset");
 861   settingSet.insert("locale.charset");
 862   m_settingsManager->RegisterCallback(&g_charsetConverter, settingSet);
 863
 864   settingSet.clear();
 865   settingSet.insert("videoscreen.fakefullscreen");
 866   m_settingsManager->RegisterCallback(&g_graphicsContext, settingSet);
 867
 868   settingSet.clear();
 869   settingSet.insert("locale.audiolanguage");
 870   settingSet.insert("locale.subtitlelanguage");
 871   settingSet.insert("locale.language");
 872   settingSet.insert("locale.country");
 873   m_settingsManager->RegisterCallback(&g_langInfo, settingSet);
 874
 875 #if defined(HAS_SDL_JOYSTICK)
 876   settingSet.clear();
 877   settingSet.insert("input.enablejoystick");
 878   m_settingsManager->RegisterCallback(&g_Joystick, settingSet);
 879 #endif
 880
 881   settingSet.clear();
 882   settingSet.insert("input.enablemouse");
 883   m_settingsManager->RegisterCallback(&g_Mouse, settingSet);
 884
 885   settingSet.clear();
 886   settingSet.insert("services.webserver");
 887   settingSet.insert("services.webserverport");
 888   settingSet.insert("services.webserverusername");
 889   settingSet.insert("services.webserverpassword");
 890   settingSet.insert("services.zeroconf");
 891   settingSet.insert("services.airplay");
 892   settingSet.insert("services.useairplaypassword");
 893   settingSet.insert("services.airplaypassword");
 894   settingSet.insert("services.upnpserver");
 895   settingSet.insert("services.upnprenderer");
 896   settingSet.insert("services.upnpcontroller");
 897   settingSet.insert("services.esenabled");
 898   settingSet.insert("services.esport");
 899   settingSet.insert("services.esallinterfaces");
 900   settingSet.insert("services.esinitialdelay");
 901   settingSet.insert("services.escontinuousdelay");
 902   settingSet.insert("smb.winsserver");
 903   settingSet.insert("smb.workgroup");
 904   m_settingsManager->RegisterCallback(&CNetworkServices::Get(), settingSet);
 905
 906   settingSet.clear();
 907   settingSet.insert("masterlock.lockcode");
 908   m_settingsManager->RegisterCallback(&g_passwordManager, settingSet);
 909
 910   settingSet.clear();
 911   settingSet.insert("pvrmanager.enabled");
 912   settingSet.insert("pvrmanager.channelmanager");
 913   settingSet.insert("pvrmanager.channelscan");
 914   settingSet.insert("pvrmanager.resetdb");
 915   settingSet.insert("pvrclient.menuhook");
 916   settingSet.insert("pvrmenu.searchicons");
 917   settingSet.insert("epg.resetepg");
 918   settingSet.insert("pvrparental.enabled");
 919   m_settingsManager->RegisterCallback(&PVR::g_PVRManager, settingSet);
 920
 921   settingSet.clear();
 922   settingSet.insert("lookandfeel.rssedit");
 923   m_settingsManager->RegisterCallback(&CRssManager::Get(), settingSet);
 924
 925 #if defined(TARGET_LINUX)
 926   settingSet.clear();
 927   settingSet.insert("locale.timezone");
 928   settingSet.insert("locale.timezonecountry");
 929   m_settingsManager->RegisterCallback(&g_timezone, settingSet);
 930 #endif
 931
 932   settingSet.clear();
 933   settingSet.insert("weather.addon");
 934   settingSet.insert("weather.addonsettings");
 935   m_settingsManager->RegisterCallback(&g_weatherManager, settingSet);
 936
 937   settingSet.clear();
 938   settingSet.insert("input.peripherals");
 939   settingSet.insert("locale.language");
 940   m_settingsManager->RegisterCallback(&PERIPHERALS::CPeripherals::Get(), settingSet);
 941
 942 #if defined(TARGET_DARWIN_OSX)
 943   settingSet.clear();
 944   settingSet.insert("input.appleremotemode");
 945   m_settingsManager->RegisterCallback(&XBMCHelper::GetInstance(), settingSet);
 946 #endif
 947 }
 948
 949 bool CSettings::Reset()
 950 {
 951   std::string settingsFile = CProfilesManager::Get().GetSettingsFile();
 952   // try to delete the settings file
 953   if (XFILE::CFile::Exists(settingsFile, false) && !XFILE::CFile::Delete(settingsFile))
 954     CLog::Log(LOGWARNING, "Unable to delete old settings file at %s", settingsFile.c_str());
 955
 956   // unload any loaded settings
 957   Unload();
 958
 959   // try to save the default settings
 960   if (!Save())
 961   {
 962     CLog::Log(LOGWARNING, "Failed to save the default settings to %s", settingsFile.c_str());
 963     return false;
 964   }
 965
 966   return true;
 967 }