|
|
| (57 intermediate revisions by 17 users not shown) |
| Line 1: |
Line 1: |
| {{TutorialBrowser|
| | This tutorial was updated and moved to https://develop.kde.org/docs/features/d-bus/accessing_dbus_interfaces/ |
|
| |
|
| series=D-Bus|
| | [[Category:MovedDevelop]] |
| | |
| name=Accessing D-Bus Interfaces|
| |
| | |
| pre=[[../Introduction_To_D-Bus|Introduction To D-Bus]]|
| |
| | |
| next=[[../Creating_D-Bus_Interfaces|Creating D-Bus Interfaces]]|
| |
| | |
| }}
| |
| | |
| == Abstract ==
| |
| | |
| D-Bus allows applications to expose internal API to the outside world. These APIs can then be accessed at run-time via the D-Bus protocol using command line applications or D-Bus libraries and bindings themselves. This tutorial looks at the latter method with examples that you can use in your applications.
| |
| | |
| == Using QDBusMessage ==
| |
| | |
| {{qt|QDBusMessage}} represents a D-Bus messages that can be sent or has been received over a given bus. Each message is one of five types, depending on the purpose of the message:
| |
| * method call
| |
| * signal
| |
| * reply
| |
| * error
| |
| * invalid
| |
| An enumeration covering each of these possibilities is defined in {{qt|QDBusMessage}}. A message's type can be access via the <tt>{{qt|QDBusMessage}}::type()</tt> method.
| |
| | |
| === Calling a D-Bus Method ===
| |
| | |
| A {{qt|QDBusMessage}} can be used directly to call methods in D-Bus services using the <tt>{{qt|QDbusMessage}}::createMethod( const QString & service, const QString & path, const QString & interface, const QString & method )</tt> static method. It returns a {{qt|QDBusMessage}} object that you can then use to make the call.
| |
| | |
| The <tt>interface</tt> parameter is optional and only necessary if the method to be called is not unique in the accessed object address by the <tt>path</tt>. This can happen with the object implements multiple interfaces and those interfaces have methods with the same name. In such (rare) cases, if you do not define the interface to use there is not guarantee as to which method will actually get called. However, usually you can simply pass an empty string (e.g. <tt>""</tt>) as the argument for <tt>interface</tt>.
| |
| | |
| By way of example, to access the (fictional) <tt>ping</tt> method on the {{path|/network}} object in the <tt>org.foo.bar</tt> service, one might do this:
| |
| | |
| <code cppqt n>QDBusMessage m = QDBusMessage::createMessage("org.foo.bar",
| |
| "/network",
| |
| "",
| |
| "ping");
| |
| bool queued = QDBusConnection::sessionBus()->send(m);</code>
| |
| | |
| In line 5 of the above example we queue the message for sending on the current session bus. We get a <tt>bool</tt> returned letting us know if the queuing was successful or not.
| |
| | |
| This leaves us with two questions, however:
| |
| * How can one set parameters for a method call?
| |
| * How can one get a return message in the case of D-Bus methods that have a return value?
| |
| | |
| === Setting Parameters ===
| |
| | |
| Sending arguments along with the method call is quite straight forward. First we need to create a {{qt|QList}} of {{qt|QVariant}} objects and then add those to our dbus message. So if the <tt>ping</tt> method in the above took a hostname as a parameter, we might alter the code in this way (note lines 5 through 7):
| |
| | |
| <code cppqt n>QDBusMessage m = QDBusMessage::createMessage("org.foo.bar",
| |
| "/network",
| |
| "",
| |
| "ping");
| |
| QList<QVariant> args;
| |
| args.append("kde.org");
| |
| m.setArguments(args);
| |
| bool queued = QDBusConnection::sessionBus()->send(m);</code>
| |
| | |
| {{note|The arguments must appear in the {{qt|QList}} in the same order they are expected by the D-Bus method being called.}}
| |
| | |
| === Getting Replies ===
| |
| | |
| If we wish to actually receive information back from the D-Bus method, we use the <tt>{{qt|QDBusConnect}}::call</tt> method instead. It will block until there is a reply or the call times out. If our <tt>ping</tt> method returned information on the host we provided in the arguments above, we might alter our code to look like this:
| |
| | |
| | |
| <code cppqt n>QDBusMessage m = QDBusMessage::createMessage("org.foo.bar",
| |
| "/network",
| |
| "",
| |
| "ping");
| |
| QList<QVariant> args;
| |
| args.append("kde.org");
| |
| m.setArguments(args);
| |
| QDBusMessage response = QDBusConnection::sessionBus()->call(m);</code>
| |
| | |
| The <tt>response</tt> will be either of type <tt>QDBusMessage::ReplyMessage</tt> or <tt>QDBusMessage::ErrorMessage</tt> depending on whether it was successful or not. We can look through the values returned by retreving the arguments with the <tt>{{qt|QDBusMessage}}::arguments()</tt> method which returns a <tt>{{qt|QList}}<{{qt|QVariant}}></tt>.
| |
| | |
| === Is This The Best Way? ===
| |
| | |
| Using QDBusMessage directly in this way to invoke remote D-Bus methods is not the easiest, best or even recommend way of doing things. Next we will look at the more convnient {{qt|QDBusInterface}} class and then look at accessing remote D-Bus interfaces as if they were local methods using a class auto-generated from the XML D-Bus interface description.
| |
| | |
| == Using QDBusInterface ==
| |
| | |
| {{qt|QDBusInterface}} provides a simple and direct method to make D-Bus calls and connect to D-Bus signals.
| |
| | |
| A {{qt|QDBusInterface}} object represents a given D-Bus interface. The constructor accepts as parameters (in order) a service name, an object path, an optional interface and optionally which bus (e.g. system or session) to use. If no bus is explicitly define, it defaults to the session bus.
| |
| | |
| As {{qt|QDBusInterface}} is a QObject, you can also pass it a parent object. This helps simplify the bookkeeping associated with creating new {{qt|QDBusInterface}} objects by letting Qt clean up for you when the parent object is deleted.
| |
| | |
| Here is an example of {{qt|QDBusInterface}} usage which we will then step through line by line:
| |
| | |
| <code cppqt n>
| |
| QString hostname("kde.org");
| |
| QDBusConnection bus = QDBusConnection::sessionBus();
| |
| QDBusInterface interface = new QDBusInterface("org.foo.bar",
| |
| "/network",
| |
| QString(),
| |
| bus,
| |
| this);
| |
| | |
| interface->call("ping");
| |
| interface->call("ping", hostname);
| |
| | |
| QList<QVariant> args;
| |
| args.append("kde.org");
| |
| interface->callWithArgumentList("ping", args);
| |
| | |
| QDBusReply<int> reply = interface->call("ping",
| |
| hostname);
| |
| if (reply.isValid())
| |
| {
| |
| KMessageBox::information(winId(),
| |
| i18n("Ping to %1 took %2s")
| |
| .arg(hostname)
| |
| .arg(reply.value()),
| |
| i18n("Pinging %1")
| |
| .arg(hostname));
| |
| }
| |
| | |
| args.clear();
| |
| interface->callWithCallback("listInterfaces", args,
| |
| this,
| |
| SLOT(interfaceList(QDBusReply));
| |
| | |
| connect(interface, SIGNAL(interfaceUp(QString)),
| |
| this, SLOT(interfaceUp(QString)));
| |
| </code>
| |
| | |
| === Synchronous Calls ===
| |
| | |
| The first thing we did was create a {{qt|QDBusInterface}} that represents the same object we were accessing in the QDBusMessage examples above. We then call several D-Bus methods on that object using a few different techniques. On line 7 we make a simple call to a method called <tt>ping</tt> without any arguments. Then, on line 8, we call the same method but with a parameter. Note that we didn't have to create a <tt>{{qt|QList}}<{{qt|QVariant}}></tt> for the arguments. We can pass up to 8 arguments to a D-Bus method this way.
| |
| | |
| If we need to pass more than 8 arguments or for some other reason a <tt>{{qt|QList}}<{{qt|QVariant}}></tt> is simply a better approach for the circumstances, then you may use the <tt>callWithArgumentList</tt> method instead as seen on lines 19-21 above.
| |
| | |
| | |
| === Handling Replies ===
| |
| | |
| On line 10 we took the reply from a D-Bus method
| |
| | |
| === Asynchronous Method Calls and Signals ===
| |
| | |
| Up to this point in the example all of the calls made were synchronous and the application would block until a reply was received. The last two uses of {{qt|QDBusInterface}} in the example show asynchronous usage of D-Bus, and in both cases we rely on Qt's signal and slot mechanism.
| |
| | |
| On line 24 we use <tt>callWithCallback</tt> and provide a regular QObject slot to be called when the D-Bus reply returns. This way the application will not block as <tt>callWithCallback</tt> returns immediately after queueing the message to be sent on the bus. Later, the <tt>interfaceList</tt> slot would get called.
| |
| | |
| == Using Classes Generated From D-Bus XML ==
| |
| | |
| == Connecting To Signals ==
| |
| | |
| == Other Resources ==
| |
| | |
| [[Category:C++]] | |
