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

Last change on this file since 1168 was 846, checked in by Dmitry A. Kuminov, 14 years ago

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