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::CurResolution,        ":platform:/resolution", "" },
  55     { RbSettings::CurBrand,             ":platform:/brand",     "" },
  56     { RbSettings::CurName,              ":platform:/name",      "" },
  57     { RbSettings::CurBuildserverModel,  ":platform:/buildserver_modelname", "" },
  58     { RbSettings::CurConfigureModel,    ":platform:/configure_modelname", "" },
  59     { RbSettings::CurTargetId,          ":platform:/targetid",  "" },
  60 };
  61
  62 // user settings
  63 const static struct {
  64     RbSettings::UserSettings setting;
  65     const char* name;
  66     const char* def;
  67 } UserSettingsList[] = {
  68     { RbSettings::RbutilVersion,        "rbutil_version",       "" },
  69     { RbSettings::CurrentPlatform,      "platform",             "" },
  70     { RbSettings::Mountpoint,           "mountpoint",           "" },
  71     { RbSettings::CachePath,            "cachepath",            "" },
  72     { RbSettings::Build,                "build",                "" },
  73     { RbSettings::ProxyType,            "proxytype",            "" },
  74     { RbSettings::Proxy,                "proxy",                "" },
  75     { RbSettings::OfPath,               "ofpath",               "" },
  76     { RbSettings::Platform,             "platform",             "" },
  77     { RbSettings::Language,             "lang",                 "" },
  78     { RbSettings::Tts,                  "tts",                  "" },
  79     { RbSettings::LastTalkedFolder,     "last_talked_folder",   "" },
  80     { RbSettings::VoiceLanguage,        "voicelanguage",        "" },
  81     { RbSettings::TtsLanguage,          ":tts:/language",       "" },
  82     { RbSettings::TtsOptions,           ":tts:/options",        "" },
  83     { RbSettings::TtsPath,              ":tts:/path",           "" },
  84     { RbSettings::TtsVoice,             ":tts:/voice",          "" },
  85     { RbSettings::EncoderPath,          ":encoder:/encoderpath",        "" },
  86     { RbSettings::EncoderOptions,       ":encoder:/encoderoptions",     "" },
  87     { RbSettings::CacheOffline,         "offline",              "false" },
  88     { RbSettings::CacheDisabled,        "cachedisable",         "false" },
  89     { RbSettings::TtsUseSapi4,          "sapi/useSapi4",        "false" },
  90     { RbSettings::EncoderNarrowBand,    ":encoder:/narrowband", "false" },
  91     { RbSettings::WavtrimThreshold,     "wavtrimthreshold",     "500"},
  92     { RbSettings::TtsSpeed,             ":tts:/speed",          "0" },
  93     { RbSettings::EncoderComplexity,    ":encoder:/complexity", "10" },
  94     { RbSettings::EncoderQuality,       ":encoder:/quality",    "8.0" },
  95     { RbSettings::EncoderVolume,        ":encoder:/volume",     "1.0" },
  96 };
  97
  98 //! pointer to setting object to NULL
  99 QSettings* RbSettings::systemSettings = NULL;
 100 QSettings* RbSettings::userSettings = NULL;
 101
 102 void RbSettings::ensureRbSettingsExists()
 103 {
 104     //check and create settings object
 105     if(systemSettings == NULL)
 106     {
 107         // only use built-in rbutil.ini
 108         systemSettings = new QSettings(":/ini/rbutil.ini", QSettings::IniFormat, 0);
 109     }
 110
 111     if(userSettings == NULL)
 112     {
 113         // portable installation:
 114         // check for a configuration file in the program folder.
 115         QFileInfo config;
 116         config.setFile(QCoreApplication::instance()->applicationDirPath()
 117             + "/RockboxUtility.ini");
 118         if(config.isFile())
 119         {
 120             userSettings = new QSettings(QCoreApplication::instance()->applicationDirPath()
 121                 + "/RockboxUtility.ini", QSettings::IniFormat, NULL);
 122             qDebug() << "[Settings] configuration: portable";
 123         }
 124         else
 125         {
 126             userSettings = new QSettings(QSettings::IniFormat,
 127             QSettings::UserScope, "rockbox.org", "RockboxUtility",NULL);
 128             qDebug() << "[Settings] configuration: system";
 129         }
 130     }
 131 }
 132
 133 void RbSettings::sync()
 134 {
 135     ensureRbSettingsExists();
 136
 137     userSettings->sync();
 138 #if defined(Q_OS_LINUX)
 139     // when using sudo it runs rbutil with uid 0 but unfortunately without a
 140     // proper login shell, thus the configuration file gets placed in the
 141     // calling users $HOME. This in turn will cause issues if trying to
 142     // run rbutil later as user. Try to detect this case via the environment
 143     // variable SUDO_UID and SUDO_GID and if set chown the user config file.
 144     if(getuid() == 0)
 145     {
 146         char* realuser = getenv("SUDO_UID");
 147         char* realgroup = getenv("SUDO_GID");
 148         if(realuser != NULL && realgroup != NULL)
 149         {
 150             int realuid = atoi(realuser);
 151             int realgid = atoi(realgroup);
 152             // chown is attribute warn_unused_result, but in case this fails
 153             // we can't do anything useful about it. Notifying the user
 154             // is somewhat pointless. Add hack to suppress compiler warning.
 155             if(chown(qPrintable(userSettings->fileName()), realuid, realgid));
 156         }
 157     }
 158 #endif
 159 }
 160
 161 QString RbSettings::userSettingFilename()
 162 {
 163     ensureRbSettingsExists();
 164     return userSettings->fileName();
 165 }
 166
 167 QVariant RbSettings::value(enum SystemSettings setting)
 168 {
 169     ensureRbSettingsExists();
 170
 171     // locate setting item
 172     int i = 0;
 173     while(SystemSettingsList[i].setting != setting)
 174         i++;
 175
 176     QString s = constructSettingPath(SystemSettingsList[i].name);
 177     QString d = SystemSettingsList[i].def;
 178     d.replace(":platform:", userSettings->value("platform").toString());
 179     qDebug() << "[Settings] GET S:" << s << systemSettings->value(s, d).toString();
 180     return systemSettings->value(s, d);
 181 }
 182
 183 QVariant RbSettings::value(enum UserSettings setting)
 184 {
 185     QString empty;
 186     return subValue(empty, setting);
 187 }
 188
 189 QVariant RbSettings::subValue(QString sub, enum UserSettings setting)
 190 {
 191     ensureRbSettingsExists();
 192
 193     // locate setting item
 194     int i = 0;
 195     while(UserSettingsList[i].setting != setting)
 196         i++;
 197
 198     QString s = constructSettingPath(UserSettingsList[i].name, sub);
 199     qDebug() << "[Settings] GET U:" << s << userSettings->value(s).toString();
 200     return userSettings->value(s, UserSettingsList[i].def);
 201 }
 202
 203 void RbSettings::setValue(enum UserSettings setting , QVariant value)
 204 {
 205    QString empty;
 206    return setSubValue(empty, setting, value);
 207 }
 208
 209 void RbSettings::setSubValue(QString sub, enum UserSettings setting, QVariant value)
 210 {
 211     ensureRbSettingsExists();
 212
 213     // locate setting item
 214     int i = 0;
 215     while(UserSettingsList[i].setting != setting)
 216         i++;
 217
 218     QString s = constructSettingPath(UserSettingsList[i].name, sub);
 219     qDebug() << "[Settings] SET U:" << s << userSettings->value(s).toString();
 220     userSettings->setValue(s, value);
 221 }
 222
 223 QStringList RbSettings::platforms()
 224 {
 225     ensureRbSettingsExists();
 226
 227     QStringList result;
 228     systemSettings->beginGroup("platforms");
 229     QStringList a = systemSettings->childKeys();
 230     for(int i = 0; i < a.size(); i++)
 231     {
 232         result.append(systemSettings->value(a.at(i), "null").toString());
 233     }
 234     systemSettings->endGroup();
 235     return result;
 236 }
 237
 238 QStringList RbSettings::languages()
 239 {
 240     ensureRbSettingsExists();
 241
 242     QStringList result;
 243     systemSettings->beginGroup("languages");
 244     QStringList a = systemSettings->childKeys();
 245     for(int i = 0; i < a.size(); i++)
 246     {
 247         result.append(systemSettings->value(a.at(i), "null").toString());
 248     }
 249     systemSettings->endGroup();
 250     return result;
 251 }
 252
 253 QString RbSettings::name(QString platform)
 254 {
 255     ensureRbSettingsExists();
 256     return systemSettings->value(platform + "/name").toString();
 257 }
 258
 259 QString RbSettings::brand(QString platform)
 260 {
 261     ensureRbSettingsExists();
 262     return systemSettings->value(platform + "/brand").toString();
 263 }
 264
 265 QMap<int, QString> RbSettings::usbIdMap(enum MapType type)
 266 {
 267     ensureRbSettingsExists();
 268
 269     QMap<int, QString> map;
 270     // get a list of ID -> target name
 271     QStringList platforms;
 272     systemSettings->beginGroup("platforms");
 273     platforms = systemSettings->childKeys();
 274     systemSettings->endGroup();
 275
 276     QString t;
 277     switch(type) {
 278         case MapDevice:
 279             t = "usbid";
 280             break;
 281         case MapError:
 282             t = "usberror";
 283             break;
 284         case MapIncompatible:
 285             t = "usbincompat";
 286             break;
 287     }
 288
 289     for(int i = 0; i < platforms.size(); i++)
 290     {
 291         systemSettings->beginGroup("platforms");
 292         QString target = systemSettings->value(platforms.at(i)).toString();
 293         systemSettings->endGroup();
 294         systemSettings->beginGroup(target);
 295         QStringList ids = systemSettings->value(t).toStringList();
 296         int j = ids.size();
 297         while(j--)
 298             map.insert(ids.at(j).toInt(0, 16), target);
 299
 300         systemSettings->endGroup();
 301     }
 302     return map;
 303 }
 304
 305
 306 QString RbSettings::constructSettingPath(QString path, QString substitute)
 307 {
 308     QString platform = userSettings->value("platform").toString();
 309     if(!substitute.isEmpty()) {
 310         path.replace(":tts:", substitute);
 311         path.replace(":encoder:", substitute);
 312     }
 313     else {
 314         path.replace(":tts:", userSettings->value("tts").toString());
 315         path.replace(":encoder:", systemSettings->value(platform + "/encoder").toString());
 316     }
 317     path.replace(":platform:", platform);
 318
 319     return path;
 320 }
 321