long long PlatformUdisks::getSize(const QString &devicePath) { long long ret; QDBusConnection connection = QDBusConnection::systemBus(); QDBusMessage message; QList<QVariant> args; args << "org.freedesktop.UDisks"; args << "DeviceSize"; message = QDBusMessage::createMethodCall("org.freedesktop.UDisks", devicePath, "org.freedesktop.DBus.Properties", "Get"); message.setArguments(args); QDBusReply<QDBusVariant> reply = connection.call(message); if (!reply.isValid()) return(0); ret = reply.value().variant().toLongLong(); return(ret); }
bool DBusComm::sendDBusRegister() { QDBusMessage reply = positioningdProxy->call("registerListener", myService.toLatin1().constData(), myPath.toLatin1().constData()); if (reply.type() == QDBusMessage::ReplyMessage) { QList<QVariant> values = reply.arguments(); clientId = values.takeFirst().toInt(); quint32 m = values.takeFirst().toUInt(); availablePositioningMethods = (QGeoPositionInfoSource::PositioningMethod) m; minimumUpdateInterval = values.takeFirst().toUInt(); } else { cerr << endl << "DBus error:\n"; cerr << reply.errorName().toLatin1().constData() << endl; cerr << reply.errorMessage().toLatin1().constData() << endl; return false; } return true; }
/*! \since 4.6 Creates a QDBusPendingCall object based on the message \a msg. The message must be of type QDBusMessage::ErrorMessage or QDBusMessage::ReplyMessage (that is, a message that is typical of a completed call). This function is useful for code that requires simulating a pending call, but that has already finished. \sa fromError() */ QDBusPendingCall QDBusPendingCall::fromCompletedCall(const QDBusMessage &msg) { QDBusPendingCallPrivate *d = 0; if (msg.type() == QDBusMessage::ErrorMessage || msg.type() == QDBusMessage::ReplyMessage) { d = new QDBusPendingCallPrivate(QDBusMessage(), 0); d->replyMessage = msg; } return QDBusPendingCall(d); }
void ServiceListener::slotDBusSignal( const QDBusMessage& message ) { odebug << "ConnMan: " << message.member() << oendl; if( message.member() == "PropertyChanged" ) { QString prop = message[0].toString(); if( prop == "State" ) { QString oldState = m_state; QString newState = message[1].toVariant().value.toString(); if( oldState != newState ) { emit serviceStateChanged( QDBusObjectPath( QCString( m_proxy->path() )), oldState, newState ); m_state = newState; sendSignalStrength(); } } else if( prop == "Strength" ) { m_strength = message[1].toVariant().value.toByte(); sendSignalStrength(); } } }
void FdoNotifyPlugin::dbusCapabiltiesReplyReceived( const QDBusMessage& reply ) { if ( reply.type() != QDBusMessage::ReplyMessage ) { tDebug( LOGVERBOSE ) << Q_FUNC_INFO << "Did not receive a ReplyMessage"; } const QStringList &list = reply.arguments().at( 0 ).toStringList(); QListIterator<QString> iter( list ); while ( iter.hasNext() ) { QString capabilty = iter.next(); if ( capabilty.compare( "body-markup" ) == 0 ) { m_wmSupportsBodyMarkup = true; break; } } }
//Callback (slot) used to retrieve subscribed event information void DBusInterface::dispatchEvent(const QDBusMessage& message) { // unpack event QString eventReceivedName= message.arguments().at(1).value<QString>(); Values eventReceivedValues = dBusMessagetoValues(message,2); // find and trigger matching callback if( callbacks.count(eventReceivedName) > 0) { callbacks[eventReceivedName](eventReceivedValues); } }
void QBluetoothPasskeyAgent_Private::Confirm(const QString &path, const QString &address, const QString &value, const QDBusMessage &msg) { QString devname = path.mid(11); QBluetoothAddress addr(address); msg.setDelayedReply(true); QDBusMessage reply; if (m_parent->confirmPasskey(devname, addr, value)) { reply = msg.createReply(); } else { reply = msg.createErrorReply("org.bluez.Error.Rejected", "Rejected"); } QDBusConnection::systemBus().send(reply); }
void AgentAdaptor::RequestInput(const QDBusObjectPath &service_path, const QVariantMap &fields, const QDBusMessage &message) { QVariantMap json; Q_FOREACH (const QString &key, fields.keys()){ QVariantMap payload = qdbus_cast<QVariantMap>(fields[key]); json.insert(key, payload); } message.setDelayedReply(true); ServiceRequestData *reqdata = new ServiceRequestData; reqdata->objectPath = service_path.path(); reqdata->fields = json; reqdata->reply = message.createReply(); reqdata->msg = message; m_userAgent->requestUserInput(reqdata); }
QList<Job::Ptr> SystemdPrivate::listJobs() { QList<Job::Ptr> jobs; qDBusRegisterMetaType<ManagerDBusJob>(); qDBusRegisterMetaType<ManagerDBusJobList>(); QDBusPendingReply<ManagerDBusJobList> reply = isdface.ListJobs(); reply.waitForFinished(); if (reply.isError()) { qDebug() << reply.error().message(); } else { const QDBusMessage message = reply.reply(); if (message.type() == QDBusMessage::ReplyMessage) { const ManagerDBusJobList queued = qdbus_cast<ManagerDBusJobList>(message.arguments().first()); Q_FOREACH(const ManagerDBusJob job, queued) { jobs.append(Job::Ptr(new Job(job.path.path()), &QObject::deleteLater)); } } }
QString SettingsUi::readDaemonVersion() { QDBusInterface getDaemonVersionCall("com.kimmoli.tohkbd2", "/", "com.kimmoli.tohkbd2", QDBusConnection::systemBus()); getDaemonVersionCall.setTimeout(2000); QDBusMessage getDaemonVersionReply = getDaemonVersionCall.call(QDBus::AutoDetect, "getVersion"); if (getDaemonVersionReply.type() == QDBusMessage::ErrorMessage) { qDebug() << "Error reading daemon version:" << getDaemonVersionReply.errorMessage(); return QString("N/A"); } QString daemonVersion = getDaemonVersionReply.arguments().at(0).toString(); qDebug() << "Daemon version is" << daemonVersion; return daemonVersion; }
QList<Systemd::Job*> Systemd::SystemdPrivate::listJobs() { qDBusRegisterMetaType<ManagerDBusJob>(); qDBusRegisterMetaType<ManagerDBusJobList>(); QDBusPendingReply<ManagerDBusJobList> reply = isdface.ListJobs(); reply.waitForFinished(); if (reply.isError()) { qDebug() << reply.error().message(); return QList<Systemd::Job*>(); } QList<Systemd::Job*> queued; const QDBusMessage message = reply.reply(); if (message.type() == QDBusMessage::ReplyMessage) { const ManagerDBusJobList jobs = qdbus_cast<ManagerDBusJobList>(message.arguments().first()); Q_FOREACH(const ManagerDBusJob job, jobs) { queued.append(new Systemd::Job(job.path.path())); } }
bool PlatformUdisks::getIsDrive(const QString &path) { bool ret; QDBusConnection connection = QDBusConnection::systemBus(); QDBusMessage message; QList<QVariant> args; args << "org.freedesktop.UDisks"; args << "DeviceIsDrive"; message = QDBusMessage::createMethodCall("org.freedesktop.UDisks", path, "org.freedesktop.DBus.Properties", "Get"); message.setArguments(args); QDBusReply<QDBusVariant> reply = connection.call(message); if (!reply.isValid()) return(false); ret = reply.value().variant().toBool(); return(ret); }
QVariant DBusResponseWaiter::waitForReply(QVariant variant) const { if (QDBusPendingCall* call = const_cast<QDBusPendingCall*>(extractPendingCall(variant))) { call->waitForFinished(); if (call->isError()) { qWarning() << "error:" << call->error(); return QVariant("error"); } QDBusMessage reply = call->reply(); if (reply.arguments().count() > 0) { return reply.arguments().at(0); } } return QVariant(); }
bool PlatformUdisks::isUSB(const QString &udiskPath) { QDBusConnection connection = QDBusConnection::systemBus(); QDBusMessage message; QList<QVariant> args; args << "org.freedesktop.UDisks"; args << "DriveConnectionInterface"; message = QDBusMessage::createMethodCall("org.freedesktop.UDisks", udiskPath, "org.freedesktop.DBus.Properties", "Get"); message.setArguments(args); QDBusReply<QDBusVariant> reply = connection.call(message); if (!reply.isValid()) return false; if (reply.value().variant().toString() == "usb") return true; else return false; }
void DbusAdapter::_mitakuuluuMessageReceived(QDBusMessage msg) { qDebug() << "Mitakuuluu messageReceived:" << msg; QDBusArgument *arg = (QDBusArgument *) msg.arguments().at(0).data(); if (arg->currentType() == QDBusArgument::MapType) { QMap<QString, QString> argMap = unpackMessage(*arg); qDebug() << "Extracted argument map:" << argMap; emit commhistoryd(argMap.value("author"), argMap.value("message")); } }
void DeviceHandler::slotAsyncReply( int callId, const QDBusMessage& reply ) { QString method = m_calls[callId]; if (reply.type() == QDBusMessage::ReplyMessage) { odebug << "********* " << m_devProxy->interface() << " " << method << " success" << oendl; if( m_pool ) { if( reply.count() > 0 ) m_pool->handlerSuccess( this, method, reply[0].toString() ); else m_pool->handlerSuccess( this, method, QString::null ); } } else if (reply.type() == QDBusMessage::ErrorMessage) { odebug << "********* " << m_devProxy->interface() << " " << method << " fail: " << reply.error().name() << ": " << reply.error().message() << oendl; if( m_pool ) m_pool->handlerError( this, method, reply.error().name(), reply.error().message() ); } m_calls.remove(callId); }
// Create DBus connection with the interface ch.epfl.mobots.AsebaNetwork DBusInterface::DBusInterface() : bus(QDBusConnection::sessionBus()), callbacks({}), dbusMainInterface("ch.epfl.mobots.Aseba", "/", "ch.epfl.mobots.AsebaNetwork",bus) { checkConnection(); // setup event filter QDBusMessage eventfilterMessage = dbusMainInterface.call("CreateEventFilter"); QDBusObjectPath eventfilterPath = eventfilterMessage.arguments().at(0).value<QDBusObjectPath>(); eventfilterInterface = new QDBusInterface("ch.epfl.mobots.Aseba", eventfilterPath.path(), "ch.epfl.mobots.EventFilter",bus); if(!bus.connect("ch.epfl.mobots.Aseba", eventfilterPath.path(), "ch.epfl.mobots.EventFilter", "Event", this, SLOT(dispatchEvent(const QDBusMessage&)))) { qDebug() << "failed to connect eventfilter signal to dispatchEvent slot!"; } }
void FdoNotifyPlugin::notifyUser( const QString& messageText ) { QDBusMessage message = QDBusMessage::createMethodCall( "org.freedesktop.Notifications", "/org/freedesktop/Notifications", "org.freedesktop.Notifications", "Notify" ); QList<QVariant> arguments; arguments << QString( "Tomahawk" ); //app_name arguments << quint32( 0 ); //notification_id arguments << QString(); //app_icon arguments << QString( "Tomahawk" ); //summary arguments << QString( messageText ); //body arguments << QStringList(); //actions QVariantMap dict; dict["desktop-entry"] = QString( "tomahawk" ); dict[ "image_data" ] = ImageConverter::variantForImage( QImage( RESPATH "icons/tomahawk-icon-512x512.png" ).scaledToHeight( getNotificationIconHeight() ) ); arguments << dict; //hints arguments << qint32( -1 ); //expire_timeout message.setArguments( arguments ); QDBusConnection::sessionBus().send( message ); }
bool tst_QDBusPerformance::executeTest(const char *funcname, int size, const QVariant &data) { QElapsedTimer timer; int callCount = 0; qint64 transferred = 0; timer.start(); while (timer.elapsed() < runTime) { QDBusMessage reply = target->call(funcname, data); if (reply.type() != QDBusMessage::ReplyMessage) return false; transferred += size; ++callCount; } qDebug() << transferred << "bytes in" << timer.elapsed() << "ms" << "(in" << callCount << "calls):" << (transferred * 1000.0 / timer.elapsed() / 1024 / 1024) << "MB/s"; return true; }
int main() { QDBusMessage myDBusMessage; //! [0] QList<QVariant> arguments; arguments << QVariant(42) << QVariant::fromValue(QDBusVariant(43)) << QVariant("hello"); myDBusMessage.setArguments(arguments); //! [0] //! [1] // call a D-Bus function that returns a D-Bus variant QVariant v = callMyDBusFunction(); // retrieve the D-Bus variant QDBusVariant dbusVariant = qvariant_cast<QDBusVariant>(v); // retrieve the actual value stored in the D-Bus variant QVariant result = dbusVariant.variant(); //! [1] return 0; }
KIO::DropJob* DragAndDropHelper::dropUrls(const QUrl& destUrl, QDropEvent* event, QWidget* window) { const QMimeData* mimeData = event->mimeData(); if (mimeData->hasFormat("application/x-kde-ark-dndextract-service") && mimeData->hasFormat("application/x-kde-ark-dndextract-path")) { const QString remoteDBusClient = mimeData->data("application/x-kde-ark-dndextract-service"); const QString remoteDBusPath = mimeData->data("application/x-kde-ark-dndextract-path"); QDBusMessage message = QDBusMessage::createMethodCall(remoteDBusClient, remoteDBusPath, "org.kde.ark.DndExtract", "extractSelectedFilesTo"); message.setArguments({destUrl.toDisplayString(QUrl::PreferLocalFile)}); QDBusConnection::sessionBus().call(message); } else { // Drop into a directory or a desktop-file KIO::DropJob *job = KIO::drop(event, destUrl); KJobWidgets::setWindow(job, window); return job; } return 0; }
void AsebaNetworkInterface::SetVariable(const QString& node, const QString& variable, const Values& data, const QDBusMessage &message) const { // make sure the node exists NodesNamesMap::const_iterator nodeIt(nodesNames.find(node)); if (nodeIt == nodesNames.end()) { DBusConnectionBus().send(message.createErrorReply(QDBusError::InvalidArgs, QString("node %0 does not exists").arg(node))); return; } const unsigned nodeId(nodeIt.value()); unsigned pos(unsigned(-1)); // check whether variable is user-defined const UserDefinedVariablesMap::const_iterator userVarMapIt(userDefinedVariablesMap.find(node)); if (userVarMapIt != userDefinedVariablesMap.end()) { const VariablesMap& userVarMap(userVarMapIt.value()); const VariablesMap::const_iterator userVarIt(userVarMap.find(variable.toStdWString())); if (userVarIt != userVarMap.end()) { pos = userVarIt->second.first; } } // if variable is not user-defined, check whether it is provided by this node if (pos == unsigned(-1)) { bool ok; pos = getVariablePos(nodeId, variable.toStdWString(), &ok); if (!ok) { DBusConnectionBus().send(message.createErrorReply(QDBusError::InvalidArgs, QString("variable %0 does not exists in node %1").arg(variable).arg(node))); return; } } SetVariables msg(nodeId, pos, toAsebaVector(data)); hub->sendMessage(msg); }
void FdoNotifyPlugin::pushInfo( QString caller, Tomahawk::InfoSystem::InfoType type, QVariant pushData ) { Q_UNUSED( caller ); qDebug() << Q_FUNC_INFO; if ( type != Tomahawk::InfoSystem::InfoNotifyUser || !pushData.canConvert< QVariantMap >() ) { qDebug() << Q_FUNC_INFO << " not the right type or could not convert the hash"; return; } QVariantMap hash = pushData.value< QVariantMap >(); if ( !hash.contains( "message" ) ) { qDebug() << Q_FUNC_INFO << " hash did not contain a message"; return; } QDBusMessage message = QDBusMessage::createMethodCall( "org.freedesktop.Notifications", "/org/freedesktop/Notifications", "org.freedesktop.Notifications", "Notify" ); QList<QVariant> arguments; arguments << QString( "Tomahawk" ); //app_name arguments << quint32( 0 ); //notification_id arguments << QString(); //app_icon arguments << QString( "Tomahawk" ); //summary arguments << hash["message"].toString(); //body arguments << QStringList(); //actions QVariantMap dict; dict["desktop-entry"] = QString( "tomahawk" ); if ( hash.contains( "image" ) ) { QVariant tempVariant = hash["image"]; QImage tempImage = tempVariant.value< QImage >(); dict["image_data"] = ImageConverter::variantForImage( tempImage ); } else dict["image_data"] = ImageConverter::variantForImage( QImage( RESPATH "icons/tomahawk-icon-128x128.png" ) ); arguments << dict; //hints arguments << qint32( -1 ); //expire_timeout message.setArguments( arguments ); QDBusConnection::sessionBus().send( message ); }
static QDBusMessage propertyWriteReply(const QDBusMessage &msg, const QString &interface_name, const QByteArray &property_name, int status) { switch (status) { case PropertyNotFound: return propertyNotFoundError(msg, interface_name, property_name); case PropertyTypeMismatch: return msg.createErrorReply(QDBusError::InvalidArgs, QString::fromLatin1("Invalid arguments for writing to property %1%2%3") .arg(interface_name, QString::fromLatin1(interface_name.isEmpty() ? "" : "."), QString::fromLatin1(property_name))); case PropertyWriteFailed: return msg.createErrorReply(QDBusError::InternalError, QString::fromLatin1("Internal error")); case PropertyWriteSuccess: return msg.createReply(); } Q_ASSERT_X(false, "", "Should not be reached"); return QDBusMessage(); }
bool PlatformUdisks2::doUnmount(const QString &partitionPath) { bool ret = true; QDBusConnection connection = QDBusConnection::systemBus(); QList<QVariant> args; QVariantMap map; args << map; QDBusMessage message = QDBusMessage::createMethodCall("org.freedesktop.UDisks2", partitionPath, "org.freedesktop.UDisks2.Filesystem", "Unmount"); message.setArguments(args); QDBusMessage reply = connection.call(message); if (reply.type() == QDBusMessage::ErrorMessage) { QMessageBox msgBox; msgBox.setText(QString("DBUS error (%1): %2").arg(partitionPath).arg(reply.errorMessage())); msgBox.exec(); ret = false; } return(ret); }
void DeviceInterface::DisconnectProfile(const QString &uuid, const QDBusMessage &msg) { if (!uuids().contains(uuid)) { QDBusMessage error = msg.createErrorReply(QStringLiteral("org.bluez.Error.DoesNotExist"), QStringLiteral("Profile UUID not supported")); QDBusConnection::sessionBus().send(error); return; } if (!m_connectedUuids.contains(uuid)) { QDBusMessage error = msg.createErrorReply(QStringLiteral("org.bluez.Error.NotConnected"), QStringLiteral("Profile not connected")); QDBusConnection::sessionBus().send(error); return; } if (uuid == MediaPlayerUuid) { disconnectMediaPlayer(); } else { Q_UNIMPLEMENTED(); } Object::changeProperty(QStringLiteral("Connected"), false); }
void UserAgent::requestConnect(const QDBusMessage &msg) { QList<QVariant> arguments2; arguments2 << QVariant("Clear"); requestMessage = msg.createReply(arguments2); QList<QVariant> arguments; arguments << QVariant(connectionRequestType()); QDBusMessage error = msg.createReply(arguments); if (!QDBusConnection::systemBus().send(error)) { qWarning() << "Could not queue message"; } if (connectionRequestType() == "Suppress") { return; } Q_EMIT connectionRequest(); Q_EMIT userConnectRequested(msg); setConnectionRequestType("Suppress"); }
bool QDBusConnection::send(const QDBusMessage &message) const { if (!d || !d->connection) return false; DBusMessage *msg = message.toDBusMessage(); if (!msg) return false; bool isOk = dbus_connection_send(d->connection, msg, 0); dbus_message_unref(msg); return isOk; }
void SavedNetworksList::loadNetworks() { savedNetworks.clear(); QDBusMessage m = savedInterface->call(QDBus::Block, "ListConnections"); QDBusArgument knownNetworks = m.arguments().first().value<QDBusArgument>(); knownNetworks.beginArray(); while (!knownNetworks.atEnd()) { QDBusObjectPath o; knownNetworks >> o; QDBusMessage settingsMessage = QDBusMessage::createMethodCall("org.freedesktop.NetworkManager", o.path(), "org.freedesktop.NetworkManager.Settings.Connection", "GetSettings"); QDBusArgument settingsArg = QDBusConnection::systemBus().call(settingsMessage).arguments().first().value<QDBusArgument>(); QMap<QString, QVariantMap> settings; settingsArg >> settings; Setting s; QVariantMap connectionSettings = settings.value("connection"); s.path = o; s.name = connectionSettings.value("id").toString(); if (connectionSettings.value("type") == "802-3-ethernet") { s.NetworkType = Setting::Wired; } else if (connectionSettings.value("type") == "802-11-wireless") { s.NetworkType = Setting::Wireless; } else if (connectionSettings.value("type") == "bluetooth") { s.NetworkType = Setting::Bluetooth; } else if (connectionSettings.value("type") == "vpn") { s.NetworkType = Setting::VPN; } else if (connectionSettings.value("type") == "gsm" || connectionSettings.value("type") == "cdma") { s.NetworkType = Setting::Mobile; } else { s.NetworkType = Setting::Unknown; } savedNetworks.append(s); } knownNetworks.endArray(); this->dataChanged(this->index(0), this->index(this->rowCount())); }
/*! Client side property call that directly accesses properties through the DBus interface. Read and reset have special hardcoded DBus methods due to the nature of QtDBus properties without an adaptor class incorrectly forwarding the metacall type */ QVariant ObjectEndPoint::invokeRemoteProperty(int metaIndex, const QVariant& arg, int /*returnType*/, QMetaObject::Call c ) { Q_ASSERT(d->endPointType == ObjectEndPoint::Client); const QMetaObject *imeta = service->metaObject(); QMetaProperty property = imeta->property(metaIndex); if (c == QMetaObject::WriteProperty) { // Writing property, direct property DBus call if (!iface->setProperty(property.name(), arg)) { qWarning() << "Service property write call failed"; } } else if (c == QMetaObject::ResetProperty) { // Resetting property, direct special method DBus call QVariantList args; args << QVariant(property.name()); QDBusMessage msg = iface->callWithArgumentList(QDBus::Block, "propertyReset", args); if (msg.type() == QDBusMessage::InvalidMessage) { qWarning() << "Service property reset call failed"; } } else if (c == QMetaObject::ReadProperty) { // Reading property, direct special method DBus call QVariantList args; args << QVariant(property.name()); QDBusMessage msg = iface->callWithArgumentList(QDBus::Block, "propertyRead", args); if (msg.type() == QDBusMessage::ReplyMessage) { QVariantList retList = msg.arguments(); return retList[0]; } else { qWarning() << "Service property read call failed"; } } else { qWarning() << "Invalid property call"; } return QVariant(); }