| 1 | /****************************************************************************
|
|---|
| 2 | **
|
|---|
| 3 | ** Copyright (C) 2009 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 QtDBus module 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 <QtCore/qmetaobject.h>
|
|---|
| 43 | #include <QtCore/qstringlist.h>
|
|---|
| 44 |
|
|---|
| 45 | #include "qdbusinterface_p.h" // for ANNOTATION_NO_WAIT
|
|---|
| 46 | #include "qdbusabstractadaptor_p.h" // for QCLASSINFO_DBUS_*
|
|---|
| 47 | #include "qdbusconnection_p.h" // for the flags
|
|---|
| 48 | #include "qdbusmetatype_p.h"
|
|---|
| 49 | #include "qdbusmetatype.h"
|
|---|
| 50 | #include "qdbusutil_p.h"
|
|---|
| 51 |
|
|---|
| 52 | QT_BEGIN_NAMESPACE
|
|---|
| 53 |
|
|---|
| 54 | extern QDBUS_EXPORT QString qDBusGenerateMetaObjectXml(QString interface, const QMetaObject *mo,
|
|---|
| 55 | const QMetaObject *base, int flags);
|
|---|
| 56 |
|
|---|
| 57 | static inline QString typeNameToXml(const char *typeName)
|
|---|
| 58 | {
|
|---|
| 59 | // ### copied from qtextdocument.cpp
|
|---|
| 60 | // ### move this into QtCore at some point
|
|---|
| 61 | QString plain = QLatin1String(typeName);
|
|---|
| 62 | QString rich;
|
|---|
| 63 | rich.reserve(int(plain.length() * 1.1));
|
|---|
| 64 | for (int i = 0; i < plain.length(); ++i) {
|
|---|
| 65 | if (plain.at(i) == QLatin1Char('<'))
|
|---|
| 66 | rich += QLatin1String("<");
|
|---|
| 67 | else if (plain.at(i) == QLatin1Char('>'))
|
|---|
| 68 | rich += QLatin1String(">");
|
|---|
| 69 | else if (plain.at(i) == QLatin1Char('&'))
|
|---|
| 70 | rich += QLatin1String("&");
|
|---|
| 71 | else
|
|---|
| 72 | rich += plain.at(i);
|
|---|
| 73 | }
|
|---|
| 74 | return rich;
|
|---|
| 75 | }
|
|---|
| 76 |
|
|---|
| 77 | // implement the D-Bus org.freedesktop.DBus.Introspectable interface
|
|---|
| 78 | // we do that by analysing the metaObject of all the adaptor interfaces
|
|---|
| 79 |
|
|---|
| 80 | static QString generateInterfaceXml(const QMetaObject *mo, int flags, int methodOffset, int propOffset)
|
|---|
| 81 | {
|
|---|
| 82 | QString retval;
|
|---|
| 83 |
|
|---|
| 84 | // start with properties:
|
|---|
| 85 | if (flags & (QDBusConnection::ExportScriptableProperties |
|
|---|
| 86 | QDBusConnection::ExportNonScriptableProperties)) {
|
|---|
| 87 | for (int i = propOffset; i < mo->propertyCount(); ++i) {
|
|---|
| 88 | static const char *accessvalues[] = {0, "read", "write", "readwrite"};
|
|---|
| 89 |
|
|---|
| 90 | QMetaProperty mp = mo->property(i);
|
|---|
| 91 |
|
|---|
| 92 | if (!((mp.isScriptable() && (flags & QDBusConnection::ExportScriptableProperties)) ||
|
|---|
| 93 | (!mp.isScriptable() && (flags & QDBusConnection::ExportNonScriptableProperties))))
|
|---|
| 94 | continue;
|
|---|
| 95 |
|
|---|
| 96 | int access = 0;
|
|---|
| 97 | if (mp.isReadable())
|
|---|
| 98 | access |= 1;
|
|---|
| 99 | if (mp.isWritable())
|
|---|
| 100 | access |= 2;
|
|---|
| 101 |
|
|---|
| 102 | int typeId = qDBusNameToTypeId(mp.typeName());
|
|---|
| 103 | if (!typeId)
|
|---|
| 104 | continue;
|
|---|
| 105 | const char *signature = QDBusMetaType::typeToSignature(typeId);
|
|---|
| 106 | if (!signature)
|
|---|
| 107 | continue;
|
|---|
| 108 |
|
|---|
| 109 | retval += QString::fromLatin1(" <property name=\"%1\" type=\"%2\" access=\"%3\"")
|
|---|
| 110 | .arg(QLatin1String(mp.name()))
|
|---|
| 111 | .arg(QLatin1String(signature))
|
|---|
| 112 | .arg(QLatin1String(accessvalues[access]));
|
|---|
| 113 |
|
|---|
| 114 | if (QDBusMetaType::signatureToType(signature) == QVariant::Invalid) {
|
|---|
| 115 | const char *typeName = QVariant::typeToName(QVariant::Type(typeId));
|
|---|
| 116 | retval += QString::fromLatin1(">\n <annotation name=\"com.trolltech.QtDBus.QtTypeName\" value=\"%3\"/>\n </property>\n")
|
|---|
| 117 | .arg(typeNameToXml(typeName));
|
|---|
| 118 | } else {
|
|---|
| 119 | retval += QLatin1String("/>\n");
|
|---|
| 120 | }
|
|---|
| 121 | }
|
|---|
| 122 | }
|
|---|
| 123 |
|
|---|
| 124 | // now add methods:
|
|---|
| 125 | for (int i = methodOffset; i < mo->methodCount(); ++i) {
|
|---|
| 126 | QMetaMethod mm = mo->method(i);
|
|---|
| 127 | QByteArray signature = mm.signature();
|
|---|
| 128 | int paren = signature.indexOf('(');
|
|---|
| 129 |
|
|---|
| 130 | bool isSignal;
|
|---|
| 131 | if (mm.methodType() == QMetaMethod::Signal)
|
|---|
| 132 | // adding a signal
|
|---|
| 133 | isSignal = true;
|
|---|
| 134 | else if (mm.methodType() == QMetaMethod::Slot && mm.access() == QMetaMethod::Public)
|
|---|
| 135 | isSignal = false;
|
|---|
| 136 | else
|
|---|
| 137 | continue; // neither signal nor public slot
|
|---|
| 138 |
|
|---|
| 139 | if (isSignal && !(flags & (QDBusConnection::ExportScriptableSignals |
|
|---|
| 140 | QDBusConnection::ExportNonScriptableSignals)))
|
|---|
| 141 | continue; // we're not exporting any signals
|
|---|
| 142 | if (!isSignal && !(flags & (QDBusConnection::ExportScriptableSlots |
|
|---|
| 143 | QDBusConnection::ExportNonScriptableSlots)))
|
|---|
| 144 | continue; // we're not exporting any slots
|
|---|
| 145 |
|
|---|
| 146 | QString xml = QString::fromLatin1(" <%1 name=\"%2\">\n")
|
|---|
| 147 | .arg(isSignal ? QLatin1String("signal") : QLatin1String("method"))
|
|---|
| 148 | .arg(QLatin1String(signature.left(paren)));
|
|---|
| 149 |
|
|---|
| 150 | // check the return type first
|
|---|
| 151 | int typeId = qDBusNameToTypeId(mm.typeName());
|
|---|
| 152 | if (typeId) {
|
|---|
| 153 | const char *typeName = QDBusMetaType::typeToSignature(typeId);
|
|---|
| 154 | if (typeName) {
|
|---|
| 155 | xml += QString::fromLatin1(" <arg type=\"%1\" direction=\"out\"/>\n")
|
|---|
| 156 | .arg(typeNameToXml(typeName));
|
|---|
| 157 |
|
|---|
| 158 | // do we need to describe this argument?
|
|---|
| 159 | if (QDBusMetaType::signatureToType(typeName) == QVariant::Invalid)
|
|---|
| 160 | xml += QString::fromLatin1(" <annotation name=\"com.trolltech.QtDBus.QtTypeName.Out0\" value=\"%1\"/>\n")
|
|---|
| 161 | .arg(typeNameToXml(mm.typeName()));
|
|---|
| 162 | } else
|
|---|
| 163 | continue;
|
|---|
| 164 | }
|
|---|
| 165 | else if (*mm.typeName())
|
|---|
| 166 | continue; // wasn't a valid type
|
|---|
| 167 |
|
|---|
| 168 | QList<QByteArray> names = mm.parameterNames();
|
|---|
| 169 | QList<int> types;
|
|---|
| 170 | int inputCount = qDBusParametersForMethod(mm, types);
|
|---|
| 171 | if (inputCount == -1)
|
|---|
| 172 | continue; // invalid form
|
|---|
| 173 | if (isSignal && inputCount + 1 != types.count())
|
|---|
| 174 | continue; // signal with output arguments?
|
|---|
| 175 | if (isSignal && types.at(inputCount) == QDBusMetaTypeId::message)
|
|---|
| 176 | continue; // signal with QDBusMessage argument?
|
|---|
| 177 | if (isSignal && mm.attributes() & QMetaMethod::Cloned)
|
|---|
| 178 | continue; // cloned signal?
|
|---|
| 179 |
|
|---|
| 180 | int j;
|
|---|
| 181 | bool isScriptable = mm.attributes() & QMetaMethod::Scriptable;
|
|---|
| 182 | for (j = 1; j < types.count(); ++j) {
|
|---|
| 183 | // input parameter for a slot or output for a signal
|
|---|
| 184 | if (types.at(j) == QDBusMetaTypeId::message) {
|
|---|
| 185 | isScriptable = true;
|
|---|
| 186 | continue;
|
|---|
| 187 | }
|
|---|
| 188 |
|
|---|
| 189 | QString name;
|
|---|
| 190 | if (!names.at(j - 1).isEmpty())
|
|---|
| 191 | name = QString::fromLatin1("name=\"%1\" ").arg(QLatin1String(names.at(j - 1)));
|
|---|
| 192 |
|
|---|
| 193 | bool isOutput = isSignal || j > inputCount;
|
|---|
| 194 |
|
|---|
| 195 | const char *signature = QDBusMetaType::typeToSignature(types.at(j));
|
|---|
| 196 | xml += QString::fromLatin1(" <arg %1type=\"%2\" direction=\"%3\"/>\n")
|
|---|
| 197 | .arg(name)
|
|---|
| 198 | .arg(QLatin1String(signature))
|
|---|
| 199 | .arg(isOutput ? QLatin1String("out") : QLatin1String("in"));
|
|---|
| 200 |
|
|---|
| 201 | // do we need to describe this argument?
|
|---|
| 202 | if (QDBusMetaType::signatureToType(signature) == QVariant::Invalid) {
|
|---|
| 203 | const char *typeName = QVariant::typeToName( QVariant::Type(types.at(j)) );
|
|---|
| 204 | xml += QString::fromLatin1(" <annotation name=\"com.trolltech.QtDBus.QtTypeName.%1%2\" value=\"%3\"/>\n")
|
|---|
| 205 | .arg(isOutput ? QLatin1String("Out") : QLatin1String("In"))
|
|---|
| 206 | .arg(isOutput && !isSignal ? j - inputCount : j - 1)
|
|---|
| 207 | .arg(typeNameToXml(typeName));
|
|---|
| 208 | }
|
|---|
| 209 | }
|
|---|
| 210 |
|
|---|
| 211 | int wantedMask;
|
|---|
| 212 | if (isScriptable)
|
|---|
| 213 | wantedMask = isSignal ? QDBusConnection::ExportScriptableSignals
|
|---|
| 214 | : QDBusConnection::ExportScriptableSlots;
|
|---|
| 215 | else
|
|---|
| 216 | wantedMask = isSignal ? QDBusConnection::ExportNonScriptableSignals
|
|---|
| 217 | : QDBusConnection::ExportNonScriptableSlots;
|
|---|
| 218 | if ((flags & wantedMask) != wantedMask)
|
|---|
| 219 | continue;
|
|---|
| 220 |
|
|---|
| 221 | if (qDBusCheckAsyncTag(mm.tag()))
|
|---|
| 222 | // add the no-reply annotation
|
|---|
| 223 | xml += QLatin1String(" <annotation name=\"" ANNOTATION_NO_WAIT "\""
|
|---|
| 224 | " value=\"true\"/>\n");
|
|---|
| 225 |
|
|---|
| 226 | retval += xml;
|
|---|
| 227 | retval += QString::fromLatin1(" </%1>\n")
|
|---|
| 228 | .arg(isSignal ? QLatin1String("signal") : QLatin1String("method"));
|
|---|
| 229 | }
|
|---|
| 230 |
|
|---|
| 231 | return retval;
|
|---|
| 232 | }
|
|---|
| 233 |
|
|---|
| 234 | QString qDBusGenerateMetaObjectXml(QString interface, const QMetaObject *mo,
|
|---|
| 235 | const QMetaObject *base, int flags)
|
|---|
| 236 | {
|
|---|
| 237 | if (interface.isEmpty())
|
|---|
| 238 | // generate the interface name from the meta object
|
|---|
| 239 | interface = qDBusInterfaceFromMetaObject(mo);
|
|---|
| 240 |
|
|---|
| 241 | QString xml;
|
|---|
| 242 | int idx = mo->indexOfClassInfo(QCLASSINFO_DBUS_INTROSPECTION);
|
|---|
| 243 | if (idx >= mo->classInfoOffset())
|
|---|
| 244 | return QString::fromUtf8(mo->classInfo(idx).value());
|
|---|
| 245 | else
|
|---|
| 246 | xml = generateInterfaceXml(mo, flags, base->methodCount(), base->propertyCount());
|
|---|
| 247 |
|
|---|
| 248 | if (xml.isEmpty())
|
|---|
| 249 | return QString(); // don't add an empty interface
|
|---|
| 250 | return QString::fromLatin1(" <interface name=\"%1\">\n%2 </interface>\n")
|
|---|
| 251 | .arg(interface, xml);
|
|---|
| 252 | }
|
|---|
| 253 | #if 0
|
|---|
| 254 | QString qDBusGenerateMetaObjectXml(QString interface, const QMetaObject *mo, const QMetaObject *base,
|
|---|
| 255 | int flags)
|
|---|
| 256 | {
|
|---|
| 257 | if (interface.isEmpty()) {
|
|---|
| 258 | // generate the interface name from the meta object
|
|---|
| 259 | int idx = mo->indexOfClassInfo(QCLASSINFO_DBUS_INTERFACE);
|
|---|
| 260 | if (idx >= mo->classInfoOffset()) {
|
|---|
| 261 | interface = QLatin1String(mo->classInfo(idx).value());
|
|---|
| 262 | } else {
|
|---|
| 263 | interface = QLatin1String(mo->className());
|
|---|
| 264 | interface.replace(QLatin1String("::"), QLatin1String("."));
|
|---|
| 265 |
|
|---|
| 266 | if (interface.startsWith(QLatin1String("QDBus"))) {
|
|---|
| 267 | interface.prepend(QLatin1String("com.trolltech.QtDBus."));
|
|---|
| 268 | } else if (interface.startsWith(QLatin1Char('Q')) &&
|
|---|
| 269 | interface.length() >= 2 && interface.at(1).isUpper()) {
|
|---|
| 270 | // assume it's Qt
|
|---|
| 271 | interface.prepend(QLatin1String("com.trolltech.Qt."));
|
|---|
| 272 | } else if (!QCoreApplication::instance()||
|
|---|
| 273 | QCoreApplication::instance()->applicationName().isEmpty()) {
|
|---|
| 274 | interface.prepend(QLatin1String("local."));
|
|---|
| 275 | } else {
|
|---|
| 276 | interface.prepend(QLatin1Char('.')).prepend(QCoreApplication::instance()->applicationName());
|
|---|
| 277 | QStringList domainName =
|
|---|
| 278 | QCoreApplication::instance()->organizationDomain().split(QLatin1Char('.'),
|
|---|
| 279 | QString::SkipEmptyParts);
|
|---|
| 280 | if (domainName.isEmpty())
|
|---|
| 281 | interface.prepend(QLatin1String("local."));
|
|---|
| 282 | else
|
|---|
| 283 | for (int i = 0; i < domainName.count(); ++i)
|
|---|
| 284 | interface.prepend(QLatin1Char('.')).prepend(domainName.at(i));
|
|---|
| 285 | }
|
|---|
| 286 | }
|
|---|
| 287 | }
|
|---|
| 288 |
|
|---|
| 289 | QString xml;
|
|---|
| 290 | int idx = mo->indexOfClassInfo(QCLASSINFO_DBUS_INTROSPECTION);
|
|---|
| 291 | if (idx >= mo->classInfoOffset())
|
|---|
| 292 | return QString::fromUtf8(mo->classInfo(idx).value());
|
|---|
| 293 | else
|
|---|
| 294 | xml = generateInterfaceXml(mo, flags, base->methodCount(), base->propertyCount());
|
|---|
| 295 |
|
|---|
| 296 | if (xml.isEmpty())
|
|---|
| 297 | return QString(); // don't add an empty interface
|
|---|
| 298 | return QString::fromLatin1(" <interface name=\"%1\">\n%2 </interface>\n")
|
|---|
| 299 | .arg(interface, xml);
|
|---|
| 300 | }
|
|---|
| 301 |
|
|---|
| 302 | #endif
|
|---|
| 303 |
|
|---|
| 304 | QT_END_NAMESPACE
|
|---|
