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();
}
