QBluetoothLocalDevice::QBluetoothLocalDevice(const QBluetoothAddress &address, QObject *parent)
: QObject(parent)
{
OrgBluezManagerInterface manager(QLatin1String("org.bluez"), QLatin1String("/"),
QDBusConnection::systemBus());
QDBusPendingReply<QList<QDBusObjectPath> > reply = manager.ListAdapters();
reply.waitForFinished();
if (reply.isError())
return;
foreach (const QDBusObjectPath &path, reply.value()) {
OrgBluezAdapterInterface *adapter = new OrgBluezAdapterInterface(QLatin1String("org.bluez"),
path.path(),
QDBusConnection::systemBus());
QDBusPendingReply<QVariantMap> reply = adapter->GetProperties();
reply.waitForFinished();
if (reply.isError())
continue;
QBluetoothAddress path_address(reply.value().value(QLatin1String("Address")).toString());
if(path_address == address){
this->d_ptr = new QBluetoothLocalDevicePrivate;
this->d_ptr->adapter = adapter;
break;
}
else {
delete adapter;
}
}
}
QList<QBluetoothHostInfo> QBluetoothLocalDevice::allDevices()
{
QList<QBluetoothHostInfo> localDevices;
OrgBluezManagerInterface manager(QLatin1String("org.bluez"), QLatin1String("/"),
QDBusConnection::systemBus());
QDBusPendingReply<QList<QDBusObjectPath> > reply = manager.ListAdapters();
reply.waitForFinished();
if (reply.isError())
return localDevices;
foreach (const QDBusObjectPath &path, reply.value()) {
QBluetoothHostInfo hostinfo;
OrgBluezAdapterInterface adapter(QLatin1String("org.bluez"), path.path(),
QDBusConnection::systemBus());
QDBusPendingReply<QVariantMap> reply = adapter.GetProperties();
reply.waitForFinished();
if (reply.isError())
continue;
hostinfo.setAddress(QBluetoothAddress(reply.value().value(QLatin1String("Address")).toString()));
hostinfo.setName(reply.value().value(QLatin1String("Name")).toString());
localDevices.append(hostinfo);
}
return localDevices;
}
void LogTest::findEventsTest()
{
QZeitgeist::DataModel::Event event;
QZeitgeist::DataModel::EventList events;
// Set the template to search for.
event.setActor("app://firefox.desktop");
event.setSubjects(QZeitgeist::DataModel::SubjectList());
// Add to the event list.
events << event;
// Query for all events since Epoch.
QZeitgeist::DataModel::TimeRange timeRange =
QZeitgeist::DataModel::TimeRange::timeRangeToNow();
// Search on Zeitgeist.
QDBusPendingReply<QZeitgeist::DataModel::EventList> reply =
m_log->findEvents(timeRange, events,
QZeitgeist::Log::Any, 10,
QZeitgeist::Log::MostRecentEvents);
// Block and wait for reply.
reply.waitForFinished();
// Check if the return is valid.
QVERIFY (reply.isValid() == true);
// Check if the return is not empty
QVERIFY (reply.value().size() > 0);
// Check if the id is 0;
for (uint i = 0; i < reply.value().size(); ++i)
QVERIFY(reply.value()[i].id() != 0);
}
int QOfonoLocationReporting::request()
{
if (d_ptr->ofonoLocationReporting) {
QDBusPendingReply<QDBusUnixFileDescriptor> reply = d_ptr->ofonoLocationReporting->Request();
if (!reply.isError() && reply.value().isValid()) {
return dup(reply.value().fileDescriptor()); //pass on fd
} else {
qDebug() << Q_FUNC_INFO << reply.error().message();
}
}
return 0;
}
void QBluetoothDeviceDiscoveryAgentPrivate::startBluez5()
{
Q_Q(QBluetoothDeviceDiscoveryAgent);
bool ok = false;
const QString adapterPath = findAdapterForAddress(m_adapterAddress, &ok);
if (!ok || adapterPath.isEmpty()) {
qCWarning(QT_BT_BLUEZ) << "Cannot find Bluez 5 adapter for device search" << ok;
lastError = QBluetoothDeviceDiscoveryAgent::InputOutputError;
errorString = QBluetoothDeviceDiscoveryAgent::tr("Cannot find valid Bluetooth adapter.");
q->error(lastError);
return;
}
adapterBluez5 = new OrgBluezAdapter1Interface(QStringLiteral("org.bluez"),
adapterPath,
QDBusConnection::systemBus());
if (!adapterBluez5->powered()) {
qCDebug(QT_BT_BLUEZ) << "Aborting device discovery due to offline Bluetooth Adapter";
lastError = QBluetoothDeviceDiscoveryAgent::PoweredOffError;
errorString = QBluetoothDeviceDiscoveryAgent::tr("Device is powered off");
delete adapterBluez5;
adapterBluez5 = 0;
emit q->error(lastError);
return;
}
QtBluezDiscoveryManager::instance()->registerDiscoveryInterest(adapterBluez5->path());
QObject::connect(QtBluezDiscoveryManager::instance(), SIGNAL(discoveryInterrupted(QString)),
q, SLOT(_q_discoveryInterrupted(QString)));
// collect initial set of information
QDBusPendingReply<ManagedObjectList> reply = managerBluez5->GetManagedObjects();
reply.waitForFinished();
if (!reply.isError()) {
foreach (const QDBusObjectPath &path, reply.value().keys()) {
const InterfaceList ifaceList = reply.value().value(path);
foreach (const QString &iface, ifaceList.keys()) {
if (iface == QStringLiteral("org.bluez.Device1")) {
if (path.path().indexOf(adapterBluez5->path()) != 0)
continue; //devices whose path doesn't start with same path we skip
deviceFoundBluez5(path.path());
}
}
}
}
QString QBluetoothSocketPrivate::peerName() const
{
quint64 bdaddr;
if (socketType == QBluetoothServiceInfo::RfcommProtocol) {
sockaddr_rc addr;
socklen_t addrLength = sizeof(addr);
if (::getpeername(socket, reinterpret_cast<sockaddr *>(&addr), &addrLength) < 0)
return QString();
convertAddress(addr.rc_bdaddr.b, bdaddr);
} else if (socketType == QBluetoothServiceInfo::L2capProtocol) {
sockaddr_l2 addr;
socklen_t addrLength = sizeof(addr);
if (::getpeername(socket, reinterpret_cast<sockaddr *>(&addr), &addrLength) < 0)
return QString();
convertAddress(addr.l2_bdaddr.b, bdaddr);
} else {
qCWarning(QT_BT_BLUEZ) << "peerName() called on socket of unknown type";
return QString();
}
const QString peerAddress = QBluetoothAddress(bdaddr).toString();
const QString localAdapter = localAddress().toString();
if (isBluez5()) {
OrgFreedesktopDBusObjectManagerInterface manager(QStringLiteral("org.bluez"),
QStringLiteral("/"),
QDBusConnection::systemBus());
QDBusPendingReply<ManagedObjectList> reply = manager.GetManagedObjects();
reply.waitForFinished();
if (reply.isError())
return QString();
foreach (const QDBusObjectPath &path, reply.value().keys()) {
const InterfaceList ifaceList = reply.value().value(path);
foreach (const QString &iface, ifaceList.keys()) {
if (iface == QStringLiteral("org.bluez.Device1")) {
if (ifaceList.value(iface).value(QStringLiteral("Address")).toString()
== peerAddress)
return ifaceList.value(iface).value(QStringLiteral("Alias")).toString();
}
}
}
return QString();
} else {
void SnorePlugin::Freedesktop::slotNotify(Snore::Notification noti)
{
if (noti.data()->sourceAndTargetAreSimilar(this)) {
return;
}
QStringList actions;
foreach(int k, noti.actions().keys()) {
actions << QString::number(k) << noti.actions()[k].name();
}
QVariantMap hints;
FreedesktopImageHint image(noti.icon().pixmap(QSize(128, 128)).toImage());
hints.insert(QStringLiteral("image_data"), QVariant::fromValue(image));
char urgency = 1;
if (noti.priority() < 0) {
urgency = 0;
} else if (noti.priority() > 2) {
urgency = 2;
}
hints.insert(QStringLiteral("urgency"), urgency);
if (noti.application().constHints().contains("desktop-entry")) {
hints.insert(QStringLiteral("desktop-entry"), noti.application().constHints().value("desktop-entry"));
}
hints.insert(QStringLiteral("suppress-sound"), noti.constHints().value("silent").toBool());
uint updateId = 0;
if (noti.isUpdate()) {
updateId = noti.old().hints().privateValue(this, "id").toUInt();
m_dbusIdMap.take(updateId);
}
QString title = noti.application().name() + QLatin1String(" - ") + noti.title(m_supportsRichtext ? Snore::Utils::AllMarkup : Snore::Utils::NoMarkup);
QString body(noti.text(m_supportsRichtext ? Snore::Utils::AllMarkup : Snore::Utils::NoMarkup));
//TODO: add app icon hint?
QDBusPendingReply<uint> id = m_interface->Notify(noti.application().name(), updateId, QString(), title,
body, actions, hints, noti.isSticky() ? -1 : noti.timeout() * 1000);
id.waitForFinished();
noti.hints().setPrivateValue(this, "id", id.value());
m_dbusIdMap[id.value()] = noti;
slotNotificationDisplayed(noti);
qCDebug(SNORE) << noti.id() << "|" << id.value();
}
void QBluetoothLocalDevicePrivate::initializeAdapter()
{
if (adapter)
return;
OrgBluezManagerInterface manager(QLatin1String("org.bluez"), QLatin1String("/"), QDBusConnection::systemBus());
if (localAddress == QBluetoothAddress()) {
QDBusPendingReply<QDBusObjectPath> reply = manager.DefaultAdapter();
reply.waitForFinished();
if (reply.isError())
return;
adapter = new OrgBluezAdapterInterface(QLatin1String("org.bluez"), reply.value().path(), QDBusConnection::systemBus());
} else {
QDBusPendingReply<QList<QDBusObjectPath> > reply = manager.ListAdapters();
reply.waitForFinished();
if (reply.isError())
return;
foreach (const QDBusObjectPath &path, reply.value()) {
OrgBluezAdapterInterface *tmpAdapter = new OrgBluezAdapterInterface(QLatin1String("org.bluez"), path.path(), QDBusConnection::systemBus());
QDBusPendingReply<QVariantMap> reply = tmpAdapter->GetProperties();
reply.waitForFinished();
if (reply.isError())
continue;
QBluetoothAddress path_address(reply.value().value(QLatin1String("Address")).toString());
if (path_address == localAddress) {
adapter = tmpAdapter;
break;
} else {
delete tmpAdapter;
}
}
}
currentMode = static_cast<QBluetoothLocalDevice::HostMode>(-1);
if (adapter) {
connect(adapter, SIGNAL(PropertyChanged(QString,QDBusVariant)), SLOT(PropertyChanged(QString,QDBusVariant)));
qsrand(QTime::currentTime().msec());
agent_path = agentPath;
agent_path.append(QString::fromLatin1("/%1").arg(qrand()));
}
}
QNetworkManagerInterfaceDeviceModem::QNetworkManagerInterfaceDeviceModem(const QString &ifaceDevicePath, QObject *parent)
: QDBusAbstractInterface(QLatin1String(NM_DBUS_SERVICE),
ifaceDevicePath,
NM_DBUS_INTERFACE_DEVICE_MODEM,
QDBusConnection::systemBus(), parent)
{
if (!isValid()) {
return;
}
PropertiesDBusInterface deviceModemPropertiesInterface(QLatin1String(NM_DBUS_SERVICE),
ifaceDevicePath,
QLatin1String("org.freedesktop.DBus.Properties"),
QDBusConnection::systemBus(),parent);
QList<QVariant> argumentList;
argumentList << QLatin1String(NM_DBUS_INTERFACE_DEVICE_MODEM);
QDBusPendingReply<QVariantMap> propsReply
= deviceModemPropertiesInterface.callWithArgumentList(QDBus::Block,QLatin1String("GetAll"),
argumentList);
if (!propsReply.isError()) {
propertyMap = propsReply.value();
}
QDBusConnection::systemBus().connect(QLatin1String(NM_DBUS_SERVICE),
ifaceDevicePath,
QLatin1String(NM_DBUS_INTERFACE_DEVICE_MODEM),
QLatin1String("PropertiesChanged"),
this,SLOT(propertiesSwap(QMap<QString,QVariant>)));
}
QNetworkManagerInterfaceAccessPoint::QNetworkManagerInterfaceAccessPoint(const QString &dbusPathName, QObject *parent)
: QDBusAbstractInterface(QLatin1String(NM_DBUS_SERVICE),
dbusPathName,
NM_DBUS_INTERFACE_ACCESS_POINT,
QDBusConnection::systemBus(),parent)
{
if (!isValid()) {
return;
}
PropertiesDBusInterface *accessPointPropertiesInterface = new PropertiesDBusInterface(QLatin1String(NM_DBUS_SERVICE),
dbusPathName,
DBUS_PROPERTIES_INTERFACE,
QDBusConnection::systemBus());
QList<QVariant> argumentList;
argumentList << QLatin1String(NM_DBUS_INTERFACE_ACCESS_POINT);
QDBusPendingReply<QVariantMap> propsReply
= accessPointPropertiesInterface->callWithArgumentList(QDBus::Block,QLatin1String("GetAll"),
argumentList);
if (!propsReply.isError()) {
propertyMap = propsReply.value();
}
QDBusConnection::systemBus().connect(QLatin1String(NM_DBUS_SERVICE),
dbusPathName,
QLatin1String(NM_DBUS_INTERFACE_ACCESS_POINT),
QLatin1String("PropertiesChanged"),
this,SLOT(propertiesSwap(QMap<QString,QVariant>)));
}
void NotificationsModel::refreshNotificationList()
{
if (!m_dbusInterface) {
return;
}
if (!m_notificationList.isEmpty()) {
beginRemoveRows(QModelIndex(), 0, m_notificationList.size() - 1);
qDeleteAll(m_notificationList);
m_notificationList.clear();
endRemoveRows();
}
if (!m_dbusInterface->isValid()) {
kDebug(debugArea()) << "dbus interface not valid";
return;
}
QDBusPendingReply<QStringList> pendingNotificationIds = m_dbusInterface->activeNotifications();
pendingNotificationIds.waitForFinished();
if (pendingNotificationIds.isError()) {
kDebug(debugArea()) << pendingNotificationIds.error();
return;
}
const QStringList& notificationIds = pendingNotificationIds.value();
if (notificationIds.isEmpty()) {
return;
}
beginInsertRows(QModelIndex(), 0, notificationIds.size() - 1);
Q_FOREACH (const QString& notificationId, notificationIds) {
NotificationDbusInterface* dbusInterface = new NotificationDbusInterface(m_deviceId, notificationId, this);
m_notificationList.append(dbusInterface);
}
void QOfonoHandsfreeAudioCard::setModemPath(const QString &path)
{
if (path == d_ptr->modemPath ||
path.isEmpty())
return;
if (path != modemPath()) {
if (d_ptr->ofonoHandsfreeAudioCard) {
delete d_ptr->ofonoHandsfreeAudioCard;
d_ptr->ofonoHandsfreeAudioCard = 0;
d_ptr->properties.clear();
}
d_ptr->modemPath = path;
d_ptr->ofonoHandsfreeAudioCard = new OfonoHandsfreeAudioCard("org.ofono", path, QDBusConnection::systemBus(),this);
if (d_ptr->ofonoHandsfreeAudioCard) {
QDBusPendingReply<QVariantMap> reply;
reply = d_ptr->ofonoHandsfreeAudioCard->GetProperties();
reply.waitForFinished();
d_ptr->properties = reply.value();
Q_EMIT modemPathChanged(path);
}
}
}
void QOfonoCallMeter::setModemPath(const QString &path)
{
if (path == d_ptr->modemPath ||
path.isEmpty())
return;
if (path != modemPath()) {
if (d_ptr->callMeter) {
delete d_ptr->callMeter;
d_ptr->callMeter = 0;
d_ptr->properties.clear();
}
d_ptr->callMeter = new OfonoCallMeter("org.ofono", path, QDBusConnection::systemBus(),this);
if (d_ptr->callMeter->isValid()) {
d_ptr->modemPath = path;
connect(d_ptr->callMeter,SIGNAL(PropertyChanged(QString,QDBusVariant)),
this,SLOT(propertyChanged(QString,QDBusVariant)));
connect(d_ptr->callMeter,SIGNAL(NearMaximumWarning()),this,SIGNAL(nearMaximumWarning()));
QDBusPendingReply<QVariantMap> reply;
reply = d_ptr->callMeter->GetProperties();
reply.waitForFinished();
d_ptr->properties = reply.value();
Q_EMIT modemPathChanged(path);
}
}
}
void QOfonoMessageWaiting::connectOfono()
{
bool wasReady = isReady();
// FIXME: Clearing properties here results in false *Changed signal
// emissions. Ideally ready() should not be derived from
// properties.isEmpty(). Also compare with QOfonoSimManager.
if (d_ptr->messageWaiting) {
delete d_ptr->messageWaiting;
d_ptr->messageWaiting = 0;
d_ptr->properties.clear();
}
d_ptr->messageWaiting = new OfonoMessageWaiting("org.ofono", d_ptr->modemPath, QDBusConnection::systemBus(),this);
if (d_ptr->messageWaiting->isValid()) {
connect(d_ptr->messageWaiting,SIGNAL(PropertyChanged(QString,QDBusVariant)),
this,SLOT(propertyChanged(QString,QDBusVariant)));
QDBusPendingReply<QVariantMap> reply;
reply = d_ptr->messageWaiting->GetProperties();
reply.waitForFinished();
if (reply.isError()) {
Q_EMIT getPropertiesFailed();
} else {
QVariantMap properties = reply.value();
for (QVariantMap::ConstIterator it = properties.constBegin();
it != properties.constEnd(); ++it) {
updateProperty(it.key(), it.value());
}
}
}
if (wasReady != isReady())
Q_EMIT readyChanged();
}
void request_watcher_t::call_returned(QDBusPendingCallWatcher *w)
{
log_debug() ;
log_assert(w==this->w, "oops, somethig is really wrong with qdbus...") ;
QDBusPendingReply<bool> reply = *w ;
bool ok = reply.isValid() and reply.value() ;
abstract_io_state_t *next = machine->state_dlg_user ;
if (ok)
log_notice("Voland acknowledge received, moving %d event(s) to DLG_USER", events.size()) ;
else
{
string err = reply.isValid() ? "false returned" : reply.error().message().toStdString() ;
log_error("Voland call 'create' failed, message: '%s'", err.c_str()) ;
log_notice("moving %d event(s) to DLG_WAIT", events.size()) ;
next = machine->state_dlg_wait ;
}
for(set<event_t*>::const_iterator it=events.begin(); it!=events.end(); ++it)
next->go_to(*it) ;
if (events.size()>0)
machine->process_transition_queue() ;
// Don't need the watcher any more
delete this ;
}
void PowerDevilRunner::updateStatus()
{
// Profiles and their icons
{
KSharedConfigPtr profilesConfig = KSharedConfig::openConfig("powerdevil2profilesrc", KConfig::SimpleConfig);
// Request profiles to the daemon
QDBusMessage call = QDBusMessage::createMethodCall("org.kde.Solid.PowerManagement", "/org/kde/Solid/PowerManagement",
"org.kde.Solid.PowerManagement", "availableProfiles");
QDBusPendingReply< StringStringMap > reply = QDBusConnection::sessionBus().asyncCall(call);
reply.waitForFinished();
if (!reply.isValid()) {
kDebug() << "Error contacting the daemon!";
return;
}
m_availableProfiles = reply.value();
if (m_availableProfiles.isEmpty()) {
kDebug() << "No available profiles!";
return;
}
for (StringStringMap::const_iterator i = m_availableProfiles.constBegin(); i != m_availableProfiles.constEnd(); ++i) {
KConfigGroup settings(profilesConfig, i.key());
if (settings.readEntry< QString >("icon", QString()).isEmpty()) {
m_profileIcon[i.key()] = "preferences-system-power-management";
} else {
m_profileIcon[i.key()] = settings.readEntry< QString >("icon", QString());
}
}
}
updateSyntaxes();
}
QStringList
PlatformUdisks2::getPartitionList(const QString &devicePath)
{
QStringList partitionList;
org::freedesktop::DBus::ObjectManager manager("org.freedesktop.UDisks2", "/org/freedesktop/UDisks2", QDBusConnection::systemBus());
QDBusPendingReply<DBUSManagerStruct> reply = manager.GetManagedObjects();
reply.waitForFinished();
if (reply.isError()) {
qDebug() << "Failure: " << reply.error();
exit(0);
}
QRegExp reg(QString("%1[0-9]+$").arg(devicePath));
Q_FOREACH(const QDBusObjectPath &path, reply.value().keys()) {
const QString udi = path.path();
if (!udi.startsWith("/org/freedesktop/UDisks2/block_devices"))
continue;
if (!udi.contains(reg))
continue;
partitionList << udi;
}
return partitionList;
}
QNetworkManagerConnectionActive::QNetworkManagerConnectionActive(const QString &activeConnectionObjectPath, QObject *parent)
: QDBusAbstractInterface(QLatin1String(NM_DBUS_SERVICE),
activeConnectionObjectPath,
NM_DBUS_INTERFACE_ACTIVE_CONNECTION,
QDBusConnection::systemBus(), parent)
{
if (!isValid()) {
return;
}
PropertiesDBusInterface connectionActivePropertiesInterface(QLatin1String(NM_DBUS_SERVICE),
activeConnectionObjectPath,
QLatin1String("org.freedesktop.DBus.Properties"),
QDBusConnection::systemBus());
QList<QVariant> argumentList;
argumentList << QLatin1String(NM_DBUS_INTERFACE_ACTIVE_CONNECTION);
QDBusPendingReply<QVariantMap> propsReply
= connectionActivePropertiesInterface.callWithArgumentList(QDBus::Block,QLatin1String("GetAll"),
argumentList);
if (!propsReply.isError()) {
propertyMap = propsReply.value();
} else {
qWarning() << propsReply.error().message();
}
QDBusConnection::systemBus().connect(QLatin1String(NM_DBUS_SERVICE),
activeConnectionObjectPath,
QLatin1String(NM_DBUS_INTERFACE_ACTIVE_CONNECTION),
QLatin1String("PropertiesChanged"),
this,SLOT(propertiesSwap(QMap<QString,QVariant>)));
}
void NetworkManager::getPropertiesReply(QDBusPendingCallWatcher *call)
{
Q_ASSERT(call);
pr_dbg() << "Got reply with manager's properties";
QDBusPendingReply<QVariantMap> reply = *call;
if (reply.isError()) {
pr_dbg() << "Error getPropertiesReply: " << reply.error().message();
disconnectFromConnman();
// TODO: set up timer to reconnect in a bit
QTimer::singleShot(10000,this,SLOT(connectToConnman()));
} else {
m_propertiesCache = reply.value();
pr_dbg() << "Initial Manager's properties";
pr_dbg() << "\tState: " << m_propertiesCache[State].toString();
pr_dbg() << "\tOfflineMode: " << m_propertiesCache[OfflineMode].toString();
emit stateChanged(m_propertiesCache[State].toString());
connect(m_manager,
SIGNAL(PropertyChanged(const QString&, const QDBusVariant&)),
this,
SLOT(propertyChanged(const QString&, const QDBusVariant&)));
}
}
void ManagerProxy::managerDBusGetModemsDone(QDBusPendingCallWatcher *call)
{
QDBusPendingReply<QArrayOfPathProperties> reply = *call;
if (reply.isError()) {
// TODO: Handle this properly, by setting states, or disabling features
qWarning() << "org.ofono.Manager.GetModems() failed: " <<
reply.error().message();
} else {
QArrayOfPathProperties modems = reply.value();
if (modems.count() >= 1) {
// FIXME: Handle multiple modems...
OfonoPathProperties p = modems[0];
if (m_modemPath.isNull() || m_modemPath.isEmpty()) {
qDebug() << QString("\n======\nUsing modem: \"%1\"\n======").arg(p.path.path());
m_modemPath = QString(p.path.path());
m_modem = new ModemProxy(m_modemPath);
m_network = new NetworkProxy(m_modemPath);
m_callManager = new CallManager(m_modemPath);
m_volumeManager = new VolumeManager(m_modemPath);
m_voicemail = new VoicemailProxy(m_modemPath);
// TODO: Connect to service proxies as available/needed here
}
}
}
}
void NotifyManager::onNotifyGetAllFinished(QDBusPendingCallWatcher *w)
{
QDBusPendingReply<QString> reply = *w;
QJsonDocument jsonDocument = QJsonDocument::fromJson(reply.value().toLocal8Bit().data());
m_dataJsonArray = jsonDocument.array();
qDebug() << "====================================" << m_dataJsonArray;
m_checkIndex = m_dataJsonArray.size();
if (m_checkIndex) {
if (m_checkIndex < 20) {
for (const QJsonValue &value : m_dataJsonArray) {
Viewer* viewer = onNotifyAdd(value.toObject());
m_connectLayout->insertWidget(0, viewer);
}
m_checkIndex = 0;
} else {
for (int i = 20; i > 0; --i) {
if (m_checkIndex - i < 1)
return;
Viewer* viewer = onNotifyAdd(m_dataJsonArray.at(m_checkIndex - i).toObject());
m_connectLayout->insertWidget(0, viewer);
}
m_checkIndex = m_dataJsonArray.size() - 20;
}
}
w->deleteLater();
}
void QBluetoothTransferReplyBluez::sessionCreated(QDBusPendingCallWatcher *watcher)
{
QDBusPendingReply<QDBusObjectPath> reply = *watcher;
if (reply.isError()) {
qCWarning(QT_BT_BLUEZ) << "Failed to create obex session:"
<< reply.error().name() << reply.reply().errorMessage();
m_errorStr = QBluetoothTransferReply::tr("Invalid target address");
m_error = QBluetoothTransferReply::HostNotFoundError;
m_finished = true;
m_running = false;
emit QBluetoothTransferReply::error(m_error);
emit finished(this);
watcher->deleteLater();
return;
}
m_objectPushBluez = new OrgBluezObexObjectPush1Interface(QStringLiteral("org.bluez.obex"),
reply.value().path(),
QDBusConnection::sessionBus(), this);
QDBusPendingReply<QDBusObjectPath, QVariantMap> newReply = m_objectPushBluez->SendFile(fileToTranser);
QDBusPendingCallWatcher *newWatcher = new QDBusPendingCallWatcher(newReply, this);
connect(newWatcher, SIGNAL(finished(QDBusPendingCallWatcher*)),
SLOT(sessionStarted(QDBusPendingCallWatcher*)));
watcher->deleteLater();
}
QBluetoothLocalDevice::QBluetoothLocalDevice(QObject *parent)
: QObject(parent)
{
OrgBluezManagerInterface manager(QLatin1String("org.bluez"), QLatin1String("/"),
QDBusConnection::systemBus());
QDBusPendingReply<QDBusObjectPath> reply = manager.DefaultAdapter();
reply.waitForFinished();
if (reply.isError())
return;
OrgBluezAdapterInterface *adapter = new OrgBluezAdapterInterface(QLatin1String("org.bluez"),
reply.value().path(),
QDBusConnection::systemBus());
this->d_ptr = new QBluetoothLocalDevicePrivate;
this->d_ptr->adapter = adapter;
this->d_ptr->q_ptr = this;
this->d_ptr->agent = 0x0;
this->d_ptr->msgConnection = 0x0;
this->d_ptr->currentMode = static_cast<QBluetoothLocalDevice::HostMode>(-1);
connect(adapter, SIGNAL(PropertyChanged(QString,QDBusVariant)),
this->d_ptr, SLOT(PropertyChanged(QString,QDBusVariant)));
// connect(d_ptr, SIGNAL(pairingFinished(const QBluetoothAddress&,QBluetoothLocalDevice::Pairing)), this, SIGNAL(pairingFinished(const QBluetoothAddress&,QBluetoothLocalDevice::Pairing)));
// connect(this->d_ptr, SIGNAL(pairingDisplayPinCode(const QBluetoothAddress &,QString)),
// this, SIGNAL(pairingDisplayPinCode(const QBluetoothAddress &,QString)));
qsrand(QTime::currentTime().msec());
this->d_ptr->agent_path = agentPath;
this->d_ptr->agent_path.append(QString::fromLatin1("/%1").arg(qrand()));
}
void Mpris::checkConnection()
{
if (m_valid) {
QDBusConnection::sessionBus().disconnect(m_service, mprisPath, dbusPropertiesInterface,
QStringLiteral("PropertiesChanged"),
this, SLOT(propertiesChanged(QString, QMap<QString, QVariant>, QStringList)));
}
DBusInterface iface(dbusService, QStringLiteral("/"), dbusService);
if (!iface.isValid()) {
return;
}
QDBusPendingCall call = iface.asyncCall(QStringLiteral("ListNames"));
QDBusPendingCallWatcher *watcher = new QDBusPendingCallWatcher(call);
watcher->connect(watcher, &QDBusPendingCallWatcher::finished, [this](QDBusPendingCallWatcher *watcher) {
watcher->deleteLater();
QDBusPendingReply<QStringList> reply = *watcher;
if (reply.isError()) {
qDebug("Failed to get the list of DBus services.");
} else {
QStringList services = reply.value();
checkServices(services);
}
});
}
void QBluetoothLocalDevicePrivate::PropertyChanged(QString property, QDBusVariant value)
{
Q_UNUSED(value);
if (property != QLatin1String("Powered") &&
property != QLatin1String("Discoverable"))
return;
Q_Q(QBluetoothLocalDevice);
QBluetoothLocalDevice::HostMode mode;
QDBusPendingReply<QVariantMap> reply = adapter->GetProperties();
reply.waitForFinished();
if (reply.isError()){
qWarning() << "Failed to get bluetooth properties for mode change";
return;
}
QVariantMap map = reply.value();
if(!map.value(QLatin1String("Powered")).toBool()){
mode = QBluetoothLocalDevice::HostPoweredOff;
}
else {
if (map.value(QLatin1String("Discoverable")).toBool())
mode = QBluetoothLocalDevice::HostDiscoverable;
else
mode = QBluetoothLocalDevice::HostConnectable;
}
if(mode != currentMode)
emit q->hostModeStateChanged(mode);
currentMode = mode;
}
void QBluetoothLocalDevicePrivate::pairingCompleted(QDBusPendingCallWatcher *watcher)
{
Q_Q(QBluetoothLocalDevice);
QDBusPendingReply<> reply = *watcher;
if(reply.isError()) {
qDebug() << Q_FUNC_INFO << "failed to create pairing" << reply.error();
emit q->pairingFinished(address, QBluetoothLocalDevice::Unpaired);
delete watcher;
return;
}
QDBusPendingReply<QDBusObjectPath> findReply = adapter->FindDevice(address.toString());
findReply.waitForFinished();
if(findReply.isError()) {
qDebug() << Q_FUNC_INFO << "failed to find device" << findReply.error();
emit q->pairingFinished(address, QBluetoothLocalDevice::Unpaired);
delete watcher;
return;
}
OrgBluezDeviceInterface device(QLatin1String("org.bluez"), findReply.value().path(),
QDBusConnection::systemBus());
if(pairing == QBluetoothLocalDevice::AuthorizedPaired) {
device.SetProperty(QLatin1String("Trusted"), QDBusVariant(QVariant(true)));
emit q->pairingFinished(address, QBluetoothLocalDevice::AuthorizedPaired);
}
else {
device.SetProperty(QLatin1String("Trusted"), QDBusVariant(QVariant(false)));
emit q->pairingFinished(address, QBluetoothLocalDevice::Paired);
}
delete watcher;
}
QBluetoothLocalDevice::Pairing QBluetoothLocalDevice::pairingStatus(const QBluetoothAddress &address) const
{
OrgBluezDeviceInterface *device = getDevice(address, d_ptr);
if(!device)
return Unpaired;
QDBusPendingReply<QVariantMap> deviceReply = device->GetProperties();
deviceReply.waitForFinished();
if (deviceReply.isError())
return Unpaired;
QVariantMap map = deviceReply.value();
// qDebug() << "Paired: " << map.value("Paired");
if (map.value(QLatin1String("Trusted")).toBool() && map.value(QLatin1String("Paired")).toBool())
return AuthorizedPaired;
else if (map.value(QLatin1String("Paired")).toBool())
return Paired;
else
return Unpaired;
}
void PowerManagerNux::OnAsyncReply(QDBusPendingCallWatcher *call)
{
if (m_state == request_idle)
{
QDBusPendingReply<> reply = *call;
if(reply.isError())
{
qDebug("D-Bus: Reply: Error: %s", qPrintable(reply.error().message()));
m_state = error;
}
else
{
m_state = idle;
qDebug("D-Bus: PowerManagerInhibitor: Request successful");
if (m_intended_state == busy)
this->setState(1, QString::fromLatin1(""));
}
}
else if (m_state == request_busy)
{
QDBusPendingReply<uint> reply = *call;
if(reply.isError())
{
qDebug("D-Bus: Reply: Error: %s", qPrintable(reply.error().message()));
if (!m_use_gsm)
{
qDebug("D-Bus: Falling back to org.gnome.SessionManager");
m_use_gsm = true;
m_state = idle;
if (m_intended_state == busy)
// XXX
this->setState(1, QString("Busy"));
}
else
{
m_state = error;
}
}
else
{
m_state = busy;
m_cookie = reply.value();
qDebug("D-Bus: PowerManagerInhibitor: Request successful, cookie is %d", m_cookie);
if (m_intended_state == idle)
// XXX
this->setState(0, QString("Iddle"));
}
}
else
{
qDebug("D-Bus: Unexpected reply in state %d", m_state);
m_state = error;
}
call->deleteLater();
}
void QBluetoothDeviceDiscoveryAgentPrivate::start()
{
if(pendingCancel == true) {
pendingStart = true;
return;
}
discoveredDevices.clear();
QDBusPendingReply<QDBusObjectPath> reply = manager->DefaultAdapter();
reply.waitForFinished();
if (reply.isError()) {
errorString = reply.error().message();
#ifdef QTM_DEVICEDISCOVERY_DEBUG
qDebug() << Q_FUNC_INFO << "ERROR: " << errorString;
#endif
lastError = QBluetoothDeviceDiscoveryAgent::IOFailure;
Q_Q(QBluetoothDeviceDiscoveryAgent);
emit q->error(lastError);
return;
}
adapter = new OrgBluezAdapterInterface(QLatin1String("org.bluez"), reply.value().path(),
QDBusConnection::systemBus());
Q_Q(QBluetoothDeviceDiscoveryAgent);
QObject::connect(adapter, SIGNAL(DeviceFound(QString,QVariantMap)),
q, SLOT(_q_deviceFound(QString,QVariantMap)));
QObject::connect(adapter, SIGNAL(PropertyChanged(QString,QDBusVariant)),
q, SLOT(_q_propertyChanged(QString,QDBusVariant)));
QDBusPendingReply<QVariantMap> propertiesReply = adapter->GetProperties();
propertiesReply.waitForFinished();
if(propertiesReply.isError()) {
#ifdef QTM_DEVICEDISCOVERY_DEBUG
qDebug() << Q_FUNC_INFO << "ERROR: " << errorString;
#endif
errorString = propertiesReply.error().message();
lastError = QBluetoothDeviceDiscoveryAgent::IOFailure;
Q_Q(QBluetoothDeviceDiscoveryAgent);
emit q->error(lastError);
return;
}
QDBusPendingReply<> discoveryReply = adapter->StartDiscovery();
if (discoveryReply.isError()) {
delete adapter;
adapter = 0;
errorString = discoveryReply.error().message();
lastError = QBluetoothDeviceDiscoveryAgent::IOFailure;
Q_Q(QBluetoothDeviceDiscoveryAgent);
emit q->error(lastError);
#ifdef QTM_DEVICEDISCOVERY_DEBUG
qDebug() << Q_FUNC_INFO << "ERROR: " << errorString;
#endif
return;
}
}
void ReadPasswordJobPrivate::kwalletReadFinished( QDBusPendingCallWatcher* watcher ) {
watcher->deleteLater();
if ( watcher->isError() ) {
const QDBusError err = watcher->error();
q->emitFinishedWithError( OtherError, tr("Could not read password: %1; %2").arg( QDBusError::errorString( err.type() ), err.message() ) );
return;
}
if ( dataType == Binary ) {
QDBusPendingReply<QByteArray> reply = *watcher;
data = reply.value();
} else {
QDBusPendingReply<QString> reply = *watcher;
data = reply.value().toUtf8();
}
q->emitFinished();
}
