1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the QtDBus module of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    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 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    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 ? 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