File::~File()
{
if (m_fd != -1)
{
if (m_pipe)
asyncCall(pclose, m_pipe);
else
asyncCall(::_close, m_fd);
}
}
Variant ClientBase::call(ObjectID id, const string &name, const Variant &args,
bool withResult, float timeout, FutureResultPtr &written)
{
if(asyncMode())
return asyncCall(id, name, args, withResult, timeout, written);
return syncCall(id, name, args, withResult);
}
mysql::~mysql()
{
if (m_conn)
{
asyncCall(close_conn, m_conn);
m_conn = NULL;
}
}
QDBusPendingReply<quint32> OrgFreedesktopNotificationsInterface::notify(const QString & appName, quint32 replacesId,
const QString & appIcon,
const QString & summary, const QString & body,
const QStringList & actions,
const QVariantMap & hints,
qint32 timeout)
{
return asyncCall("Notify", appName, replacesId, appIcon, summary, body, actions, hints, timeout);
}
/// Calls the Unsubscribe function over DBus asynchronously.
void SubscriberInterface::unsubscribe(QSet<QString> keys)
{
if (isValid() && keys.size() != 0) {
// Construct the asynchronous call
QStringList keyList = keys.toList();
asyncCall("Unsubscribe", keyList);
// The possible errors are not tracked, because we can't do anything if Unsubscribe fails.
}
}
MongoCursor::~MongoCursor()
{
m_query.Reset();
asyncCall(mongo_cursor_destroy, m_cursor);
if (m_bInit)
bson_destroy(&m_bbq);
bson_destroy(&m_bbp);
}
void QNetworkManagerInterface::activateConnection(QDBusObjectPath connectionPath,
QDBusObjectPath devicePath,
QDBusObjectPath specificObject)
{
QDBusPendingCall pendingCall = asyncCall(QLatin1String("ActivateConnection"),
QVariant::fromValue(connectionPath),
QVariant::fromValue(devicePath),
QVariant::fromValue(specificObject));
QDBusPendingCallWatcher *callWatcher = new QDBusPendingCallWatcher(pendingCall);
connect(callWatcher, SIGNAL(finished(QDBusPendingCallWatcher*)),
this, SIGNAL(activationFinished(QDBusPendingCallWatcher*)));
}
QNetworkManagerInterfaceDeviceWireless::QNetworkManagerInterfaceDeviceWireless(const QString &ifaceDevicePath, QObject *parent)
: QDBusAbstractInterface(QLatin1String(NM_DBUS_SERVICE),
ifaceDevicePath,
NM_DBUS_INTERFACE_DEVICE_WIRELESS,
QDBusConnection::systemBus(), parent)
{
if (!isValid()) {
return;
}
interfacePath = ifaceDevicePath;
QDBusPendingReply<QList <QDBusObjectPath> > nmReply
= call(QLatin1String("GetAccessPoints"));
if (!nmReply.isError()) {
accessPointsList = nmReply.value();
}
PropertiesDBusInterface deviceWirelessPropertiesInterface(QLatin1String(NM_DBUS_SERVICE),
interfacePath,
DBUS_PROPERTIES_INTERFACE,
QDBusConnection::systemBus(),parent);
QList<QVariant> argumentList;
argumentList << QLatin1String(NM_DBUS_INTERFACE_DEVICE_WIRELESS);
QDBusPendingReply<QVariantMap> propsReply
= deviceWirelessPropertiesInterface.callWithArgumentList(QDBus::Block,QLatin1String("GetAll"),
argumentList);
if (!propsReply.isError()) {
propertyMap = propsReply.value();
}
QDBusConnection::systemBus().connect(QLatin1String(NM_DBUS_SERVICE),
interfacePath,
QLatin1String(NM_DBUS_INTERFACE_DEVICE_WIRELESS),
QLatin1String("PropertiesChanged"),
this,SLOT(propertiesSwap(QMap<QString,QVariant>)));
QDBusPendingReply<QList<QDBusObjectPath> > reply
= asyncCall(QLatin1String("GetAccessPoints"));
QDBusPendingCallWatcher *callWatcher = new QDBusPendingCallWatcher(reply);
connect(callWatcher, SIGNAL(finished(QDBusPendingCallWatcher*)),
this, SLOT(accessPointsFinished(QDBusPendingCallWatcher*)));
}
static std::function<void(Args...)>
make(v8::Local<v8::Function> func)
{
Nan::HandleScope scope;
auto pfunc(std::make_shared<Nan::Persistent<v8::Function>>(func));
return
[pfunc](Args&&... args)
{
packed_args_type packed{ std::forward<Args>(args)... };
asyncCall(
[pfunc, packed(std::move(packed))]() mutable
{
Nan::HandleScope scope;
callNode(Nan::New(*pfunc), std::move(packed),
typename gens<sizeof...(Args)>::type());
});
};
}
/// Calls the Subscribe function over DBus asynchronously.
void SubscriberInterface::subscribe(QSet<QString> keys)
{
contextDebug() << "SubscriberInterface::subscribe";
// FIXME contextDebug() << "SubscriberInterface::subscribe " << keys;
if (isValid() == false || keys.size() == 0) {
contextDebug() << "Subscriber cannot subscribe -> emitting subscribeFinished()";
Q_EMIT subscribeFinished(keys.toList());
return;
}
// Construct the asynchronous call
QStringList keyList = keys.toList();
QDBusPendingCall subscribeCall = asyncCall("Subscribe", keyList);
SafeDBusPendingCallWatcher *watcher = new SafeDBusPendingCallWatcher(subscribeCall, this);
sconnect(watcher, SIGNAL(finished(QDBusPendingCallWatcher *)),
this, SLOT(onSubscribeFinished(QDBusPendingCallWatcher *)));
// When the pending call returns, we need to know the keys we
// tried to subscribe to.
watcher->setProperty("keysToSubscribe", keyList);
}
SQLite::~SQLite()
{
if (m_db)
asyncCall(sqlite3_close, m_db);
}
void QNetworkManagerInterfaceDeviceWireless::requestScan()
{
asyncCall(QLatin1String("RequestScan"));
}
void QNetworkManagerInterface::deactivateConnection(QDBusObjectPath connectionPath)
{
asyncCall(QLatin1String("DeactivateConnection"), QVariant::fromValue(connectionPath));
}
QDBusPendingReply<QString, QString, QString> OrgFreedesktopNotificationsInterface::getServerInformation()
{
return asyncCall("GetServerInformation");
}
QDBusPendingReply<> OrgFreedesktopNotificationsInterface::closeNotification(quint32 id)
{
return asyncCall("CloseNotification", id);
}
QDBusPendingReply<QStringList> OrgFreedesktopNotificationsInterface::getCapabilities()
{
return asyncCall("GetCapabilities");
}
