workspace/solid/solidshell/solid-powermanagement.cpp

   1 /*  This file is part of the KDE project
   2     Copyright (C) 2006 Kevin Ottens <ervin@kde.org>
   3
   4     This library is free software; you can redistribute it and/or
   5     modify it under the terms of the GNU Library General Public
   6     License version 2 as published by the Free Software Foundation.
   7
   8     This library is distributed in the hope that it will be useful,
   9     but WITHOUT ANY WARRANTY; without even the implied warranty of
  10     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11     Library General Public License for more details.
  12
  13     You should have received a copy of the GNU Library General Public License
  14     along with this library; see the file COPYING.LIB.  If not, write to
  15     the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  16     Boston, MA 02110-1301, USA.
  17
  18 */
  19
  20 #include "solid-powermanagement.h"
  21
  22
  23 #include <QString>
  24 #include <QStringList>
  25 #include <QMetaProperty>
  26 #include <QMetaEnum>
  27 #include <QTimer>
  28
  29 #include <kcomponentdata.h>
  30 #include <kcmdlineargs.h>
  31 #include <klocale.h>
  32 #include <k3socketaddress.h>
  33 #include <kdebug.h>
  34
  35 #include <solid/device.h>
  36 #include <solid/genericinterface.h>
  37 #include <solid/storageaccess.h>
  38 #include <solid/opticaldrive.h>
  39
  40 #include <solid/control/powermanager.h>
  41
  42 #include <kjob.h>
  43
  44
  45 #include <iostream>
  46 using namespace std;
  47
  48 static const char appName[] = "solid-powermanagement";
  49 static const char programName[] = I18N_NOOP("solid-powermanagement");
  50
  51 static const char description[] = I18N_NOOP("KDE tool for querying and controlling your power management options from the command line");
  52
  53 static const char version[] = "0.1";
  54
  55 std::ostream &operator<<(std::ostream &out, const QString &msg)
  56 {
  57     return (out << msg.toLocal8Bit().constData());
  58 }
  59
  60 std::ostream &operator<<(std::ostream &out, const QVariant &value)
  61 {
  62     switch (value.type())
  63     {
  64     case QVariant::StringList:
  65     {
  66         out << "{";
  67
  68         QStringList list = value.toStringList();
  69
  70         QStringList::ConstIterator it = list.constBegin();
  71         QStringList::ConstIterator end = list.constEnd();
  72
  73         for (; it!=end; ++it)
  74         {
  75             out << "'" << *it << "'";
  76
  77             if (it+1!=end)
  78             {
  79                 out << ", ";
  80             }
  81         }
  82
  83         out << "}  (string list)";
  84         break;
  85     }
  86     case QVariant::Bool:
  87         out << (value.toBool()?"true":"false") << "  (bool)";
  88         break;
  89     case QVariant::Int:
  90         out << value.toString()
  91             << "  (0x" << QString::number(value.toInt(), 16) << ")  (int)";
  92         break;
  93     default:
  94         out << "'" << value.toString() << "'  (string)";
  95         break;
  96     }
  97
  98     return out;
  99 }
 100
 101 std::ostream &operator<<(std::ostream &out, const Solid::Device &device)
 102 {
 103     out << "  parent = " << QVariant(device.parentUdi()) << endl;
 104     out << "  vendor = " << QVariant(device.vendor()) << endl;
 105     out << "  product = " << QVariant(device.product()) << endl;
 106
 107     int index = Solid::DeviceInterface::staticMetaObject.indexOfEnumerator("Type");
 108     QMetaEnum typeEnum = Solid::DeviceInterface::staticMetaObject.enumerator(index);
 109
 110     for (int i=0; i<typeEnum.keyCount(); i++)
 111     {
 112         Solid::DeviceInterface::Type type = (Solid::DeviceInterface::Type)typeEnum.value(i);
 113         const Solid::DeviceInterface *interface = device.asDeviceInterface(type);
 114
 115         if (interface)
 116         {
 117             const QMetaObject *meta = interface->metaObject();
 118
 119             for (int i=meta->propertyOffset(); i<meta->propertyCount(); i++)
 120             {
 121                 QMetaProperty property = meta->property(i);
 122                 out << "  " << QString(meta->className()).mid(7) << "." << property.name()
 123                     << " = ";
 124
 125                 QVariant value = property.read(interface);
 126
 127                 if (property.isEnumType()) {
 128                     QMetaEnum metaEnum = property.enumerator();
 129                     out << "'" << metaEnum.valueToKeys(value.toInt()).constData() << "'"
 130                         << "  (0x" << QString::number(value.toInt(), 16) << ")  ";
 131                     if (metaEnum.isFlag()) {
 132                         out << "(flag)";
 133                     } else {
 134                         out << "(enum)";
 135                     }
 136                     out << endl;
 137                 } else {
 138                     out << value << endl;
 139                 }
 140             }
 141         }
 142     }
 143
 144     return out;
 145 }
 146
 147 std::ostream &operator<<(std::ostream &out, const QMap<QString,QVariant> &properties)
 148 {
 149     foreach (const QString& key, properties.keys())
 150     {
 151         out << "  " << key << " = " << properties[key] << endl;
 152     }
 153
 154     return out;
 155 }
 156
 157 void checkArgumentCount(int min, int max)
 158 {
 159     int count = KCmdLineArgs::parsedArgs()->count();
 160
 161     if (count < min)
 162     {
 163         cerr << i18n("Syntax Error: Not enough arguments") << endl;
 164         ::exit(1);
 165     }
 166
 167     if ((max > 0) && (count > max))
 168     {
 169         cerr << i18n("Syntax Error: Too many arguments") << endl;
 170         ::exit(1);
 171     }
 172 }
 173
 174 int main(int argc, char **argv)
 175 {
 176   KCmdLineArgs::init(argc, argv, appName, 0, ki18n(programName), version, ki18n(description), false);
 177
 178
 179   KCmdLineOptions options;
 180
 181   options.add("commands", ki18n("Show available commands"));
 182
 183   options.add("+command", ki18n("Command (see --commands)"));
 184
 185   options.add("+[arg(s)]", ki18n("Arguments for command"));
 186
 187   KCmdLineArgs::addCmdLineOptions(options);
 188
 189   KCmdLineArgs *args = KCmdLineArgs::parsedArgs();
 190
 191   KComponentData componentData(appName);
 192
 193   if (args->isSet("commands"))
 194   {
 195       KCmdLineArgs::enable_i18n();
 196
 197       cout << endl << i18n("Syntax:") << endl << endl;
 198
 199       cout << "  solid-powermanagement query (suspend|scheme|cpufreq)" << endl;
 200       cout << i18n("             # List a particular set of information regarding power management.\n"
 201                     "             # - If the 'suspend' option is specified, give the list of suspend\n"
 202                     "             # method supported by the system\n"
 203                     "             # - If the 'scheme' option is specified, give the list of\n"
 204                     "             # supported power management schemes by this system\n"
 205                     "             # - If the 'cpufreq' option is specified, give the list of\n"
 206                     "             # supported CPU frequency policy\n") << endl;
 207
 208       cout << "  solid-powermanagement set (scheme|cpufreq) 'value'" << endl;
 209       cout << i18n("             # Set power management options of the system.\n"
 210                     "             # - If the 'scheme' option is specified, the power management\n"
 211                     "             # scheme set corresponds to 'value'\n"
 212                     "             # - If the 'cpufreq' option is specified, the CPU frequency policy\n"
 213                     "             # set corresponds to 'value'\n") << endl;
 214
 215       cout << "  solid-powermanagement suspend 'method'" << endl;
 216       cout << i18n("             # Suspend the computer using the given 'method'.\n") << endl;
 217
 218       cout << "  solid-powermanagement brightness (set|get) 'value'" << endl;
 219       cout << i18n("             # Set and get brightness options of the system.\n"
 220                     "             # - If the 'set' option is specified, the brightness is\n"
 221                     "             # set to 'value' (as a percentage)\n"
 222                     "             # - If the 'get' option is specified, the current brightness\n"
 223                     "             # is returned (as a percentage)'\n") << endl;
 224
 225       cout << endl;
 226
 227       return 0;
 228   }
 229
 230   return SolidPowermanagement::doIt() ? 0 : 1;
 231 }
 232
 233 bool SolidPowermanagement::doIt()
 234 {
 235     KCmdLineArgs *args = KCmdLineArgs::parsedArgs();
 236     checkArgumentCount(1, 0);
 237
 238     QString command(args->arg(0));
 239
 240     int fake_argc = 0;
 241     char **fake_argv = 0;
 242     SolidPowermanagement shell(fake_argc, fake_argv);
 243
 244     if (command == "suspend")
 245     {
 246         checkArgumentCount(2, 2);
 247         QString method(args->arg(1));
 248
 249         return shell.powerSuspend(method);
 250     }
 251     else if (command == "query")
 252     {
 253         checkArgumentCount(2, 2);
 254         QString type(args->arg(1));
 255
 256         if (type == "suspend")
 257         {
 258             return shell.powerQuerySuspendMethods();
 259         }
 260         else if (type == "scheme")
 261         {
 262             return shell.powerQuerySchemes();
 263         }
 264         else if (type == "cpufreq")
 265         {
 266             return shell.powerQueryCpuPolicies();
 267         }
 268         else
 269         {
 270             cerr << i18n("Syntax Error: Unknown option '%1'" , type) << endl;
 271         }
 272     }
 273     else if (command == "set")
 274     {
 275         checkArgumentCount(3, 3);
 276         QString type(args->arg(1));
 277         QString value(args->arg(2));
 278
 279         if (type == "scheme")
 280         {
 281             return shell.powerChangeScheme(value);
 282         }
 283         else if (type == "cpufreq")
 284         {
 285             return shell.powerChangeCpuPolicy(value);
 286         }
 287         else
 288         {
 289             cerr << i18n("Syntax Error: Unknown option '%1'" , type) << endl;
 290         }
 291     }
 292     else if (command == "brightness")
 293     {
 294         QString request(args->arg(1));
 295         if (request == "get")
 296         {
 297             cout << endl << "Brightness is " << shell.powerGetBrightness() << "%" << endl;
 298         }
 299         else if (request == "set")
 300         {
 301             return shell.powerSetBrightness(args->arg(2).toInt());
 302         }
 303     }
 304     else
 305     {
 306         cerr << i18n("Syntax Error: Unknown command '%1'" , command) << endl;
 307     }
 308
 309     return false;
 310 }
 311
 312 bool SolidPowermanagement::powerQuerySuspendMethods()
 313 {
 314     Solid::Control::PowerManager::SuspendMethods methods = Solid::Control::PowerManager::supportedSuspendMethods();
 315
 316     if (methods  & Solid::Control::PowerManager::ToDisk)
 317     {
 318         cout << "to_disk" << endl;
 319     }
 320
 321     if (methods  & Solid::Control::PowerManager::ToRam)
 322     {
 323         cout << "to_ram" << endl;
 324     }
 325
 326     if (methods  & Solid::Control::PowerManager::Standby)
 327     {
 328         cout << "standby" << endl;
 329     }
 330
 331     return true;
 332 }
 333
 334 bool SolidPowermanagement::powerSuspend(const QString &strMethod)
 335 {
 336     Solid::Control::PowerManager::SuspendMethods supported
 337         = Solid::Control::PowerManager::supportedSuspendMethods();
 338
 339     Solid::Control::PowerManager::SuspendMethod method = Solid::Control::PowerManager::UnknownSuspendMethod;
 340
 341     if (strMethod == "to_disk" && (supported  & Solid::Control::PowerManager::ToDisk))
 342     {
 343         method = Solid::Control::PowerManager::ToDisk;
 344     }
 345     else if (strMethod == "to_ram" && (supported  & Solid::Control::PowerManager::ToRam))
 346     {
 347         method = Solid::Control::PowerManager::ToRam;
 348     }
 349     else if (strMethod == "standby" && (supported  & Solid::Control::PowerManager::Standby))
 350     {
 351         method = Solid::Control::PowerManager::Standby;
 352     }
 353     else
 354     {
 355         cerr << i18n("Unsupported suspend method: %1" , strMethod) << endl;
 356         return false;
 357     }
 358
 359     KJob *job = Solid::Control::PowerManager::suspend(method);
 360
 361     if (job==0)
 362     {
 363         cerr << i18n("Error: unsupported operation!") << endl;
 364         return false;
 365     }
 366
 367     connectJob(job);
 368
 369     job->start();
 370     m_loop.exec();
 371
 372     if (m_error)
 373     {
 374         cerr << i18n("Error: %1" , m_errorString) << endl;
 375         return false;
 376     }
 377     else
 378     {
 379         return true;
 380     }
 381 }
 382
 383 bool SolidPowermanagement::powerQuerySchemes()
 384 {
 385     QString current = Solid::Control::PowerManager::scheme();
 386     QStringList schemes = Solid::Control::PowerManager::supportedSchemes();
 387
 388     foreach (const QString& scheme, schemes)
 389     {
 390         cout << scheme << " (" << Solid::Control::PowerManager::schemeDescription(scheme) << ")";
 391
 392         if (scheme==current)
 393         {
 394             cout << " [*]" << endl;
 395         }
 396         else
 397         {
 398             cout << endl;
 399         }
 400     }
 401
 402     return true;
 403 }
 404
 405 bool SolidPowermanagement::powerChangeScheme(const QString &schemeName)
 406 {
 407     QStringList supported = Solid::Control::PowerManager::supportedSchemes();
 408
 409     if (!supported.contains(schemeName))
 410     {
 411         cerr << i18n("Unsupported scheme: %1" , schemeName) << endl;
 412         return false;
 413     }
 414
 415     return Solid::Control::PowerManager::setScheme(schemeName);
 416 }
 417
 418 bool SolidPowermanagement::powerQueryCpuPolicies()
 419 {
 420     Solid::Control::PowerManager::CpuFreqPolicy current = Solid::Control::PowerManager::cpuFreqPolicy();
 421     Solid::Control::PowerManager::CpuFreqPolicies policies = Solid::Control::PowerManager::supportedCpuFreqPolicies();
 422
 423     QList<Solid::Control::PowerManager::CpuFreqPolicy> all_policies;
 424     all_policies << Solid::Control::PowerManager::OnDemand
 425                  << Solid::Control::PowerManager::Userspace
 426                  << Solid::Control::PowerManager::Powersave
 427                  << Solid::Control::PowerManager::Performance
 428                  << Solid::Control::PowerManager::Conservative;
 429
 430     foreach (Solid::Control::PowerManager::CpuFreqPolicy policy, all_policies)
 431     {
 432         if (policies  & policy)
 433         {
 434             switch (policy)
 435             {
 436             case Solid::Control::PowerManager::OnDemand:
 437                 cout << "ondemand";
 438                 break;
 439             case Solid::Control::PowerManager::Userspace:
 440                 cout << "userspace";
 441                 break;
 442             case Solid::Control::PowerManager::Powersave:
 443                 cout << "powersave";
 444                 break;
 445             case Solid::Control::PowerManager::Performance:
 446                 cout << "performance";
 447                 break;
 448             case Solid::Control::PowerManager::Conservative:
 449                 cout << "conservative";
 450                 break;
 451             case Solid::Control::PowerManager::UnknownCpuFreqPolicy:
 452                 break;
 453             }
 454
 455             if (policy==current)
 456             {
 457                 cout << " [*]" << endl;
 458             }
 459             else
 460             {
 461                 cout << endl;
 462             }
 463         }
 464     }
 465
 466     return true;
 467 }
 468
 469 bool SolidPowermanagement::powerChangeCpuPolicy(const QString &policyName)
 470 {
 471     Solid::Control::PowerManager::CpuFreqPolicies supported
 472         = Solid::Control::PowerManager::supportedCpuFreqPolicies();
 473
 474     Solid::Control::PowerManager::CpuFreqPolicy policy = Solid::Control::PowerManager::UnknownCpuFreqPolicy;
 475
 476     if (policyName == "ondemand" && (supported  & Solid::Control::PowerManager::OnDemand))
 477     {
 478         policy = Solid::Control::PowerManager::OnDemand;
 479     }
 480     else if (policyName == "userspace" && (supported  & Solid::Control::PowerManager::Userspace))
 481     {
 482         policy = Solid::Control::PowerManager::Userspace;
 483     }
 484     else if (policyName == "performance" && (supported  & Solid::Control::PowerManager::Performance))
 485     {
 486         policy = Solid::Control::PowerManager::Performance;
 487     }
 488     else if (policyName == "powersave" && (supported  & Solid::Control::PowerManager::Powersave))
 489     {
 490         policy = Solid::Control::PowerManager::Powersave;
 491     }
 492     else if (policyName == "conservative" && (supported  & Solid::Control::PowerManager::Conservative))
 493     {
 494         policy = Solid::Control::PowerManager::Conservative;
 495     }
 496     else
 497     {
 498         cerr << i18n("Unsupported cpufreq policy: %1" , policyName) << endl;
 499         return false;
 500     }
 501
 502     return Solid::Control::PowerManager::setCpuFreqPolicy(policy);
 503 }
 504
 505 int SolidPowermanagement::powerGetBrightness()
 506 {
 507     return Solid::Control::PowerManager::brightness();
 508 }
 509
 510 bool SolidPowermanagement::powerSetBrightness(int brightness)
 511 {
 512     cout << "Setting brightness to " << brightness << "%" << endl;
 513     return Solid::Control::PowerManager::setBrightness(brightness);
 514 }
 515
 516
 517 void SolidPowermanagement::connectJob(KJob *job)
 518 {
 519     connect(job, SIGNAL(result(KJob *)),
 520              this, SLOT(slotResult(KJob *)));
 521     connect(job, SIGNAL(percent(KJob *, unsigned long)),
 522              this, SLOT(slotPercent(KJob *, unsigned long)));
 523     connect(job, SIGNAL(infoMessage(KJob *, const QString &, const QString &)),
 524              this, SLOT(slotInfoMessage(KJob *, const QString &)));
 525 }
 526
 527 void SolidPowermanagement::slotPercent(KJob */*job */, unsigned long percent)
 528 {
 529     cout << i18n("Progress: %1%" , percent) << endl;
 530 }
 531
 532 void SolidPowermanagement::slotInfoMessage(KJob */*job */, const QString &message)
 533 {
 534     cout << i18n("Info: %1" , message) << endl;
 535 }
 536
 537 void SolidPowermanagement::slotResult(KJob *job)
 538 {
 539     m_error = 0;
 540
 541     if (job->error())
 542     {
 543         m_error = job->error();
 544         m_errorString = job->errorString();
 545     }
 546
 547     m_loop.exit();
 548 }
 549
 550 void SolidPowermanagement::slotStorageResult(Solid::ErrorType error, const QVariant &errorData)
 551 {
 552     if (error) {
 553         m_error = 1;
 554         m_errorString = errorData.toString();
 555     }
 556     m_loop.exit();
 557 }
 558
 559 #include "solid-powermanagement.moc"