rbutil/rbutilqt/base/rbsettings.cpp

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  *
   9  *   Copyright (C) 2007 by Dominik Wenger
  10  *   $Id$
  11  *
  12  * All files in this archive are subject to the GNU General Public License.
  13  * See the file COPYING in the source tree root for full license agreement.
  14  *
  15  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  16  * KIND, either express or implied.
  17  *
  18  ****************************************************************************/
  19
  20 #include "rbsettings.h"
  21
  22 #include <QSettings>
  23
  24 #if defined(Q_OS_LINUX)
  25 #include <unistd.h>
  26 #endif
  27
  28
  29 // device settings
  30 const static struct {
  31     RbSettings::SystemSettings setting;
  32     const char* name;
  33     const char* def;
  34 } SystemSettingsList[] = {
  35     { RbSettings::ManualUrl,            "manual_url",           "" },
  36     { RbSettings::BleedingUrl,          "bleeding_url",         "" },
  37     { RbSettings::BootloaderUrl,        "bootloader_url",       "" },
  38     { RbSettings::BootloaderInfoUrl,    "bootloader_info_url",  "" },
  39     { RbSettings::FontUrl,              "font_url",             "" },
  40     { RbSettings::VoiceUrl,             "voice_url",            "" },
  41     { RbSettings::DoomUrl,              "doom_url",             "" },
  42     { RbSettings::ReleaseUrl,           "release_url",          "" },
  43     { RbSettings::DailyUrl,             "daily_url",            "" },
  44     { RbSettings::ServerConfUrl,        "server_conf_url",      "" },
  45     { RbSettings::GenlangUrl,           "genlang_url",          "" },
  46     { RbSettings::ThemesUrl,            "themes_url",           "" },
  47     { RbSettings::BleedingInfo,         "bleeding_info",        "" },
  48     { RbSettings::CurPlatformName,      ":platform:/name",      "" },
  49     { RbSettings::CurManual,            ":platform:/manualname","rockbox-:platform:" },
  50     { RbSettings::CurBootloaderMethod,  ":platform:/bootloadermethod", "none" },
  51     { RbSettings::CurBootloaderName,    ":platform:/bootloadername", "" },
  52     { RbSettings::CurBootloaderFile,    ":platform:/bootloaderfile", "" },
  53     { RbSettings::CurEncoder,           ":platform:/encoder",   "" },
  54     { RbSettings::CurBrand,             ":platform:/brand",     "" },
  55     { RbSettings::CurName,              ":platform:/name",      "" },
  56     { RbSettings::CurBuildserverModel,  ":platform:/buildserver_modelname", "" },
  57     { RbSettings::CurConfigureModel,    ":platform:/configure_modelname", "" },
  58 };
  59
  60 // user settings
  61 const static struct {
  62     RbSettings::UserSettings setting;
  63     const char* name;
  64     const char* def;
  65 } UserSettingsList[] = {
  66     { RbSettings::RbutilVersion,        "rbutil_version",       "" },
  67     { RbSettings::CurrentPlatform,      "platform",             "" },
  68     { RbSettings::Mountpoint,           "mountpoint",           "" },
  69     { RbSettings::CachePath,            "cachepath",            "" },
  70     { RbSettings::Build,                "build",                "" },
  71     { RbSettings::ProxyType,            "proxytype",            "" },
  72     { RbSettings::Proxy,                "proxy",                "" },
  73     { RbSettings::OfPath,               "ofpath",               "" },
  74     { RbSettings::Platform,             "platform",             "" },
  75     { RbSettings::Language,             "lang",                 "" },
  76     { RbSettings::Tts,                  "tts",                  "" },
  77     { RbSettings::LastTalkedFolder,     "last_talked_folder",   "" },
  78     { RbSettings::VoiceLanguage,        "voicelanguage",        "" },
  79     { RbSettings::TtsLanguage,          ":tts:/language",       "" },
  80     { RbSettings::TtsOptions,           ":tts:/options",        "" },
  81     { RbSettings::TtsPath,              ":tts:/path",           "" },
  82     { RbSettings::TtsVoice,             ":tts:/voice",          "" },
  83     { RbSettings::EncoderPath,          ":encoder:/encoderpath",        "" },
  84     { RbSettings::EncoderOptions,       ":encoder:/encoderoptions",     "" },
  85     { RbSettings::CacheOffline,         "offline",              "false" },
  86     { RbSettings::CacheDisabled,        "cachedisable",         "false" },
  87     { RbSettings::TtsUseSapi4,          "sapi/useSapi4",        "false" },
  88     { RbSettings::EncoderNarrowBand,    ":encoder:/narrowband", "false" },
  89     { RbSettings::WavtrimThreshold,     "wavtrimthreshold",     "500"},
  90     { RbSettings::TtsSpeed,             ":tts:/speed",          "0" },
  91     { RbSettings::EncoderComplexity,    ":encoder:/complexity", "10" },
  92     { RbSettings::EncoderQuality,       ":encoder:/quality",    "8.0" },
  93     { RbSettings::EncoderVolume,        ":encoder:/volume",     "1.0" },
  94 };
  95
  96 //! pointer to setting object to NULL
  97 QSettings* RbSettings::systemSettings = NULL;
  98 QSettings* RbSettings::userSettings = NULL;
  99
 100 void RbSettings::ensureRbSettingsExists()
 101 {
 102     //check and create settings object
 103     if(systemSettings == NULL)
 104     {
 105         // only use built-in rbutil.ini
 106         systemSettings = new QSettings(":/ini/rbutil.ini", QSettings::IniFormat, 0);
 107     }
 108
 109     if(userSettings == NULL)
 110     {
 111         // portable installation:
 112         // check for a configuration file in the program folder.
 113         QFileInfo config;
 114         config.setFile(QCoreApplication::instance()->applicationDirPath()
 115             + "/RockboxUtility.ini");
 116         if(config.isFile())
 117         {
 118             userSettings = new QSettings(QCoreApplication::instance()->applicationDirPath()
 119                 + "/RockboxUtility.ini", QSettings::IniFormat, NULL);
 120             qDebug() << "[Settings] configuration: portable";
 121         }
 122         else
 123         {
 124             userSettings = new QSettings(QSettings::IniFormat,
 125             QSettings::UserScope, "rockbox.org", "RockboxUtility",NULL);
 126             qDebug() << "[Settings] configuration: system";
 127         }
 128     }
 129 }
 130
 131 void RbSettings::sync()
 132 {
 133     ensureRbSettingsExists();
 134
 135     userSettings->sync();
 136 #if defined(Q_OS_LINUX)
 137     // when using sudo it runs rbutil with uid 0 but unfortunately without a
 138     // proper login shell, thus the configuration file gets placed in the
 139     // calling users $HOME. This in turn will cause issues if trying to
 140     // run rbutil later as user. Try to detect this case via the environment
 141     // variable SUDO_UID and SUDO_GID and if set chown the user config file.
 142     if(getuid() == 0)
 143     {
 144         char* realuser = getenv("SUDO_UID");
 145         char* realgroup = getenv("SUDO_GID");
 146         if(realuser != NULL && realgroup != NULL)
 147         {
 148             int realuid = atoi(realuser);
 149             int realgid = atoi(realgroup);
 150             // chown is attribute warn_unused_result, but in case this fails
 151             // we can't do anything useful about it. Notifying the user
 152             // is somewhat pointless. Add hack to suppress compiler warning.
 153             if(chown(qPrintable(userSettings->fileName()), realuid, realgid));
 154         }
 155     }
 156 #endif
 157 }
 158
 159 QString RbSettings::userSettingFilename()
 160 {
 161     ensureRbSettingsExists();
 162     return userSettings->fileName();
 163 }
 164
 165 QVariant RbSettings::value(enum SystemSettings setting)
 166 {
 167     ensureRbSettingsExists();
 168
 169     // locate setting item
 170     int i = 0;
 171     while(SystemSettingsList[i].setting != setting)
 172         i++;
 173
 174     QString s = constructSettingPath(SystemSettingsList[i].name);
 175     QString d = SystemSettingsList[i].def;
 176     d.replace(":platform:", userSettings->value("platform").toString());
 177     qDebug() << "[Settings] GET S:" << s << systemSettings->value(s, d).toString();
 178     return systemSettings->value(s, d);
 179 }
 180
 181 QVariant RbSettings::value(enum UserSettings setting)
 182 {
 183     QString empty;
 184     return subValue(empty, setting);
 185 }
 186
 187 QVariant RbSettings::subValue(QString sub, enum UserSettings setting)
 188 {
 189     ensureRbSettingsExists();
 190
 191     // locate setting item
 192     int i = 0;
 193     while(UserSettingsList[i].setting != setting)
 194         i++;
 195
 196     QString s = constructSettingPath(UserSettingsList[i].name, sub);
 197     qDebug() << "[Settings] GET U:" << s << userSettings->value(s).toString();
 198     return userSettings->value(s, UserSettingsList[i].def);
 199 }
 200
 201 void RbSettings::setValue(enum UserSettings setting , QVariant value)
 202 {
 203    QString empty;
 204    return setSubValue(empty, setting, value);
 205 }
 206
 207 void RbSettings::setSubValue(QString sub, enum UserSettings setting, QVariant value)
 208 {
 209     ensureRbSettingsExists();
 210
 211     // locate setting item
 212     int i = 0;
 213     while(UserSettingsList[i].setting != setting)
 214         i++;
 215
 216     QString s = constructSettingPath(UserSettingsList[i].name, sub);
 217     qDebug() << "[Settings] SET U:" << s << userSettings->value(s).toString();
 218     userSettings->setValue(s, value);
 219 }
 220
 221
 222 QVariant RbSettings::platformValue(QString platform, enum SystemSettings setting)
 223 {
 224     ensureRbSettingsExists();
 225
 226     // locate setting item
 227     int i = 0;
 228     while(SystemSettingsList[i].setting != setting)
 229         i++;
 230
 231     QString s = SystemSettingsList[i].name;
 232     s.replace(":platform:", platform);
 233     QString d = SystemSettingsList[i].def;
 234     d.replace(":platform:", platform);
 235     qDebug() << "[Settings] GET P:" << s << systemSettings->value(s, d).toString();
 236     return systemSettings->value(s, d);
 237 }
 238
 239
 240 QStringList RbSettings::platforms()
 241 {
 242     ensureRbSettingsExists();
 243
 244     QStringList result;
 245     systemSettings->beginGroup("platforms");
 246     QStringList a = systemSettings->childKeys();
 247     for(int i = 0; i < a.size(); i++)
 248     {
 249         result.append(systemSettings->value(a.at(i), "null").toString());
 250     }
 251     systemSettings->endGroup();
 252     return result;
 253 }
 254
 255 QStringList RbSettings::languages()
 256 {
 257     ensureRbSettingsExists();
 258
 259     QStringList result;
 260     systemSettings->beginGroup("languages");
 261     QStringList a = systemSettings->childKeys();
 262     for(int i = 0; i < a.size(); i++)
 263     {
 264         result.append(systemSettings->value(a.at(i), "null").toString());
 265     }
 266     systemSettings->endGroup();
 267     return result;
 268 }
 269
 270
 271 QString RbSettings::name(QString platform)
 272 {
 273     ensureRbSettingsExists();
 274     return systemSettings->value(platform + "/name").toString();
 275 }
 276
 277 QString RbSettings::brand(QString platform)
 278 {
 279     ensureRbSettingsExists();
 280     return systemSettings->value(platform + "/brand").toString();
 281 }
 282
 283 QMap<int, QString> RbSettings::usbIdMap(enum MapType type)
 284 {
 285     ensureRbSettingsExists();
 286
 287     QMap<int, QString> map;
 288     // get a list of ID -> target name
 289     QStringList platforms;
 290     systemSettings->beginGroup("platforms");
 291     platforms = systemSettings->childKeys();
 292     systemSettings->endGroup();
 293
 294     QString t;
 295     switch(type) {
 296         case MapDevice:
 297             t = "usbid";
 298             break;
 299         case MapError:
 300             t = "usberror";
 301             break;
 302         case MapIncompatible:
 303             t = "usbincompat";
 304             break;
 305     }
 306
 307     for(int i = 0; i < platforms.size(); i++)
 308     {
 309         systemSettings->beginGroup("platforms");
 310         QString target = systemSettings->value(platforms.at(i)).toString();
 311         systemSettings->endGroup();
 312         systemSettings->beginGroup(target);
 313         QStringList ids = systemSettings->value(t).toStringList();
 314         int j = ids.size();
 315         while(j--)
 316             map.insert(ids.at(j).toInt(0, 16), target);
 317
 318         systemSettings->endGroup();
 319     }
 320     return map;
 321 }
 322
 323
 324 QString RbSettings::constructSettingPath(QString path, QString substitute)
 325 {
 326     QString platform = userSettings->value("platform").toString();
 327     if(!substitute.isEmpty()) {
 328         path.replace(":tts:", substitute);
 329         path.replace(":encoder:", substitute);
 330     }
 331     else {
 332         path.replace(":tts:", userSettings->value("tts").toString());
 333         path.replace(":encoder:", systemSettings->value(platform + "/encoder").toString());
 334     }
 335     path.replace(":platform:", platform);
 336
 337     return path;
 338 }
 339