plasma/dataengine.cpp

   1 /*
   2  *   Copyright 2006-2007 Aaron Seigo <aseigo@kde.org>
   3  *
   4  *   This program is free software; you can redistribute it and/or modify
   5  *   it under the terms of the GNU Library General Public License as
   6  *   published by the Free Software Foundation; either version 2, or
   7  *   (at your option) any later version.
   8  *
   9  *   This program is distributed in the hope that it will be useful,
  10  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  *   GNU General Public License for more details
  13  *
  14  *   You should have received a copy of the GNU Library General Public
  15  *   License along with this program; if not, write to the
  16  *   Free Software Foundation, Inc.,
  17  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  18  */
  19
  20 #include "dataengine.h"
  21 #include "private/dataengine_p.h"
  22
  23 #include <QQueue>
  24 #include <QTimer>
  25 #include <QTime>
  26 #include <QTimerEvent>
  27 #include <QVariant>
  28
  29 #include <kdebug.h>
  30 #include <kplugininfo.h>
  31 #include <kservice.h>
  32 #include <kstandarddirs.h>
  33
  34 #include "datacontainer.h"
  35 #include "package.h"
  36 #include "service.h"
  37 #include "scripting/dataenginescript.h"
  38
  39 #include "private/service_p.h"
  40
  41 namespace Plasma
  42 {
  43
  44 DataEngine::DataEngine(QObject *parent, KService::Ptr service)
  45     : QObject(parent),
  46       d(new DataEnginePrivate(this, service))
  47 {
  48     connect(d->updateTimer, SIGNAL(timeout()), this, SLOT(scheduleSourcesUpdated()));
  49 }
  50
  51 DataEngine::DataEngine(QObject *parent, const QVariantList &args)
  52     : QObject(parent),
  53       d(new DataEnginePrivate(this, KService::serviceByStorageId(args.count() > 0 ? args[0].toString() : QString())))
  54 {
  55     connect(d->updateTimer, SIGNAL(timeout()), this, SLOT(scheduleSourcesUpdated()));
  56 }
  57
  58 DataEngine::~DataEngine()
  59 {
  60     //kDebug() << objectName() << ": bye bye birdy! ";
  61     delete d;
  62 }
  63
  64 QStringList DataEngine::sources() const
  65 {
  66     if (d->script) {
  67         return d->script->sources();
  68     } else {
  69         return d->sources.keys();
  70     }
  71 }
  72
  73 Service *DataEngine::serviceForSource(const QString &source)
  74 {
  75     if (d->script) {
  76         return d->script->serviceForSource(source);
  77     } else {
  78         return new NullService(source, this);
  79     }
  80 }
  81
  82 void DataEngine::connectSource(const QString &source, QObject *visualization,
  83                                uint pollingInterval,
  84                                Plasma::IntervalAlignment intervalAlignment) const
  85 {
  86     //kDebug() << "connectSource" << source;
  87     bool newSource;
  88     DataContainer *s = d->requestSource(source, &newSource);
  89
  90     if (s) {
  91         // we suppress the immediate invocation of dataUpdated here if the
  92         // source was prexisting and they don't request delayed updates
  93         // (we want to do an immediate update in that case so they don't
  94         // have to wait for the first time out)
  95         d->connectSource(s, visualization, pollingInterval, intervalAlignment,
  96                          !newSource || pollingInterval > 0);
  97         //kDebug() << " ==> source connected";
  98     }
  99 }
 100
 101 void DataEngine::connectAllSources(QObject *visualization, uint pollingInterval,
 102                                    Plasma::IntervalAlignment intervalAlignment) const
 103 {
 104     foreach (DataContainer *s, d->sources) {
 105         d->connectSource(s, visualization, pollingInterval, intervalAlignment);
 106     }
 107 }
 108
 109 void DataEngine::disconnectSource(const QString &source, QObject *visualization) const
 110 {
 111     DataContainer *s = d->source(source, false);
 112
 113     if (s) {
 114         s->disconnectVisualization(visualization);
 115     }
 116 }
 117
 118 DataContainer *DataEngine::containerForSource(const QString &source)
 119 {
 120     return d->source(source, false);
 121 }
 122
 123 DataEngine::Data DataEngine::query(const QString &source) const
 124 {
 125     bool newSource;
 126     DataContainer *s = d->requestSource(source, &newSource);
 127
 128     if (!s) {
 129         return DataEngine::Data();
 130     } else if (!newSource && d->minPollingInterval >= 0 &&
 131                s->timeSinceLastUpdate() >= uint(d->minPollingInterval)) {
 132         if (const_cast<DataEngine*>(this)->updateSourceEvent(source)) {
 133             d->queueUpdate();
 134         }
 135     }
 136
 137     DataEngine::Data data = s->data();
 138     s->checkUsage();
 139     return data;
 140 }
 141
 142 void DataEngine::init()
 143 {
 144     if (d->script) {
 145         d->script->init();
 146     } else {
 147         // kDebug() << "called";
 148         // default implementation does nothing. this is for engines that have to
 149         // start things in motion external to themselves before they can work
 150     }
 151 }
 152
 153 bool DataEngine::sourceRequestEvent(const QString &name)
 154 {
 155     if (d->script) {
 156         return d->script->sourceRequestEvent(name);
 157     } else {
 158         return false;
 159     }
 160 }
 161
 162 bool DataEngine::updateSourceEvent(const QString &source)
 163 {
 164     if (d->script) {
 165         return d->script->updateSourceEvent(source);
 166     } else {
 167         //kDebug() << source;
 168         return false; //TODO: should this be true to trigger, even needless, updates on every tick?
 169     }
 170 }
 171
 172 void DataEngine::setData(const QString &source, const QVariant &value)
 173 {
 174     setData(source, source, value);
 175 }
 176
 177 void DataEngine::setData(const QString &source, const QString &key, const QVariant &value)
 178 {
 179     DataContainer *s = d->source(source, false);
 180     bool isNew = !s;
 181
 182     if (isNew) {
 183         s = d->source(source);
 184     }
 185
 186     s->setData(key, value);
 187
 188     if (isNew) {
 189         emit sourceAdded(source);
 190     }
 191
 192     d->queueUpdate();
 193 }
 194
 195 void DataEngine::setData(const QString &source, const Data &data)
 196 {
 197     DataContainer *s = d->source(source, false);
 198     bool isNew = !s;
 199
 200     if (isNew) {
 201         s = d->source(source);
 202     }
 203
 204     Data::const_iterator it = data.constBegin();
 205     while (it != data.constEnd()) {
 206         s->setData(it.key(), it.value());
 207         ++it;
 208     }
 209
 210     if (isNew) {
 211         emit sourceAdded(source);
 212     }
 213
 214     d->queueUpdate();
 215 }
 216
 217 void DataEngine::removeAllData(const QString &source)
 218 {
 219     DataContainer *s = d->source(source, false);
 220     if (s) {
 221         s->removeAllData();
 222         d->queueUpdate();
 223     }
 224 }
 225
 226 void DataEngine::removeData(const QString &source, const QString &key)
 227 {
 228     DataContainer *s = d->source(source, false);
 229     if (s) {
 230         s->setData(key, QVariant());
 231         d->queueUpdate();
 232     }
 233 }
 234
 235 void DataEngine::addSource(DataContainer *source)
 236 {
 237     if (d->sources.contains(source->objectName())) {
 238         kDebug() << "source named \"" << source->objectName() << "\" already exists.";
 239         return;
 240     }
 241
 242     QObject::connect(source, SIGNAL(updateRequested(DataContainer*)),
 243                      this, SLOT(internalUpdateSource(DataContainer*)));
 244     d->sources.insert(source->objectName(), source);
 245     emit sourceAdded(source->objectName());
 246     d->queueUpdate();
 247 }
 248
 249 void DataEngine::setMaxSourceCount(uint limit)
 250 {
 251     if (d->limit == limit) {
 252         return;
 253     }
 254
 255     d->limit = limit;
 256
 257     if (d->limit > 0) {
 258         d->trimQueue();
 259     } else {
 260         d->sourceQueue.clear();
 261     }
 262 }
 263
 264 uint DataEngine::maxSourceCount() const
 265 {
 266     return d->limit;
 267 }
 268
 269 void DataEngine::setMinimumPollingInterval(int minimumMs)
 270 {
 271     if (minimumMs < 0) {
 272         minimumMs = 0;
 273     }
 274
 275     d->minPollingInterval = minimumMs;
 276 }
 277
 278 int DataEngine::minimumPollingInterval() const
 279 {
 280     return d->minPollingInterval;
 281 }
 282
 283 void DataEngine::setPollingInterval(uint frequency)
 284 {
 285     killTimer(d->updateTimerId);
 286     d->updateTimerId = 0;
 287
 288     if (frequency > 0) {
 289         d->updateTimerId = startTimer(frequency);
 290     }
 291 }
 292
 293 /*
 294 NOTE: This is not implemented to prevent having to store the value internally.
 295       When there is a good use case for needing access to this value, we can
 296       add another member to the Private class and add this method.
 297
 298 void DataEngine::pollingInterval()
 299 {
 300     return d->pollingInterval;
 301 }
 302 */
 303
 304 void DataEngine::removeSource(const QString &source)
 305 {
 306     //kDebug() << "removing source " << source;
 307     SourceDict::iterator it = d->sources.find(source);
 308     if (it != d->sources.end()) {
 309         DataContainer *s = it.value();
 310
 311         // remove it from the limit queue if we're keeping one
 312         if (d->limit > 0) {
 313             QQueue<DataContainer*>::iterator it = d->sourceQueue.begin();
 314             while (it != d->sourceQueue.end()) {
 315                 if (*it == s) {
 316                     d->sourceQueue.erase(it);
 317                     break;
 318                 }
 319                 ++it;
 320             }
 321         }
 322
 323         s->deleteLater();
 324         d->sources.erase(it);
 325         emit sourceRemoved(source);
 326     }
 327 }
 328
 329 void DataEngine::removeAllSources()
 330 {
 331     QMutableHashIterator<QString, Plasma::DataContainer*> it(d->sources);
 332     while (it.hasNext()) {
 333         it.next();
 334         emit sourceRemoved(it.key());
 335         delete it.value();
 336         it.remove();
 337     }
 338 }
 339
 340 bool DataEngine::isValid() const
 341 {
 342     return d->valid;
 343 }
 344
 345 bool DataEngine::isEmpty() const
 346 {
 347     return d->sources.isEmpty();
 348 }
 349
 350 void DataEngine::setValid(bool valid)
 351 {
 352     d->valid = valid;
 353 }
 354
 355 DataEngine::SourceDict DataEngine::containerDict() const
 356 {
 357     return d->sources;
 358 }
 359
 360 void DataEngine::timerEvent(QTimerEvent *event)
 361 {
 362     if (event->timerId() != d->updateTimerId) {
 363         kDebug() << "bzzzt";
 364         return;
 365     }
 366
 367     event->accept();
 368
 369     // if the freq update is less than 0, don't bother
 370     if (d->minPollingInterval < 0) {
 371         //kDebug() << "uh oh.. no polling allowed!";
 372         return;
 373     }
 374
 375     // minPollingInterval
 376     if (d->updateTimestamp.elapsed() < d->minPollingInterval) {
 377         //kDebug() << "hey now.. slow down!";
 378         return;
 379     }
 380
 381     d->updateTimestamp.restart();
 382     updateAllSources();
 383 }
 384
 385 void DataEngine::updateAllSources()
 386 {
 387     QHashIterator<QString, Plasma::DataContainer*> it(d->sources);
 388     while (it.hasNext()) {
 389         it.next();
 390         //kDebug() << "updating" << it.key();
 391         updateSourceEvent(it.key());
 392     }
 393
 394     scheduleSourcesUpdated();
 395 }
 396
 397 void DataEngine::setIcon(const QString &icon)
 398 {
 399     d->icon = icon;
 400 }
 401
 402 QString DataEngine::icon() const
 403 {
 404     return d->icon;
 405 }
 406
 407 QString DataEngine::pluginName() const
 408 {
 409     if (!d->dataEngineDescription.isValid()) {
 410         return QString();
 411     }
 412
 413     return d->dataEngineDescription.pluginName();
 414 }
 415
 416 const Package *DataEngine::package() const
 417 {
 418     return d->package;
 419 }
 420
 421 void DataEngine::scheduleSourcesUpdated()
 422 {
 423     QHashIterator<QString, Plasma::DataContainer*> it(d->sources);
 424     while (it.hasNext()) {
 425         it.next();
 426         it.value()->checkForUpdate();
 427     }
 428 }
 429
 430 QString DataEngine::name() const
 431 {
 432     return d->engineName;
 433 }
 434
 435 void DataEngine::setName(const QString &name)
 436 {
 437     d->engineName = name;
 438     setObjectName(name);
 439 }
 440
 441 // Private class implementations
 442 DataEnginePrivate::DataEnginePrivate(DataEngine *e, KService::Ptr service)
 443     : q(e),
 444       dataEngineDescription(service),
 445       refCount(-1), // first ref
 446       updateTimerId(0),
 447       minPollingInterval(-1),
 448       limit(0),
 449       valid(true),
 450       script(0),
 451       package(0)
 452 {
 453     updateTimer = new QTimer(q);
 454     updateTimer->setSingleShot(true);
 455     updateTimestamp.start();
 456
 457     if (!service) {
 458         engineName = i18n("Unnamed");
 459         return;
 460     }
 461
 462     engineName = service->name();
 463     if (engineName.isEmpty()) {
 464         engineName = i18n("Unnamed");
 465     }
 466     e->setObjectName(engineName);
 467     icon = service->icon();
 468
 469     if (dataEngineDescription.isValid()) {
 470         QString api = dataEngineDescription.property("X-Plasma-API").toString();
 471
 472         if (!api.isEmpty()) {
 473             const QString path =
 474                 KStandardDirs::locate("data",
 475                                       "plasma/dataengines/" + dataEngineDescription.pluginName() + '/');
 476             PackageStructure::Ptr structure =
 477                 Plasma::packageStructure(api, Plasma::DataEngineComponent);
 478             structure->setPath(path);
 479             package = new Package(path, structure);
 480
 481             script = Plasma::loadScriptEngine(api, q);
 482             if (!script) {
 483                 kDebug() << "Could not create a" << api << "ScriptEngine for the"
 484                         << dataEngineDescription.name() << "DataEngine.";
 485                 delete package;
 486                 package = 0;
 487             }
 488         }
 489     }
 490 }
 491
 492 DataEnginePrivate::~DataEnginePrivate()
 493 {
 494     delete script;
 495     script = 0;
 496     delete package;
 497     package = 0;
 498 }
 499
 500 void DataEnginePrivate::internalUpdateSource(DataContainer *source)
 501 {
 502     if (minPollingInterval > 0 &&
 503         source->timeSinceLastUpdate() < (uint)minPollingInterval) {
 504         // skip updating this source; it's been too soon
 505         //kDebug() << "internal update source is delaying" << source->timeSinceLastUpdate() << minPollingInterval;
 506         //but fake an update so that the signalrelay that triggered this gets the data from the
 507         //recent update. this way we don't have to worry about queuing - the relay will send a
 508         //signal immediately and everyone else is undisturbed.
 509         source->setNeedsUpdate();
 510         return;
 511     }
 512
 513     if (q->updateSourceEvent(source->objectName())) {
 514         //kDebug() << "queuing an update";
 515         queueUpdate();
 516     }/* else {
 517         kDebug() << "no update";
 518     }*/
 519 }
 520
 521 void DataEnginePrivate::ref()
 522 {
 523     --refCount;
 524 }
 525
 526 void DataEnginePrivate::deref()
 527 {
 528     ++refCount;
 529 }
 530
 531 bool DataEnginePrivate::isUsed() const
 532 {
 533     return refCount != 0;
 534 }
 535
 536 DataContainer *DataEnginePrivate::source(const QString &sourceName, bool createWhenMissing)
 537 {
 538     DataEngine::SourceDict::const_iterator it = sources.constFind(sourceName);
 539     if (it != sources.constEnd()) {
 540         DataContainer *s = it.value();
 541         if (limit > 0) {
 542             QQueue<DataContainer*>::iterator it = sourceQueue.begin();
 543             while (it != sourceQueue.end()) {
 544                 if (*it == s) {
 545                     sourceQueue.erase(it);
 546                     break;
 547                 }
 548                 ++it;
 549             }
 550             sourceQueue.enqueue(s);
 551         }
 552         return it.value();
 553     }
 554
 555     if (!createWhenMissing) {
 556         return 0;
 557     }
 558
 559     /*kDebug() << "DataEngine " << q->objectName()
 560                 << ": could not find DataContainer " << sourceName
 561                 << ", creating" << endl;*/
 562     DataContainer *s = new DataContainer(q);
 563     s->setObjectName(sourceName);
 564     sources.insert(sourceName, s);
 565     QObject::connect(s, SIGNAL(updateRequested(DataContainer*)),
 566                      q, SLOT(internalUpdateSource(DataContainer*)));
 567
 568     if (limit > 0) {
 569         trimQueue();
 570         sourceQueue.enqueue(s);
 571     }
 572     return s;
 573 }
 574
 575 void DataEnginePrivate::connectSource(DataContainer *s, QObject *visualization,
 576                                       uint pollingInterval,
 577                                       Plasma::IntervalAlignment align,
 578                                       bool immediateCall)
 579 {
 580     //kDebug() << "connect source called" << s->objectName() << "with interval" << pollingInterval;
 581     if (pollingInterval > 0) {
 582         // never more frequently than allowed, never more than 20 times per second
 583         uint min = qMax(50, minPollingInterval); // for qMax below
 584         pollingInterval = qMax(min, pollingInterval);
 585
 586         // align on the 50ms
 587         pollingInterval = pollingInterval - (pollingInterval % 50);
 588     }
 589
 590     if (immediateCall) {
 591         // we don't want to do an immediate call if we are simply
 592         // reconnecting
 593         //kDebug() << "immediate call requested, we have:" << s->visualizationIsConnected(visualization);
 594         immediateCall = !s->visualizationIsConnected(visualization);
 595     }
 596
 597     s->connectVisualization(visualization, pollingInterval, align);
 598
 599     if (immediateCall) {
 600         QMetaObject::invokeMethod(visualization, "dataUpdated",
 601                                   Q_ARG(QString, s->objectName()),
 602                                   Q_ARG(Plasma::DataEngine::Data, s->data()));
 603     }
 604 }
 605
 606 DataContainer *DataEnginePrivate::requestSource(const QString &sourceName, bool *newSource)
 607 {
 608     if (newSource) {
 609         *newSource = false;
 610     }
 611
 612     //kDebug() << "requesting source " << sourceName;
 613     DataContainer *s = source(sourceName, false);
 614
 615     if (!s) {
 616         // we didn't find a data source, so give the engine an opportunity to make one
 617         /*kDebug() << "DataEngine " << q->objectName()
 618             << ": could not find DataContainer " << sourceName
 619             << " will create on request" << endl;*/
 620         if (q->sourceRequestEvent(sourceName)) {
 621             s = source(sourceName, false);
 622             if (s) {
 623                 // now we have a source; since it was created on demand, assume
 624                 // it should be removed when not used
 625                 if (newSource) {
 626                     *newSource = true;
 627                 }
 628                 QObject::connect(s, SIGNAL(becameUnused(QString)), q, SLOT(removeSource(QString)));
 629             }
 630         }
 631     }
 632
 633     return s;
 634 }
 635
 636 void DataEnginePrivate::trimQueue()
 637 {
 638     uint queueCount = sourceQueue.count();
 639     while (queueCount >= limit && !sourceQueue.isEmpty()) {
 640         DataContainer *punted = sourceQueue.dequeue();
 641         q->removeSource(punted->objectName());
 642         queueCount = sourceQueue.count();
 643     }
 644 }
 645
 646 void DataEnginePrivate::queueUpdate()
 647 {
 648     if (updateTimer->isActive()) {
 649         return;
 650     }
 651     updateTimer->start(0);
 652 }
 653
 654 }
 655
 656 #include "dataengine.moc"