source: trunk/src/plugins/script/qtdbus/main.cpp@ 85

Last change on this file since 85 was 2, checked in by Dmitry A. Kuminov, 17 years ago

Initially imported qt-all-opensource-src-4.5.1 from Trolltech.
File size: 16.0 KB
Line 
1/****************************************************************************
2**
3** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
4** Contact: Qt Software Information ([email protected])
5**
6** This file is part of the plugins of the Qt Toolkit.
7**
8** $QT_BEGIN_LICENSE:LGPL$
9** Commercial Usage
10** Licensees holding valid Qt Commercial licenses may use this file in
11** accordance with the Qt Commercial License Agreement provided with the
12** Software or, alternatively, in accordance with the terms contained in
13** a written agreement between you and Nokia.
14**
15** GNU Lesser General Public License Usage
16** Alternatively, this file may be used under the terms of the GNU Lesser
17** General Public License version 2.1 as published by the Free Software
18** Foundation and appearing in the file LICENSE.LGPL included in the
19** packaging of this file. Please review the following information to
20** ensure the GNU Lesser General Public License version 2.1 requirements
21** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
22**
23** In addition, as a special exception, Nokia gives you certain
24** additional rights. These rights are described in the Nokia Qt LGPL
25** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
26** package.
27**
28** GNU General Public License Usage
29** Alternatively, this file may be used under the terms of the GNU
30** General Public License version 3.0 as published by the Free Software
31** Foundation and appearing in the file LICENSE.GPL included in the
32** packaging of this file. Please review the following information to
33** ensure the GNU General Public License version 3.0 requirements will be
34** met: http://www.gnu.org/copyleft/gpl.html.
35**
36** If you are unsure which license is appropriate for your use, please
37** contact the sales department at [email protected].
38** $QT_END_LICENSE$
39**
40****************************************************************************/
41
42#include "main.h"
43#include <QDebug>
44#include <QMetaMethod>
45#include <QScriptExtensionPlugin>
46
47QT_USE_NAMESPACE
48
49static QScriptValue setupDBusInterface(QScriptEngine *engine, QDBusAbstractInterface *iface);
50
51static QScriptValue do_dbus_call(QScriptContext *context, QScriptEngine *engine)
52{
53 int firstArgument = 0;
54 QString functionName = context->callee().property(QLatin1String("functionName")).toString();
55 if (functionName.isEmpty()) {
56 functionName = context->argument(0).toString();
57 ++firstArgument;
58 }
59
60 QScriptValue thisObject = context->thisObject();
61 QDBusAbstractInterface *iface = qobject_cast<QDBusAbstractInterface *>(thisObject.toQObject());
62 if (!iface)
63 return QScriptValue();
64
65 QDBusMessage msg = QDBusMessage::createMethodCall(iface->service(),
66 iface->path(),
67 iface->interface(),
68 functionName);
69
70 QList<QVariant> args;
71 for (int i = firstArgument; i < context->argumentCount(); ++i) {
72 args.append(context->argument(i).toVariant());
73 }
74 msg.setArguments(args);
75
76 msg = iface->connection().call(msg);
77
78 QScriptValue returnValue = engine->nullValue();
79 args = msg.arguments();
80 if (args.count() != 1)
81 return returnValue;
82
83 QVariant variant = args.first();
84 if (variant.type() == QVariant::UserType
85 && variant.userType() == qMetaTypeId<QDBusObjectPath>()) {
86 QDBusObjectPath path = qvariant_cast<QDBusObjectPath>(variant);
87
88 QDBusInterface *returnedIface = new QDBusInterface(iface->service(),
89 path.path(),
90 /*interface*/QString(),
91 iface->connection(),
92 engine);
93 returnValue = setupDBusInterface(engine, returnedIface);
94 } else {
95 returnValue = engine->newVariant(variant);
96 }
97
98 return returnValue;
99}
100
101static QScriptValue setupDBusInterface(QScriptEngine *engine, QDBusAbstractInterface *iface)
102{
103 QScriptValue v = engine->newQObject(iface);
104
105 if (!qobject_cast<QDBusConnectionInterface *>(iface)) {
106 const QMetaObject *mo = iface->metaObject();
107 for (int i = 0; i < mo->methodCount(); ++i) {
108 const QMetaMethod method = mo->method(i);
109 const QByteArray signature = method.signature();
110 //qDebug() << "signature" << signature;
111 int parenIndex = signature.indexOf('(');
112 if (parenIndex == -1)
113 continue;
114 const QByteArray name = signature.left(parenIndex);
115 if (name.isEmpty())
116 continue;
117
118 // don't try to override properties
119 if (mo->indexOfProperty(name) != -1)
120 continue;
121
122 QScriptValue callWrapper = engine->newFunction(do_dbus_call);
123 const QString nameString = QString::fromAscii(name);
124 callWrapper.setProperty(QLatin1String("functionName"), QScriptValue(engine, nameString));
125 v.setProperty(nameString, callWrapper);
126 }
127 }
128
129 v.setProperty(QLatin1String("service"), QScriptValue(engine, iface->service()), QScriptValue::ReadOnly);
130 v.setProperty(QLatin1String("path"), QScriptValue(engine, iface->path()), QScriptValue::ReadOnly);
131 v.setProperty(QLatin1String("interface"), QScriptValue(engine, iface->interface()), QScriptValue::ReadOnly);
132 v.setProperty(QLatin1String("isValid"), QScriptValue(engine, iface->isValid()), QScriptValue::ReadOnly);
133 v.setProperty(QLatin1String("connection"), engine->newQObject(new QScriptDBusConnection(iface->connection(), engine)), QScriptValue::ReadOnly);
134
135 return v;
136}
137
138QDBusConnectionConstructor::QDBusConnectionConstructor(QScriptEngine *engine, QScriptValue extensionObject)
139 : QObject(engine)
140{
141 QScriptValue ctor = engine->newQObject(this);
142
143 QScriptValue proto = engine->newQMetaObject(&QDBusConnection::staticMetaObject);
144 proto.setPrototype(engine->globalObject().property(QLatin1String("Function")).property(QLatin1String("prototype")));
145 ctor.setProperty(QLatin1String("prototype"), proto);
146
147 extensionObject.setProperty(QLatin1String("QDBusConnection"), ctor);
148}
149
150QScriptValue QDBusConnectionConstructor::sessionBus() const
151{
152 return engine()->newQObject(new QScriptDBusConnection(QDBusConnection::sessionBus(), engine()));
153}
154
155QScriptValue QDBusConnectionConstructor::systemBus() const
156{
157 return engine()->newQObject(new QScriptDBusConnection(QDBusConnection::systemBus(), engine()));
158}
159
160QObject *QDBusConnectionConstructor::qscript_call(const QString &name)
161{
162 return new QScriptDBusConnection(QDBusConnection(name), this);
163}
164
165void QDBusConnectionConstructor::disconnectFromBus(const QString &name)
166{
167 QDBusConnection::disconnectFromBus(name);
168}
169
170QDBusConnection QDBusConnectionConstructor::connectToBus(const QString &address, const QString &name)
171{
172 return QDBusConnection::connectToBus(address, name);
173}
174
175QDBusConnection QDBusConnectionConstructor::connectToBus(QDBusConnection::BusType type, const QString &name)
176{
177 return QDBusConnection::connectToBus(type, name);
178}
179
180QScriptDBusConnection::QScriptDBusConnection(const QDBusConnection &conn, QObject *parent)
181 : QObject(parent), connection(conn)
182{
183}
184
185QScriptValue QScriptDBusConnection::dbusInterface() const
186{
187 QDBusConnectionInterface *iface = connection.interface();
188 if (!iface)
189 return engine()->nullValue();
190 return setupDBusInterface(engine(), iface);
191}
192
193QScriptDBusInterfaceConstructor::QScriptDBusInterfaceConstructor(QScriptEngine *engine, QScriptValue extensionObject)
194{
195 QScriptValue ctorValue = engine->newQObject(this);
196 QScriptValue klass = engine->newQMetaObject(metaObject(), ctorValue);
197 extensionObject.setProperty(QLatin1String("QDBusInterface"), klass);
198}
199
200QScriptValue QScriptDBusInterfaceConstructor::qscript_call(const QString &service, const QString &path, const QString &interface,
201 const QScriptValue &conn)
202{
203 QDBusConnection connection = QDBusConnection::sessionBus();
204
205 QScriptDBusConnection *connWrapper = qobject_cast<QScriptDBusConnection *>(conn.toQObject());
206 if (connWrapper)
207 connection = connWrapper->dbusConnection();
208
209 return setupDBusInterface(engine(), new QDBusInterface(service, path, interface, connection, engine()));
210}
211
212QScriptDBusMessageConstructor::QScriptDBusMessageConstructor(QScriptEngine *engine, QScriptValue extensionObject)
213 : QObject(engine)
214{
215 proto = engine->newQMetaObject(metaObject(), engine->newQObject(this));
216
217 proto.setProperty(QLatin1String("createReply"), engine->newFunction(createReply));
218 proto.setProperty(QLatin1String("createErrorReply"), engine->newFunction(createErrorReply));
219
220 extensionObject.setProperty(QLatin1String("QDBusMessage"), proto);
221 engine->setDefaultPrototype(qMetaTypeId<QDBusMessage>(), proto);
222}
223
224QDBusMessage QScriptDBusMessageConstructor::createSignal(const QString &path, const QString &interface, const QString &name)
225{
226 return QDBusMessage::createSignal(path, interface, name);
227}
228
229QDBusMessage QScriptDBusMessageConstructor::createMethodCall(const QString &destination, const QString &path, const QString &interface, const QString &method)
230{
231 return QDBusMessage::createMethodCall(destination, path, interface, method);
232}
233
234QDBusMessage QScriptDBusMessageConstructor::createError(const QString &name, const QString &msg)
235{
236 return QDBusMessage::createError(name, msg);
237}
238
239static QScriptValue messageToScriptValue(QScriptEngine *engine, const QDBusMessage &message)
240{
241 QScriptValue v = engine->newVariant(QVariant::fromValue(message));
242 v.setProperty(QLatin1String("service"), QScriptValue(engine, message.service()), QScriptValue::ReadOnly);
243 v.setProperty(QLatin1String("path"), QScriptValue(engine, message.path()), QScriptValue::ReadOnly);
244 v.setProperty(QLatin1String("interface"), QScriptValue(engine, message.interface()), QScriptValue::ReadOnly);
245 v.setProperty(QLatin1String("member"), QScriptValue(engine, message.member()), QScriptValue::ReadOnly);
246 v.setProperty(QLatin1String("type"), QScriptValue(engine, message.type()), QScriptValue::ReadOnly);
247 v.setProperty(QLatin1String("signature"), QScriptValue(engine, message.signature()), QScriptValue::ReadOnly);
248 v.setProperty(QLatin1String("isReplyRequired"), QScriptValue(engine, message.isReplyRequired()), QScriptValue::ReadOnly);
249
250 v.setProperty(QLatin1String("delayedReply"), QScriptValue(engine, message.isDelayedReply()));
251 QScriptValue argValue = engine->newArray();
252 const QList<QVariant> args = message.arguments();
253 for (int i = 0; i < args.count(); ++i)
254 argValue.setProperty(QScriptValue(engine, i).toString(),
255 engine->newVariant(args.at(i)));
256
257 v.setProperty(QLatin1String("arguments"), argValue);
258
259 return v;
260}
261
262static void scriptValueToMessage(const QScriptValue &value, QDBusMessage &message)
263{
264 QVariant v = value.toVariant();
265 message = qvariant_cast<QDBusMessage>(v);
266 message.setDelayedReply(value.property(QLatin1String("delayedReply")).toBoolean());
267
268 QList<QVariant> args;
269 quint32 len = value.property(QLatin1String("length")).toUInt32();
270 for (quint32 i = 0; i < len; ++i) {
271 QScriptValue item = value.property(i);
272 args.append(item.toVariant());
273 }
274 message.setArguments(args);
275}
276
277QScriptValue QScriptDBusMessageConstructor::createReply(QScriptContext *context, QScriptEngine *engine)
278{
279 QDBusMessage msg;
280 scriptValueToMessage(context->thisObject(), msg);
281
282 QList<QVariant> args;
283 for (int i = 0; i < context->argumentCount(); ++i) {
284 QScriptValue value = context->argument(i);
285 args.append(value.toVariant());
286 }
287
288 return messageToScriptValue(engine, msg.createReply(args));
289}
290
291QScriptValue QScriptDBusMessageConstructor::createErrorReply(QScriptContext *context, QScriptEngine *engine)
292{
293 if (context->argumentCount() != 2)
294 return engine->nullValue();
295
296 QDBusMessage msg;
297 scriptValueToMessage(context->thisObject(), msg);
298
299 QString name = context->argument(0).toString();
300 QString errMsg = context->argument(1).toString();
301 return messageToScriptValue(engine, msg.createErrorReply(name, errMsg));
302}
303
304template <typename T>
305QScriptValue qDBusReplyToScriptValue(QScriptEngine *eng, const QDBusReply<T> &reply)
306{
307 return QScriptValue(eng, reply.value());
308}
309
310template <>
311QScriptValue qDBusReplyToScriptValue(QScriptEngine *eng, const QDBusReply<QStringList> &reply)
312{
313 QScriptValue v = eng->newArray();
314 const QStringList &lst = reply.value();
315 for (int i = 0; i < lst.count(); ++i)
316 v.setProperty(i, QScriptValue(eng, lst.at(i)));
317 return v;
318}
319
320template <typename T>
321void qDBusReplyFromScriptValue(const QScriptValue &, QDBusReply<T> &)
322{
323 // never called
324}
325
326QScriptValue qDBusErrorToScriptValue(QScriptEngine *engine, const QDBusError &error)
327{
328 QScriptValue v = engine->newObject();
329 v.setProperty(QLatin1String("type"), QScriptValue(engine, error.type()), QScriptValue::ReadOnly);
330 v.setProperty(QLatin1String("name"), QScriptValue(engine, error.name()), QScriptValue::ReadOnly);
331 v.setProperty(QLatin1String("message"), QScriptValue(engine, error.message()), QScriptValue::ReadOnly);
332 v.setProperty(QLatin1String("isValid"), QScriptValue(engine, error.isValid()), QScriptValue::ReadOnly);
333 return v;
334}
335
336void scriptValueToQDBusError(const QScriptValue &value, QDBusError &error)
337{
338 Q_UNUSED(value)
339 Q_UNUSED(error)
340 // never called
341}
342
343Q_DECLARE_METATYPE(QDBusReply<QString>)
344Q_DECLARE_METATYPE(QDBusReply<QStringList>)
345Q_DECLARE_METATYPE(QDBusReply<uint>)
346Q_DECLARE_METATYPE(QDBusReply<bool>)
347Q_DECLARE_METATYPE(QDBusReply<QDBusConnectionInterface::RegisterServiceReply>)
348Q_DECLARE_METATYPE(QDBusError)
349
350class QtDBusScriptPlugin : public QScriptExtensionPlugin
351{
352public:
353 QStringList keys() const;
354 void initialize(const QString &key, QScriptEngine *engine);
355};
356
357QStringList QtDBusScriptPlugin::keys() const
358{
359 return QStringList(QLatin1String("qt.dbus"));
360}
361
362void QtDBusScriptPlugin::initialize(const QString &key, QScriptEngine *engine)
363{
364 if (key != QLatin1String("qt.dbus")) {
365 Q_ASSERT_X(false, "initialize", qPrintable(key));
366 return;
367 }
368
369 QScriptValue extensionObject = engine->globalObject();
370
371 qScriptRegisterMetaType<QDBusReply<QString> >(engine, qDBusReplyToScriptValue, qDBusReplyFromScriptValue);
372 qScriptRegisterMetaType<QDBusReply<QStringList> >(engine, qDBusReplyToScriptValue, qDBusReplyFromScriptValue);
373 qScriptRegisterMetaType<QDBusReply<uint> >(engine, qDBusReplyToScriptValue, qDBusReplyFromScriptValue);
374 qScriptRegisterMetaType<QDBusReply<bool> >(engine, qDBusReplyToScriptValue, qDBusReplyFromScriptValue);
375 qScriptRegisterMetaType<QDBusReply<QDBusConnectionInterface::RegisterServiceReply> >(engine, qDBusReplyToScriptValue, qDBusReplyFromScriptValue);
376 qScriptRegisterMetaType<QDBusMessage>(engine, messageToScriptValue, scriptValueToMessage);
377 qScriptRegisterMetaType<QDBusError>(engine, qDBusErrorToScriptValue, scriptValueToQDBusError);
378
379 QScriptValue connIfaceProto = engine->newQMetaObject(&QDBusConnectionInterface::staticMetaObject, engine->nullValue());
380 extensionObject.setProperty(QLatin1String("QDBusConnectionInterface"), connIfaceProto);
381
382 QScriptValue qdbus = engine->newObject();
383 qdbus.setProperty(QLatin1String("NoBlock"), QScriptValue(engine, QDBus::NoBlock));
384 qdbus.setProperty(QLatin1String("Block"), QScriptValue(engine, QDBus::Block));
385 qdbus.setProperty(QLatin1String("BlockWithGui"), QScriptValue(engine, QDBus::BlockWithGui));
386 qdbus.setProperty(QLatin1String("AutoDetect"), QScriptValue(engine, QDBus::AutoDetect));
387 engine->globalObject().setProperty(QLatin1String("QDBus"), qdbus);
388
389 (void)new QDBusConnectionConstructor(engine, extensionObject);
390 (void)new QScriptDBusInterfaceConstructor(engine, extensionObject);
391 (void)new QScriptDBusMessageConstructor(engine, extensionObject);
392}
393
394
395Q_EXPORT_STATIC_PLUGIN(QtDBusScriptPlugin)
396Q_EXPORT_PLUGIN2(qtscriptdbus, QtDBusScriptPlugin)
Note: See TracBrowser for help on using the repository browser.