xbmc/interfaces/json-rpc/SettingsOperations.cpp

   1 /*
   2  *  Copyright (C) 2013-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 "SettingsOperations.h"
  10
  11 #include "ServiceBroker.h"
  12 #include "addons/Addon.h"
  13 #include "addons/Skin.h"
  14 #include "addons/addoninfo/AddonInfo.h"
  15 #include "guilib/LocalizeStrings.h"
  16 #include "settings/SettingAddon.h"
  17 #include "settings/SettingControl.h"
  18 #include "settings/SettingDateTime.h"
  19 #include "settings/SettingPath.h"
  20 #include "settings/SettingUtils.h"
  21 #include "settings/Settings.h"
  22 #include "settings/SettingsComponent.h"
  23 #include "settings/SkinSettings.h"
  24 #include "settings/lib/Setting.h"
  25 #include "settings/lib/SettingDefinitions.h"
  26 #include "settings/lib/SettingSection.h"
  27 #include "utils/StringUtils.h"
  28 #include "utils/Variant.h"
  29
  30 using namespace JSONRPC;
  31
  32 JSONRPC_STATUS CSettingsOperations::GetSections(const std::string &method, ITransportLayer *transport, IClient *client, const CVariant &parameterObject, CVariant &result)
  33 {
  34   SettingLevel level = ParseSettingLevel(parameterObject["level"].asString());
  35   bool listCategories = !parameterObject["properties"].empty() && parameterObject["properties"][0].asString() == "categories";
  36
  37   result["sections"] = CVariant(CVariant::VariantTypeArray);
  38
  39   // apply the level filter
  40   SettingSectionList allSections = CServiceBroker::GetSettingsComponent()->GetSettings()->GetSections();
  41   for (const auto& itSection : allSections)
  42   {
  43     SettingCategoryList categories = itSection->GetCategories(level);
  44     if (categories.empty())
  45       continue;
  46
  47     CVariant varSection(CVariant::VariantTypeObject);
  48     if (!SerializeSettingSection(itSection, varSection))
  49       continue;
  50
  51     if (listCategories)
  52     {
  53       varSection["categories"] = CVariant(CVariant::VariantTypeArray);
  54       for (const auto& itCategory : categories)
  55       {
  56         CVariant varCategory(CVariant::VariantTypeObject);
  57         if (!SerializeSettingCategory(itCategory, varCategory))
  58           continue;
  59
  60         varSection["categories"].push_back(varCategory);
  61       }
  62     }
  63
  64     result["sections"].push_back(varSection);
  65   }
  66
  67   return OK;
  68 }
  69
  70 JSONRPC_STATUS CSettingsOperations::GetCategories(const std::string &method, ITransportLayer *transport, IClient *client, const CVariant &parameterObject, CVariant &result)
  71 {
  72   SettingLevel level = ParseSettingLevel(parameterObject["level"].asString());
  73   std::string strSection = parameterObject["section"].asString();
  74   bool listSettings = !parameterObject["properties"].empty() && parameterObject["properties"][0].asString() == "settings";
  75
  76   std::vector<SettingSectionPtr> sections;
  77   if (!strSection.empty())
  78   {
  79     SettingSectionPtr section = CServiceBroker::GetSettingsComponent()->GetSettings()->GetSection(strSection);
  80     if (section == NULL)
  81       return InvalidParams;
  82
  83     sections.push_back(section);
  84   }
  85   else
  86     sections = CServiceBroker::GetSettingsComponent()->GetSettings()->GetSections();
  87
  88   result["categories"] = CVariant(CVariant::VariantTypeArray);
  89
  90   for (const auto& itSection : sections)
  91   {
  92     SettingCategoryList categories = itSection->GetCategories(level);
  93     for (const auto& itCategory : categories)
  94     {
  95       CVariant varCategory(CVariant::VariantTypeObject);
  96       if (!SerializeSettingCategory(itCategory, varCategory))
  97         continue;
  98
  99       if (listSettings)
 100       {
 101         varCategory["groups"] = CVariant(CVariant::VariantTypeArray);
 102
 103         SettingGroupList groups = itCategory->GetGroups(level);
 104         for (const auto& itGroup : groups)
 105         {
 106           CVariant varGroup(CVariant::VariantTypeObject);
 107           if (!SerializeSettingGroup(itGroup, varGroup))
 108             continue;
 109
 110           varGroup["settings"] = CVariant(CVariant::VariantTypeArray);
 111           SettingList settings = itGroup->GetSettings(level);
 112           for (const auto& itSetting : settings)
 113           {
 114             if (itSetting->IsVisible())
 115             {
 116               CVariant varSetting(CVariant::VariantTypeObject);
 117               if (!SerializeSetting(itSetting, varSetting))
 118                 continue;
 119
 120               varGroup["settings"].push_back(varSetting);
 121             }
 122           }
 123
 124           varCategory["groups"].push_back(varGroup);
 125         }
 126       }
 127
 128       result["categories"].push_back(varCategory);
 129     }
 130   }
 131
 132   return OK;
 133 }
 134
 135 JSONRPC_STATUS CSettingsOperations::GetSettings(const std::string &method, ITransportLayer *transport, IClient *client, const CVariant &parameterObject, CVariant &result)
 136 {
 137   SettingLevel level = ParseSettingLevel(parameterObject["level"].asString());
 138   const CVariant &filter = parameterObject["filter"];
 139   bool doFilter = filter.isMember("section") && filter.isMember("category");
 140   std::string strSection, strCategory;
 141   if (doFilter)
 142   {
 143     strSection = filter["section"].asString();
 144     strCategory = filter["category"].asString();
 145   }
 146
 147   std::vector<SettingSectionPtr> sections;
 148
 149   if (doFilter)
 150   {
 151     SettingSectionPtr section = CServiceBroker::GetSettingsComponent()->GetSettings()->GetSection(strSection);
 152     if (section == NULL)
 153       return InvalidParams;
 154
 155     sections.push_back(section);
 156   }
 157   else
 158     sections = CServiceBroker::GetSettingsComponent()->GetSettings()->GetSections();
 159
 160   result["settings"] = CVariant(CVariant::VariantTypeArray);
 161
 162   for (const auto& itSection : sections)
 163   {
 164     SettingCategoryList categories = itSection->GetCategories(level);
 165     bool found = !doFilter;
 166     for (const auto& itCategory : categories)
 167     {
 168       if (!doFilter || StringUtils::EqualsNoCase(itCategory->GetId(), strCategory))
 169       {
 170         SettingGroupList groups = itCategory->GetGroups(level);
 171         for (const auto& itGroup : groups)
 172         {
 173           SettingList settings = itGroup->GetSettings(level);
 174           for (const auto& itSetting : settings)
 175           {
 176             if (itSetting->IsVisible())
 177             {
 178               CVariant varSetting(CVariant::VariantTypeObject);
 179               if (!SerializeSetting(itSetting, varSetting))
 180                 continue;
 181
 182               result["settings"].push_back(varSetting);
 183             }
 184           }
 185         }
 186         found = true;
 187
 188         if (doFilter)
 189           break;
 190       }
 191     }
 192
 193     if (doFilter && !found)
 194       return InvalidParams;
 195   }
 196
 197   return OK;
 198 }
 199
 200 JSONRPC_STATUS CSettingsOperations::GetSettingValue(const std::string &method, ITransportLayer *transport, IClient *client, const CVariant &parameterObject, CVariant &result)
 201 {
 202   std::string settingId = parameterObject["setting"].asString();
 203
 204   SettingPtr setting = CServiceBroker::GetSettingsComponent()->GetSettings()->GetSetting(settingId);
 205   if (setting == NULL ||
 206       !setting->IsVisible())
 207     return InvalidParams;
 208
 209   CVariant value;
 210   switch (setting->GetType())
 211   {
 212   case SettingType::Boolean:
 213     value = std::static_pointer_cast<CSettingBool>(setting)->GetValue();
 214     break;
 215
 216   case SettingType::Integer:
 217     value = std::static_pointer_cast<CSettingInt>(setting)->GetValue();
 218     break;
 219
 220   case SettingType::Number:
 221     value = std::static_pointer_cast<CSettingNumber>(setting)->GetValue();
 222     break;
 223
 224   case SettingType::String:
 225     value = std::static_pointer_cast<CSettingString>(setting)->GetValue();
 226     break;
 227
 228   case SettingType::List:
 229   {
 230     SerializeSettingListValues(CServiceBroker::GetSettingsComponent()->GetSettings()->GetList(settingId), value);
 231     break;
 232   }
 233
 234   case SettingType::Unknown:
 235   case SettingType::Action:
 236   default:
 237     return InvalidParams;
 238   }
 239
 240   result["value"] = value;
 241
 242   return OK;
 243 }
 244
 245 JSONRPC_STATUS CSettingsOperations::SetSettingValue(const std::string &method, ITransportLayer *transport, IClient *client, const CVariant &parameterObject, CVariant &result)
 246 {
 247   std::string settingId = parameterObject["setting"].asString();
 248   CVariant value = parameterObject["value"];
 249
 250   SettingPtr setting = CServiceBroker::GetSettingsComponent()->GetSettings()->GetSetting(settingId);
 251   if (setting == NULL ||
 252       !setting->IsVisible())
 253     return InvalidParams;
 254
 255   switch (setting->GetType())
 256   {
 257   case SettingType::Boolean:
 258     if (!value.isBoolean())
 259       return InvalidParams;
 260
 261     result = std::static_pointer_cast<CSettingBool>(setting)->SetValue(value.asBoolean());
 262     break;
 263
 264   case SettingType::Integer:
 265     if (!value.isInteger() && !value.isUnsignedInteger())
 266       return InvalidParams;
 267
 268     result = std::static_pointer_cast<CSettingInt>(setting)->SetValue((int)value.asInteger());
 269     break;
 270
 271   case SettingType::Number:
 272     if (!value.isDouble())
 273       return InvalidParams;
 274
 275     result = std::static_pointer_cast<CSettingNumber>(setting)->SetValue(value.asDouble());
 276     break;
 277
 278   case SettingType::String:
 279     if (!value.isString())
 280       return InvalidParams;
 281
 282     result = std::static_pointer_cast<CSettingString>(setting)->SetValue(value.asString());
 283     break;
 284
 285   case SettingType::List:
 286   {
 287     if (!value.isArray())
 288       return InvalidParams;
 289
 290     std::vector<CVariant> values;
 291     for (CVariant::const_iterator_array itValue = value.begin_array(); itValue != value.end_array(); ++itValue)
 292       values.push_back(*itValue);
 293
 294     result = CServiceBroker::GetSettingsComponent()->GetSettings()->SetList(settingId, values);
 295     break;
 296   }
 297
 298   case SettingType::Unknown:
 299   case SettingType::Action:
 300   default:
 301     return InvalidParams;
 302   }
 303
 304   return OK;
 305 }
 306
 307 JSONRPC_STATUS CSettingsOperations::ResetSettingValue(const std::string &method, ITransportLayer *transport, IClient *client, const CVariant &parameterObject, CVariant &result)
 308 {
 309   std::string settingId = parameterObject["setting"].asString();
 310
 311   SettingPtr setting = CServiceBroker::GetSettingsComponent()->GetSettings()->GetSetting(settingId);
 312   if (setting == NULL ||
 313       !setting->IsVisible())
 314     return InvalidParams;
 315
 316   switch (setting->GetType())
 317   {
 318   case SettingType::Boolean:
 319   case SettingType::Integer:
 320   case SettingType::Number:
 321   case SettingType::String:
 322   case SettingType::List:
 323     setting->Reset();
 324     break;
 325
 326   case SettingType::Unknown:
 327   case SettingType::Action:
 328   default:
 329     return InvalidParams;
 330   }
 331
 332   return ACK;
 333 }
 334
 335 SettingLevel CSettingsOperations::ParseSettingLevel(const std::string &strLevel)
 336 {
 337   if (StringUtils::EqualsNoCase(strLevel, "basic"))
 338     return SettingLevel::Basic;
 339   if (StringUtils::EqualsNoCase(strLevel, "advanced"))
 340     return SettingLevel::Advanced;
 341   if (StringUtils::EqualsNoCase(strLevel, "expert"))
 342     return SettingLevel::Expert;
 343
 344   return SettingLevel::Standard;
 345 }
 346
 347 bool CSettingsOperations::SerializeISetting(const std::shared_ptr<const ISetting>& setting,
 348                                             CVariant& obj)
 349 {
 350   if (setting == NULL)
 351     return false;
 352
 353   obj["id"] = setting->GetId();
 354
 355   return true;
 356 }
 357
 358 bool CSettingsOperations::SerializeSettingSection(
 359     const std::shared_ptr<const CSettingSection>& setting, CVariant& obj)
 360 {
 361   if (!SerializeISetting(setting, obj))
 362     return false;
 363
 364   obj["label"] = g_localizeStrings.Get(setting->GetLabel());
 365   if (setting->GetHelp() >= 0)
 366     obj["help"] = g_localizeStrings.Get(setting->GetHelp());
 367
 368   return true;
 369 }
 370
 371 bool CSettingsOperations::SerializeSettingCategory(
 372     const std::shared_ptr<const CSettingCategory>& setting, CVariant& obj)
 373 {
 374   if (!SerializeISetting(setting, obj))
 375     return false;
 376
 377   obj["label"] = g_localizeStrings.Get(setting->GetLabel());
 378   if (setting->GetHelp() >= 0)
 379     obj["help"] = g_localizeStrings.Get(setting->GetHelp());
 380
 381   return true;
 382 }
 383
 384 bool CSettingsOperations::SerializeSettingGroup(const std::shared_ptr<const CSettingGroup>& setting,
 385                                                 CVariant& obj)
 386 {
 387   return SerializeISetting(setting, obj);
 388 }
 389
 390 bool CSettingsOperations::SerializeSetting(const std::shared_ptr<const CSetting>& setting,
 391                                            CVariant& obj)
 392 {
 393   if (!SerializeISetting(setting, obj))
 394     return false;
 395
 396   obj["label"] = g_localizeStrings.Get(setting->GetLabel());
 397   if (setting->GetHelp() >= 0)
 398     obj["help"] = g_localizeStrings.Get(setting->GetHelp());
 399
 400   switch (setting->GetLevel())
 401   {
 402     case SettingLevel::Basic:
 403       obj["level"] = "basic";
 404       break;
 405
 406     case SettingLevel::Standard:
 407       obj["level"] = "standard";
 408       break;
 409
 410     case SettingLevel::Advanced:
 411       obj["level"] = "advanced";
 412       break;
 413
 414     case SettingLevel::Expert:
 415       obj["level"] = "expert";
 416       break;
 417
 418     default:
 419       return false;
 420   }
 421
 422   obj["enabled"] = setting->IsEnabled();
 423   obj["parent"] = setting->GetParent();
 424
 425   obj["control"] = CVariant(CVariant::VariantTypeObject);
 426   if (!SerializeSettingControl(setting->GetControl(), obj["control"]))
 427     return false;
 428
 429   switch (setting->GetType())
 430   {
 431     case SettingType::Boolean:
 432       obj["type"] = "boolean";
 433       if (!SerializeSettingBool(std::static_pointer_cast<const CSettingBool>(setting), obj))
 434         return false;
 435       break;
 436
 437     case SettingType::Integer:
 438       obj["type"] = "integer";
 439       if (!SerializeSettingInt(std::static_pointer_cast<const CSettingInt>(setting), obj))
 440         return false;
 441       break;
 442
 443     case SettingType::Number:
 444       obj["type"] = "number";
 445       if (!SerializeSettingNumber(std::static_pointer_cast<const CSettingNumber>(setting), obj))
 446         return false;
 447       break;
 448
 449     case SettingType::String:
 450       obj["type"] = "string";
 451       if (!SerializeSettingString(std::static_pointer_cast<const CSettingString>(setting), obj))
 452         return false;
 453       break;
 454
 455     case SettingType::Action:
 456       obj["type"] = "action";
 457       if (!SerializeSettingAction(std::static_pointer_cast<const CSettingAction>(setting), obj))
 458         return false;
 459       break;
 460
 461     case SettingType::List:
 462       obj["type"] = "list";
 463       if (!SerializeSettingList(std::static_pointer_cast<const CSettingList>(setting), obj))
 464         return false;
 465       break;
 466
 467     default:
 468       return false;
 469   }
 470
 471   return true;
 472 }
 473
 474 bool CSettingsOperations::SerializeSettingBool(const std::shared_ptr<const CSettingBool>& setting,
 475                                                CVariant& obj)
 476 {
 477   if (setting == NULL)
 478     return false;
 479
 480   obj["value"] = setting->GetValue();
 481   obj["default"] = setting->GetDefault();
 482
 483   return true;
 484 }
 485
 486 bool CSettingsOperations::SerializeSettingInt(const std::shared_ptr<const CSettingInt>& setting,
 487                                               CVariant& obj)
 488 {
 489   if (setting == NULL)
 490     return false;
 491
 492   obj["default"] = setting->GetDefault();
 493
 494   switch (setting->GetOptionsType())
 495   {
 496     case SettingOptionsType::StaticTranslatable:
 497     {
 498       obj["options"] = CVariant(CVariant::VariantTypeArray);
 499       const TranslatableIntegerSettingOptions& options = setting->GetTranslatableOptions();
 500       for (const auto& itOption : options)
 501       {
 502         CVariant varOption(CVariant::VariantTypeObject);
 503         varOption["label"] = g_localizeStrings.Get(itOption.label);
 504         varOption["value"] = itOption.value;
 505         obj["options"].push_back(varOption);
 506       }
 507       break;
 508     }
 509
 510     case SettingOptionsType::Static:
 511     {
 512       obj["options"] = CVariant(CVariant::VariantTypeArray);
 513       const IntegerSettingOptions& options = setting->GetOptions();
 514       for (const auto& itOption : options)
 515       {
 516         CVariant varOption(CVariant::VariantTypeObject);
 517         varOption["label"] = itOption.label;
 518         varOption["value"] = itOption.value;
 519         obj["options"].push_back(varOption);
 520       }
 521       break;
 522     }
 523
 524     case SettingOptionsType::Dynamic:
 525     {
 526       obj["options"] = CVariant(CVariant::VariantTypeArray);
 527       IntegerSettingOptions options = std::const_pointer_cast<CSettingInt>(setting)->UpdateDynamicOptions();
 528       for (const auto& itOption : options)
 529       {
 530         CVariant varOption(CVariant::VariantTypeObject);
 531         varOption["label"] = itOption.label;
 532         varOption["value"] = itOption.value;
 533         obj["options"].push_back(varOption);
 534       }
 535       break;
 536     }
 537
 538     case SettingOptionsType::Unknown:
 539     default:
 540       obj["minimum"] = setting->GetMinimum();
 541       obj["step"] = setting->GetStep();
 542       obj["maximum"] = setting->GetMaximum();
 543       break;
 544   }
 545
 546   // this must be done after potentially calling CSettingInt::UpdateDynamicOptions() because it can
 547   // change the value of the setting
 548   obj["value"] = setting->GetValue();
 549
 550   return true;
 551 }
 552
 553 bool CSettingsOperations::SerializeSettingNumber(
 554     const std::shared_ptr<const CSettingNumber>& setting, CVariant& obj)
 555 {
 556   if (setting == NULL)
 557     return false;
 558
 559   obj["value"] = setting->GetValue();
 560   obj["default"] = setting->GetDefault();
 561
 562   obj["minimum"] = setting->GetMinimum();
 563   obj["step"] = setting->GetStep();
 564   obj["maximum"] = setting->GetMaximum();
 565
 566   return true;
 567 }
 568
 569 bool CSettingsOperations::SerializeSettingString(
 570     const std::shared_ptr<const CSettingString>& setting, CVariant& obj)
 571 {
 572   if (setting == NULL)
 573     return false;
 574
 575   obj["default"] = setting->GetDefault();
 576
 577   obj["allowempty"] = setting->AllowEmpty();
 578   obj["allownewoption"] = setting->AllowNewOption();
 579
 580   switch (setting->GetOptionsType())
 581   {
 582     case SettingOptionsType::StaticTranslatable:
 583     {
 584       obj["options"] = CVariant(CVariant::VariantTypeArray);
 585       const TranslatableStringSettingOptions& options = setting->GetTranslatableOptions();
 586       for (const auto& itOption : options)
 587       {
 588         CVariant varOption(CVariant::VariantTypeObject);
 589         varOption["label"] = g_localizeStrings.Get(itOption.first);
 590         varOption["value"] = itOption.second;
 591         obj["options"].push_back(varOption);
 592       }
 593       break;
 594     }
 595
 596     case SettingOptionsType::Static:
 597     {
 598       obj["options"] = CVariant(CVariant::VariantTypeArray);
 599       const StringSettingOptions& options = setting->GetOptions();
 600       for (const auto& itOption : options)
 601       {
 602         CVariant varOption(CVariant::VariantTypeObject);
 603         varOption["label"] = itOption.label;
 604         varOption["value"] = itOption.value;
 605         obj["options"].push_back(varOption);
 606       }
 607       break;
 608     }
 609
 610     case SettingOptionsType::Dynamic:
 611     {
 612       obj["options"] = CVariant(CVariant::VariantTypeArray);
 613       StringSettingOptions options = std::const_pointer_cast<CSettingString>(setting)->UpdateDynamicOptions();
 614       for (const auto& itOption : options)
 615       {
 616         CVariant varOption(CVariant::VariantTypeObject);
 617         varOption["label"] = itOption.label;
 618         varOption["value"] = itOption.value;
 619         obj["options"].push_back(varOption);
 620       }
 621       break;
 622     }
 623
 624     case SettingOptionsType::Unknown:
 625     default:
 626       break;
 627   }
 628
 629   // this must be done after potentially calling CSettingString::UpdateDynamicOptions() because it
 630   // can change the value of the setting
 631   obj["value"] = setting->GetValue();
 632
 633   std::shared_ptr<const ISettingControl> control = setting->GetControl();
 634   if (control->GetFormat() == "path")
 635   {
 636     if (!SerializeSettingPath(std::static_pointer_cast<const CSettingPath>(setting), obj))
 637       return false;
 638   }
 639   if (control->GetFormat() == "addon")
 640   {
 641     if (!SerializeSettingAddon(std::static_pointer_cast<const CSettingAddon>(setting), obj))
 642       return false;
 643   }
 644   if (control->GetFormat() == "date")
 645   {
 646     if (!SerializeSettingDate(std::static_pointer_cast<const CSettingDate>(setting), obj))
 647       return false;
 648   }
 649   if (control->GetFormat() == "time")
 650   {
 651     if (!SerializeSettingTime(std::static_pointer_cast<const CSettingTime>(setting), obj))
 652       return false;
 653   }
 654
 655   return true;
 656 }
 657
 658 bool CSettingsOperations::SerializeSettingAction(
 659     const std::shared_ptr<const CSettingAction>& setting, CVariant& obj)
 660 {
 661   if (setting == NULL)
 662     return false;
 663
 664   obj["data"] = setting->GetData();
 665
 666   return true;
 667 }
 668
 669 bool CSettingsOperations::SerializeSettingList(const std::shared_ptr<const CSettingList>& setting,
 670                                                CVariant& obj)
 671 {
 672   if (setting == NULL ||
 673       !SerializeSetting(setting->GetDefinition(), obj["definition"]))
 674     return false;
 675
 676   SerializeSettingListValues(CSettingUtils::GetList(setting), obj["value"]);
 677   SerializeSettingListValues(CSettingUtils::ListToValues(setting, setting->GetDefault()), obj["default"]);
 678
 679   obj["elementtype"] = obj["definition"]["type"];
 680   obj["delimiter"] = setting->GetDelimiter();
 681   obj["minimumItems"] = setting->GetMinimumItems();
 682   obj["maximumItems"] = setting->GetMaximumItems();
 683
 684   return true;
 685 }
 686
 687 bool CSettingsOperations::SerializeSettingPath(const std::shared_ptr<const CSettingPath>& setting,
 688                                                CVariant& obj)
 689 {
 690   if (setting == NULL)
 691     return false;
 692
 693   obj["type"] = "path";
 694   obj["writable"] = setting->Writable();
 695   obj["sources"] = setting->GetSources();
 696
 697   return true;
 698 }
 699
 700 bool CSettingsOperations::SerializeSettingAddon(const std::shared_ptr<const CSettingAddon>& setting,
 701                                                 CVariant& obj)
 702 {
 703   if (setting == NULL)
 704     return false;
 705
 706   obj["type"] = "addon";
 707   obj["addontype"] = ADDON::CAddonInfo::TranslateType(setting->GetAddonType());
 708
 709   return true;
 710 }
 711
 712 bool CSettingsOperations::SerializeSettingDate(const std::shared_ptr<const CSettingDate>& setting,
 713                                                CVariant& obj)
 714 {
 715   if (setting == NULL)
 716     return false;
 717
 718   obj["type"] = "date";
 719
 720   return true;
 721 }
 722
 723 bool CSettingsOperations::SerializeSettingTime(const std::shared_ptr<const CSettingTime>& setting,
 724                                                CVariant& obj)
 725 {
 726   if (setting == NULL)
 727     return false;
 728
 729   obj["type"] = "time";
 730
 731   return true;
 732 }
 733
 734 bool CSettingsOperations::SerializeSettingControl(
 735     const std::shared_ptr<const ISettingControl>& control, CVariant& obj)
 736 {
 737   if (control == NULL)
 738     return false;
 739
 740   const std::string& type = control->GetType();
 741   obj["type"] = type;
 742   obj["format"] = control->GetFormat();
 743   obj["delayed"] = control->GetDelayed();
 744
 745   if (type == "spinner")
 746   {
 747     std::shared_ptr<const CSettingControlSpinner> spinner = std::static_pointer_cast<const CSettingControlSpinner>(control);
 748     if (spinner->GetFormatLabel() >= 0)
 749       obj["formatlabel"] = g_localizeStrings.Get(spinner->GetFormatLabel());
 750     else if (!spinner->GetFormatString().empty() && spinner->GetFormatString() != "{:d}")
 751       obj["formatlabel"] = spinner->GetFormatString();
 752     if (spinner->GetMinimumLabel() >= 0)
 753       obj["minimumlabel"] = g_localizeStrings.Get(spinner->GetMinimumLabel());
 754   }
 755   else if (type == "edit")
 756   {
 757     std::shared_ptr<const CSettingControlEdit> edit = std::static_pointer_cast<const CSettingControlEdit>(control);
 758     obj["hidden"] = edit->IsHidden();
 759     obj["verifynewvalue"] = edit->VerifyNewValue();
 760     if (edit->GetHeading() >= 0)
 761       obj["heading"] = g_localizeStrings.Get(edit->GetHeading());
 762   }
 763   else if (type == "button")
 764   {
 765     std::shared_ptr<const CSettingControlButton> button = std::static_pointer_cast<const CSettingControlButton>(control);
 766     if (button->GetHeading() >= 0)
 767       obj["heading"] = g_localizeStrings.Get(button->GetHeading());
 768   }
 769   else if (type == "list")
 770   {
 771     std::shared_ptr<const CSettingControlList> list = std::static_pointer_cast<const CSettingControlList>(control);
 772     if (list->GetHeading() >= 0)
 773       obj["heading"] = g_localizeStrings.Get(list->GetHeading());
 774     obj["multiselect"] = list->CanMultiSelect();
 775   }
 776   else if (type == "slider")
 777   {
 778     std::shared_ptr<const CSettingControlSlider> slider = std::static_pointer_cast<const CSettingControlSlider>(control);
 779     if (slider->GetHeading() >= 0)
 780       obj["heading"] = g_localizeStrings.Get(slider->GetHeading());
 781     obj["popup"] = slider->UsePopup();
 782     if (slider->GetFormatLabel() >= 0)
 783       obj["formatlabel"] = g_localizeStrings.Get(slider->GetFormatLabel());
 784     else
 785       obj["formatlabel"] = slider->GetFormatString();
 786   }
 787   else if (type == "range")
 788   {
 789     std::shared_ptr<const CSettingControlRange> range = std::static_pointer_cast<const CSettingControlRange>(control);
 790     if (range->GetFormatLabel() >= 0)
 791       obj["formatlabel"] = g_localizeStrings.Get(range->GetFormatLabel());
 792     else
 793       obj["formatlabel"] = "";
 794     if (range->GetValueFormatLabel() >= 0)
 795       obj["formatvalue"] = g_localizeStrings.Get(range->GetValueFormatLabel());
 796     else
 797       obj["formatvalue"] = range->GetValueFormat();
 798   }
 799   else if (type != "toggle" && type != "label")
 800     return false;
 801
 802   return true;
 803 }
 804
 805 void CSettingsOperations::SerializeSettingListValues(const std::vector<CVariant> &values, CVariant &obj)
 806 {
 807   obj = CVariant(CVariant::VariantTypeArray);
 808   for (const auto& itValue : values)
 809     obj.push_back(itValue);
 810 }
 811
 812 JSONRPC_STATUS CSettingsOperations::GetSkinSettings(const std::string& method,
 813                                                     ITransportLayer* transport,
 814                                                     IClient* client,
 815                                                     const CVariant& parameterObject,
 816                                                     CVariant& result)
 817 {
 818   const std::set<ADDON::CSkinSettingPtr> settings = CSkinSettings::GetInstance().GetSettings();
 819   CVariant varSettings(CVariant::VariantTypeArray);
 820
 821   for (const auto& setting : settings)
 822   {
 823     CVariant varSetting(CVariant::VariantTypeObject);
 824     varSetting["id"] = setting->name;
 825
 826     if (setting->GetType() == "bool")
 827     {
 828       varSetting["value"] = std::static_pointer_cast<ADDON::CSkinSettingBool>(setting)->value;
 829       varSetting["type"] = "boolean";
 830     }
 831     else if (setting->GetType() == "string")
 832     {
 833       varSetting["value"] = std::static_pointer_cast<ADDON::CSkinSettingString>(setting)->value;
 834       varSetting["type"] = setting->GetType();
 835     }
 836     else
 837       continue;
 838
 839     varSettings.push_back(varSetting);
 840   }
 841
 842   result["skin"] = CServiceBroker::GetSettingsComponent()->GetSettings()->GetString(
 843       CSettings::SETTING_LOOKANDFEEL_SKIN);
 844   result["settings"] = varSettings;
 845   return OK;
 846 }
 847
 848 JSONRPC_STATUS CSettingsOperations::GetSkinSettingValue(const std::string& method,
 849                                                         ITransportLayer* transport,
 850                                                         IClient* client,
 851                                                         const CVariant& parameterObject,
 852                                                         CVariant& result)
 853 {
 854   const std::string settingId = parameterObject["setting"].asString();
 855   ADDON::CSkinSettingPtr setting = CSkinSettings::GetInstance().GetSetting(settingId);
 856
 857   if (setting == nullptr)
 858     return InvalidParams;
 859
 860   CVariant value;
 861   if (setting->GetType() == "string")
 862     value = std::static_pointer_cast<ADDON::CSkinSettingString>(setting)->value;
 863   else if (setting->GetType() == "bool")
 864     value = std::static_pointer_cast<ADDON::CSkinSettingBool>(setting)->value;
 865   else
 866     return InvalidParams;
 867
 868   result["value"] = value;
 869   return OK;
 870 }
 871
 872 JSONRPC_STATUS CSettingsOperations::SetSkinSettingValue(const std::string& method,
 873                                                         ITransportLayer* transport,
 874                                                         IClient* client,
 875                                                         const CVariant& parameterObject,
 876                                                         CVariant& result)
 877 {
 878   const std::string settingId = parameterObject["setting"].asString();
 879   ADDON::CSkinSettingPtr setting = CSkinSettings::GetInstance().GetSetting(settingId);
 880
 881   if (setting == nullptr)
 882     return InvalidParams;
 883
 884   CVariant value = parameterObject["value"];
 885   if (setting->GetType() == "string")
 886   {
 887     if (!value.isString())
 888       return InvalidParams;
 889
 890     result = std::static_pointer_cast<ADDON::CSkinSettingString>(setting)->value = value.asString();
 891   }
 892   else if (setting->GetType() == "bool")
 893   {
 894     if (!value.isBoolean())
 895       return InvalidParams;
 896
 897     result = std::static_pointer_cast<ADDON::CSkinSettingBool>(setting)->value = value.asBoolean();
 898   }
 899   else
 900   {
 901     return InvalidParams;
 902   }
 903
 904   return OK;
 905 }