2008-11-04 00:08:39 +01:00
|
|
|
/*
|
|
|
|
* Copyright 2008 Aaron Seigo <aseigo@kde.org>
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU Library General Public License as
|
|
|
|
* published by the Free Software Foundation; either version 2, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU Library General Public
|
|
|
|
* License along with this program; if not, write to the
|
|
|
|
* Free Software Foundation, Inc.,
|
|
|
|
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "service.h"
|
2011-06-03 13:13:19 +02:00
|
|
|
#include "servicejob.h"
|
2009-09-03 01:49:58 +02:00
|
|
|
#include "private/authorizationmanager_p.h"
|
2008-11-04 00:08:39 +01:00
|
|
|
#include "private/service_p.h"
|
2009-09-02 04:27:16 +02:00
|
|
|
#include "private/serviceprovider_p.h"
|
2008-11-04 00:08:39 +01:00
|
|
|
|
2009-09-09 17:37:03 +02:00
|
|
|
#include "config-plasma.h"
|
2009-09-09 15:40:16 +02:00
|
|
|
|
2008-11-04 00:08:39 +01:00
|
|
|
#include <QFile>
|
2012-04-27 17:02:18 +02:00
|
|
|
#include <QGraphicsWidget>
|
2008-11-04 00:08:39 +01:00
|
|
|
#include <QTimer>
|
|
|
|
|
2008-11-04 03:55:37 +01:00
|
|
|
#include <kdebug.h>
|
2008-11-04 03:04:34 +01:00
|
|
|
#include <kservice.h>
|
|
|
|
#include <kservicetypetrader.h>
|
|
|
|
#include <ksharedconfig.h>
|
|
|
|
#include <kstandarddirs.h>
|
2009-09-02 04:27:16 +02:00
|
|
|
#include <dnssd/publicservice.h>
|
|
|
|
#include <dnssd/servicebrowser.h>
|
2008-11-04 00:08:39 +01:00
|
|
|
|
|
|
|
#include "configloader.h"
|
|
|
|
#include "version.h"
|
2008-11-21 02:26:43 +01:00
|
|
|
#include "private/configloader_p.h"
|
2009-10-20 21:15:32 +02:00
|
|
|
#include "private/remoteservice_p.h"
|
|
|
|
#include "private/remoteservicejob_p.h"
|
2010-07-15 23:06:21 +02:00
|
|
|
#include "pluginloader.h"
|
2008-11-04 00:08:39 +01:00
|
|
|
|
|
|
|
namespace Plasma
|
|
|
|
{
|
|
|
|
|
|
|
|
Service::Service(QObject *parent)
|
|
|
|
: QObject(parent),
|
|
|
|
d(new ServicePrivate(this))
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
Service::Service(QObject *parent, const QVariantList &args)
|
|
|
|
: QObject(parent),
|
|
|
|
d(new ServicePrivate(this))
|
|
|
|
{
|
|
|
|
Q_UNUSED(args)
|
|
|
|
}
|
|
|
|
|
|
|
|
Service::~Service()
|
|
|
|
{
|
2009-09-02 04:27:16 +02:00
|
|
|
d->unpublish();
|
2008-11-04 00:08:39 +01:00
|
|
|
delete d;
|
|
|
|
}
|
|
|
|
|
|
|
|
Service *Service::load(const QString &name, QObject *parent)
|
2010-05-13 01:30:10 +02:00
|
|
|
{
|
|
|
|
QVariantList args;
|
|
|
|
return load(name, args, parent);
|
|
|
|
}
|
|
|
|
|
|
|
|
Service *Service::load(const QString &name, const QVariantList &args, QObject *parent)
|
2008-11-04 00:08:39 +01:00
|
|
|
{
|
2010-07-15 23:38:56 +02:00
|
|
|
return PluginLoader::pluginLoader()->loadService(name, args, parent);
|
2008-11-04 00:08:39 +01:00
|
|
|
}
|
|
|
|
|
2009-09-02 04:27:16 +02:00
|
|
|
Service *Service::access(const KUrl &url, QObject *parent)
|
|
|
|
{
|
|
|
|
return new RemoteService(parent, url);
|
|
|
|
}
|
|
|
|
|
|
|
|
void ServicePrivate::jobFinished(KJob *job)
|
2010-05-26 18:02:18 +02:00
|
|
|
{
|
|
|
|
emit q->finished(static_cast<ServiceJob*>(job));
|
|
|
|
}
|
2009-09-02 04:27:16 +02:00
|
|
|
|
2010-05-26 18:02:18 +02:00
|
|
|
void ServicePrivate::associatedWidgetDestroyed(QObject *obj)
|
|
|
|
{
|
|
|
|
associatedWidgets.remove(static_cast<QWidget*>(obj));
|
|
|
|
}
|
2009-09-02 04:27:16 +02:00
|
|
|
|
2010-05-26 18:02:18 +02:00
|
|
|
void ServicePrivate::associatedGraphicsWidgetDestroyed(QObject *obj)
|
|
|
|
{
|
2012-04-27 17:02:18 +02:00
|
|
|
associatedGraphicsWidgets.remove(static_cast<QGraphicsObject*>(obj));
|
2010-05-26 18:02:18 +02:00
|
|
|
}
|
2009-09-02 04:27:16 +02:00
|
|
|
|
2010-10-04 23:48:06 +02:00
|
|
|
void ServicePrivate::publish(AnnouncementMethods methods, const QString &name, const PackageMetadata &metadata)
|
2010-05-26 18:02:18 +02:00
|
|
|
{
|
|
|
|
#ifdef ENABLE_REMOTE_WIDGETS
|
|
|
|
if (!serviceProvider) {
|
|
|
|
AuthorizationManager::self()->d->prepareForServicePublication();
|
2009-09-03 01:49:58 +02:00
|
|
|
|
2010-05-26 18:02:18 +02:00
|
|
|
serviceProvider = new ServiceProvider(name, q);
|
2009-09-02 04:27:16 +02:00
|
|
|
|
2010-05-26 18:02:18 +02:00
|
|
|
if (methods.testFlag(ZeroconfAnnouncement) &&
|
2010-10-04 23:48:06 +02:00
|
|
|
(DNSSD::ServiceBrowser::isAvailable() == DNSSD::ServiceBrowser::Working)) {
|
2010-05-26 18:02:18 +02:00
|
|
|
//TODO: dynamically pick a free port number.
|
|
|
|
publicService = new DNSSD::PublicService(name, "_plasma._tcp", 4000);
|
|
|
|
|
|
|
|
QMap<QString, QByteArray> textData;
|
|
|
|
textData["name"] = name.toUtf8();
|
|
|
|
textData["plasmoidname"] = metadata.name().toUtf8();
|
|
|
|
textData["description"] = metadata.description().toUtf8();
|
2011-04-28 23:48:55 +02:00
|
|
|
textData["icon"] = metadata.icon().toUtf8();
|
2010-05-26 18:02:18 +02:00
|
|
|
publicService->setTextData(textData);
|
|
|
|
kDebug() << "about to publish";
|
|
|
|
|
|
|
|
publicService->publishAsync();
|
|
|
|
} else if (methods.testFlag(ZeroconfAnnouncement) &&
|
|
|
|
(DNSSD::ServiceBrowser::isAvailable() != DNSSD::ServiceBrowser::Working)) {
|
|
|
|
kDebug() << "sorry, but your zeroconf daemon doesn't seem to be running.";
|
2009-09-02 04:27:16 +02:00
|
|
|
}
|
2010-05-26 18:02:18 +02:00
|
|
|
} else {
|
|
|
|
kDebug() << "already published!";
|
2009-09-02 04:27:16 +02:00
|
|
|
}
|
2010-05-26 18:02:18 +02:00
|
|
|
#else
|
|
|
|
kWarning() << "libplasma is compiled without support for remote widgets. not publishing.";
|
|
|
|
#endif
|
|
|
|
}
|
2009-09-02 04:27:16 +02:00
|
|
|
|
2010-05-26 18:02:18 +02:00
|
|
|
void ServicePrivate::unpublish()
|
|
|
|
{
|
|
|
|
delete serviceProvider;
|
|
|
|
serviceProvider = 0;
|
2009-09-02 04:27:16 +02:00
|
|
|
|
2010-05-26 18:02:18 +02:00
|
|
|
delete publicService;
|
|
|
|
publicService = 0;
|
|
|
|
}
|
2009-09-02 04:27:16 +02:00
|
|
|
|
2010-05-26 18:02:18 +02:00
|
|
|
bool ServicePrivate::isPublished() const
|
|
|
|
{
|
|
|
|
if (serviceProvider) {
|
|
|
|
return true;
|
|
|
|
} else {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
2009-09-02 04:27:16 +02:00
|
|
|
|
2010-05-26 18:02:18 +02:00
|
|
|
KConfigGroup ServicePrivate::dummyGroup()
|
|
|
|
{
|
|
|
|
if (!dummyConfig) {
|
2010-06-04 19:28:07 +02:00
|
|
|
dummyConfig = new KConfig(QString(), KConfig::SimpleConfig);
|
2009-09-02 04:27:16 +02:00
|
|
|
}
|
|
|
|
|
2010-05-26 18:02:18 +02:00
|
|
|
return KConfigGroup(dummyConfig, "DummyGroup");
|
|
|
|
}
|
|
|
|
|
2008-11-04 00:08:39 +01:00
|
|
|
void Service::setDestination(const QString &destination)
|
|
|
|
{
|
|
|
|
d->destination = destination;
|
|
|
|
}
|
|
|
|
|
|
|
|
QString Service::destination() const
|
|
|
|
{
|
|
|
|
return d->destination;
|
|
|
|
}
|
|
|
|
|
|
|
|
QStringList Service::operationNames() const
|
|
|
|
{
|
|
|
|
if (!d->config) {
|
|
|
|
kDebug() << "No valid operations scheme has been registered";
|
|
|
|
return QStringList();
|
|
|
|
}
|
|
|
|
|
|
|
|
return d->config->groupList();
|
|
|
|
}
|
|
|
|
|
|
|
|
KConfigGroup Service::operationDescription(const QString &operationName)
|
|
|
|
{
|
|
|
|
if (!d->config) {
|
|
|
|
kDebug() << "No valid operations scheme has been registered";
|
2009-08-02 20:24:20 +02:00
|
|
|
return d->dummyGroup();
|
2008-11-04 00:08:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
d->config->writeConfig();
|
|
|
|
KConfigGroup params(d->config->config(), operationName);
|
|
|
|
//kDebug() << "operation" << operationName
|
|
|
|
// << "requested, has keys" << params.keyList() << "from"
|
|
|
|
// << d->config->config()->name();
|
|
|
|
return params;
|
|
|
|
}
|
|
|
|
|
2009-10-20 21:15:32 +02:00
|
|
|
QMap<QString, QVariant> Service::parametersFromDescription(const KConfigGroup &description)
|
|
|
|
{
|
|
|
|
QMap<QString, QVariant> params;
|
|
|
|
|
|
|
|
if (!d->config || !description.isValid()) {
|
|
|
|
return params;
|
|
|
|
}
|
|
|
|
|
|
|
|
const QString op = description.name();
|
|
|
|
foreach (const QString &key, description.keyList()) {
|
|
|
|
KConfigSkeletonItem *item = d->config->findItem(op, key);
|
|
|
|
if (item) {
|
|
|
|
params.insert(key, description.readEntry(key, item->property()));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return params;
|
|
|
|
}
|
|
|
|
|
2008-11-04 00:08:39 +01:00
|
|
|
ServiceJob *Service::startOperationCall(const KConfigGroup &description, QObject *parent)
|
|
|
|
{
|
|
|
|
// TODO: nested groups?
|
|
|
|
ServiceJob *job = 0;
|
2009-10-20 21:15:32 +02:00
|
|
|
const QString op = description.isValid() ? description.name() : QString();
|
|
|
|
|
|
|
|
RemoteService *rs = qobject_cast<RemoteService *>(this);
|
|
|
|
if (!op.isEmpty() && rs && !rs->isReady()) {
|
|
|
|
// if we have an operation, but a non-ready remote service, just let it through
|
|
|
|
kDebug() << "Remote service is not ready; queueing operation";
|
|
|
|
QMap<QString, QVariant> params;
|
|
|
|
job = createJob(op, params);
|
|
|
|
RemoteServiceJob *rsj = qobject_cast<RemoteServiceJob *>(job);
|
|
|
|
if (rsj) {
|
|
|
|
rsj->setDelayedDescription(description);
|
|
|
|
}
|
|
|
|
} else if (!d->config) {
|
2008-11-04 00:08:39 +01:00
|
|
|
kDebug() << "No valid operations scheme has been registered";
|
2008-12-01 01:28:50 +01:00
|
|
|
} else if (!op.isEmpty() && d->config->hasGroup(op)) {
|
2008-11-04 00:08:39 +01:00
|
|
|
if (d->disabledOperations.contains(op)) {
|
|
|
|
kDebug() << "Operation" << op << "is disabled";
|
|
|
|
} else {
|
2009-10-20 21:15:32 +02:00
|
|
|
QMap<QString, QVariant> params = parametersFromDescription(description);
|
|
|
|
job = createJob(op, params);
|
2008-11-04 00:08:39 +01:00
|
|
|
}
|
|
|
|
} else {
|
2012-04-27 22:48:35 +02:00
|
|
|
kDebug() << op << "is not a valid group; valid groups are:" << d->config->groupList();
|
2008-11-04 00:08:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!job) {
|
|
|
|
job = new NullServiceJob(destination(), op, this);
|
|
|
|
}
|
|
|
|
|
|
|
|
job->setParent(parent ? parent : this);
|
|
|
|
connect(job, SIGNAL(finished(KJob*)), this, SLOT(jobFinished(KJob*)));
|
2011-04-28 18:01:16 +02:00
|
|
|
QTimer::singleShot(0, job, SLOT(autoStart()));
|
2008-11-04 00:08:39 +01:00
|
|
|
return job;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Service::associateWidget(QWidget *widget, const QString &operation)
|
|
|
|
{
|
2011-06-03 12:53:32 +02:00
|
|
|
if (!widget) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2008-11-04 00:08:39 +01:00
|
|
|
disassociateWidget(widget);
|
|
|
|
d->associatedWidgets.insert(widget, operation);
|
|
|
|
connect(widget, SIGNAL(destroyed(QObject*)), this, SLOT(associatedWidgetDestroyed(QObject*)));
|
|
|
|
|
|
|
|
widget->setEnabled(!d->disabledOperations.contains(operation));
|
|
|
|
}
|
|
|
|
|
|
|
|
void Service::disassociateWidget(QWidget *widget)
|
|
|
|
{
|
2011-06-03 12:53:32 +02:00
|
|
|
if (!widget) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2008-11-04 00:08:39 +01:00
|
|
|
disconnect(widget, SIGNAL(destroyed(QObject*)),
|
|
|
|
this, SLOT(associatedWidgetDestroyed(QObject*)));
|
|
|
|
d->associatedWidgets.remove(widget);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Service::associateWidget(QGraphicsWidget *widget, const QString &operation)
|
2012-04-27 17:02:18 +02:00
|
|
|
{
|
2012-04-27 22:33:18 +02:00
|
|
|
associateItem(widget, operation);
|
2012-04-27 17:02:18 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void Service::disassociateWidget(QGraphicsWidget *widget)
|
|
|
|
{
|
2012-04-27 22:33:18 +02:00
|
|
|
disassociateItem(widget);
|
2012-04-27 17:02:18 +02:00
|
|
|
}
|
|
|
|
|
2012-04-27 22:33:18 +02:00
|
|
|
void Service::associateItem(QGraphicsObject *widget, const QString &operation)
|
2008-11-04 00:08:39 +01:00
|
|
|
{
|
2011-06-03 12:56:11 +02:00
|
|
|
if (!widget) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2012-04-27 22:33:18 +02:00
|
|
|
disassociateItem(widget);
|
2008-11-04 00:08:39 +01:00
|
|
|
d->associatedGraphicsWidgets.insert(widget, operation);
|
|
|
|
connect(widget, SIGNAL(destroyed(QObject*)),
|
|
|
|
this, SLOT(associatedGraphicsWidgetDestroyed(QObject*)));
|
|
|
|
|
|
|
|
widget->setEnabled(!d->disabledOperations.contains(operation));
|
|
|
|
}
|
|
|
|
|
2012-04-27 22:33:18 +02:00
|
|
|
void Service::disassociateItem(QGraphicsObject *widget)
|
2008-11-04 00:08:39 +01:00
|
|
|
{
|
2011-06-03 12:56:11 +02:00
|
|
|
if (!widget) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2008-11-04 00:08:39 +01:00
|
|
|
disconnect(widget, SIGNAL(destroyed(QObject*)),
|
|
|
|
this, SLOT(associatedGraphicsWidgetDestroyed(QObject*)));
|
|
|
|
d->associatedGraphicsWidgets.remove(widget);
|
|
|
|
}
|
|
|
|
|
|
|
|
QString Service::name() const
|
|
|
|
{
|
|
|
|
return d->name;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Service::setName(const QString &name)
|
|
|
|
{
|
|
|
|
d->name = name;
|
|
|
|
|
|
|
|
// now reset the config, which may be based on our name
|
|
|
|
delete d->config;
|
|
|
|
d->config = 0;
|
|
|
|
|
2009-08-02 20:24:20 +02:00
|
|
|
delete d->dummyConfig;
|
|
|
|
d->dummyConfig = 0;
|
|
|
|
|
2008-11-04 00:08:39 +01:00
|
|
|
registerOperationsScheme();
|
2009-09-02 04:27:16 +02:00
|
|
|
|
|
|
|
emit serviceReady(this);
|
2008-11-04 00:08:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void Service::setOperationEnabled(const QString &operation, bool enable)
|
|
|
|
{
|
|
|
|
if (!d->config || !d->config->hasGroup(operation)) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (enable) {
|
|
|
|
d->disabledOperations.remove(operation);
|
2008-12-11 03:47:11 +01:00
|
|
|
} else {
|
2008-11-04 00:08:39 +01:00
|
|
|
d->disabledOperations.insert(operation);
|
|
|
|
}
|
|
|
|
|
|
|
|
{
|
|
|
|
QHashIterator<QWidget *, QString> it(d->associatedWidgets);
|
|
|
|
while (it.hasNext()) {
|
|
|
|
it.next();
|
|
|
|
if (it.value() == operation) {
|
|
|
|
it.key()->setEnabled(enable);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
{
|
2012-04-27 17:02:18 +02:00
|
|
|
QHashIterator<QGraphicsObject *, QString> it(d->associatedGraphicsWidgets);
|
2008-11-04 00:08:39 +01:00
|
|
|
while (it.hasNext()) {
|
|
|
|
it.next();
|
|
|
|
if (it.value() == operation) {
|
|
|
|
it.key()->setEnabled(enable);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Service::isOperationEnabled(const QString &operation) const
|
|
|
|
{
|
|
|
|
return d->config && d->config->hasGroup(operation) && !d->disabledOperations.contains(operation);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Service::setOperationsScheme(QIODevice *xml)
|
|
|
|
{
|
|
|
|
delete d->config;
|
|
|
|
|
2009-08-02 20:24:20 +02:00
|
|
|
delete d->dummyConfig;
|
|
|
|
d->dummyConfig = 0;
|
|
|
|
|
2010-06-04 19:28:07 +02:00
|
|
|
KSharedConfigPtr c = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
|
2008-11-04 00:08:39 +01:00
|
|
|
d->config = new ConfigLoader(c, xml, this);
|
2008-11-21 02:26:43 +01:00
|
|
|
d->config->d->setWriteDefaults(true);
|
2008-11-04 00:08:39 +01:00
|
|
|
|
|
|
|
emit operationsChanged();
|
|
|
|
|
|
|
|
{
|
|
|
|
QHashIterator<QWidget *, QString> it(d->associatedWidgets);
|
|
|
|
while (it.hasNext()) {
|
|
|
|
it.next();
|
|
|
|
it.key()->setEnabled(d->config->hasGroup(it.value()));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
{
|
2012-04-27 17:02:18 +02:00
|
|
|
QHashIterator<QGraphicsObject *, QString> it(d->associatedGraphicsWidgets);
|
2008-11-04 00:08:39 +01:00
|
|
|
while (it.hasNext()) {
|
|
|
|
it.next();
|
|
|
|
it.key()->setEnabled(d->config->hasGroup(it.value()));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Service::registerOperationsScheme()
|
|
|
|
{
|
|
|
|
if (d->config) {
|
|
|
|
// we've already done our job. let's go home.
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (d->name.isEmpty()) {
|
|
|
|
kDebug() << "No name found";
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2010-08-06 05:42:26 +02:00
|
|
|
const QString path = KStandardDirs::locate("data", "plasma/services/" + d->name + ".operations");
|
2008-11-04 00:08:39 +01:00
|
|
|
|
|
|
|
if (path.isEmpty()) {
|
2009-01-04 19:12:27 +01:00
|
|
|
kDebug() << "Cannot find operations description:" << d->name << ".operations";
|
2008-11-04 00:08:39 +01:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
QFile file(path);
|
|
|
|
setOperationsScheme(&file);
|
|
|
|
}
|
|
|
|
|
|
|
|
} // namespace Plasma
|
|
|
|
|
|
|
|
#include "service.moc"
|
|
|
|
|