summaryrefslogtreecommitdiffstats
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/plugins/bearer/connman/connman.pro2
-rw-r--r--src/plugins/bearer/connman/qconnmanengine.cpp162
-rw-r--r--src/plugins/bearer/connman/qconnmanengine.h3
-rw-r--r--src/plugins/bearer/connman/qconnmanservice_linux.cpp9
-rw-r--r--src/plugins/bearer/connman/qconnmanservice_linux_p.h1
-rw-r--r--src/plugins/bearer/connman/qofonoservice_linux.cpp940
-rw-r--r--src/plugins/bearer/connman/qofonoservice_linux_p.h332
7 files changed, 1393 insertions, 56 deletions
diff --git a/src/plugins/bearer/connman/connman.pro b/src/plugins/bearer/connman/connman.pro
index 4be752b..dec408c 100644
--- a/src/plugins/bearer/connman/connman.pro
+++ b/src/plugins/bearer/connman/connman.pro
@@ -4,12 +4,14 @@ include(../../qpluginbase.pri)
QT = core network dbus
HEADERS += qconnmanservice_linux_p.h \
+ qofonoservice_linux_p.h \
qconnmanengine.h \
../qnetworksession_impl.h \
../qbearerengine_impl.h
SOURCES += main.cpp \
qconnmanservice_linux.cpp \
+ qofonoservice_linux.cpp \
qconnmanengine.cpp \
../qnetworksession_impl.cpp
diff --git a/src/plugins/bearer/connman/qconnmanengine.cpp b/src/plugins/bearer/connman/qconnmanengine.cpp
index 341f7cd..a8b8911 100644
--- a/src/plugins/bearer/connman/qconnmanengine.cpp
+++ b/src/plugins/bearer/connman/qconnmanengine.cpp
@@ -41,6 +41,7 @@
#include "qconnmanengine.h"
#include "qconnmanservice_linux_p.h"
+#include "qofonoservice_linux_p.h"
#include "../qnetworksession_impl.h"
#include <QtNetwork/private/qnetworkconfiguration_p.h>
@@ -109,7 +110,6 @@ void QConnmanEngine::initialize()
QList<QNetworkConfigurationPrivate *> QConnmanEngine::getConfigurations()
{
QMutexLocker locker(&mutex);
- // foundConfigurations.clear();
getNetworkListing();
QList<QNetworkConfigurationPrivate *> fetchedConfigurations;
QNetworkConfigurationPrivate* cpPriv = 0;
@@ -131,7 +131,6 @@ QList<QNetworkConfigurationPrivate *> QConnmanEngine::getConfigurations()
delete config;
}
return fetchedConfigurations;
-// return foundConfigurations;
}
void QConnmanEngine::getNetworkListing()
@@ -149,7 +148,6 @@ void QConnmanEngine::getNetworkListing()
}
}
-
void QConnmanEngine::doRequestUpdate()
{
connmanManager->requestScan("");
@@ -184,11 +182,24 @@ void QConnmanEngine::connectToId(const QString &id)
void QConnmanEngine::disconnectFromId(const QString &id)
{
QMutexLocker locker(&mutex);
- QConnmanServiceInterface serv(serviceFromId(id));
+ QString servicePath = serviceFromId(id);
+ QConnmanServiceInterface serv(servicePath);
if(!serv.isValid()) {
emit connectionError(id, DisconnectionError);
} else {
- serv.disconnect();
+ if(serv.getType() != "cellular") {
+ serv.disconnect();
+ } else {
+ QOfonoManagerInterface ofonoManager(0);
+ QString modemPath = ofonoManager.currentModem().path();
+ QOfonoDataConnectionManagerInterface dc(modemPath,0);
+ foreach(const QDBusObjectPath dcPath,dc.getPrimaryContexts()) {
+ if(dcPath.path().contains(servicePath.section("_",-1))) {
+ QOfonoPrimaryDataContextInterface primaryContext(dcPath.path(),0);
+ primaryContext.setActive(false);
+ }
+ }
+ }
}
}
@@ -324,7 +335,6 @@ QString QConnmanEngine::getServiceForNetwork(const QString &netPath)
return QString();
}
-
void QConnmanEngine::propertyChangedContext(const QString &path,const QString &item, const QDBusVariant &value)
{
Q_UNUSED(path);
@@ -376,7 +386,7 @@ void QConnmanEngine::servicePropertyChangedContext(const QString &path,const QSt
}
}
-void QConnmanEngine::networkPropertyChangedContext(const QString &path,const QString &item, const QDBusVariant &value)
+void QConnmanEngine::networkPropertyChangedContext(const QString &/*path*/,const QString &/*item*/, const QDBusVariant &/*value*/)
{
QMutexLocker locker(&mutex);
}
@@ -388,7 +398,6 @@ void QConnmanEngine::devicePropertyChangedContext(const QString &devpath,const Q
QConnmanNetworkInterface network(devpath, this);
-
QDBusArgument arg = qvariant_cast<QDBusArgument>(value.variant());
QStringList remainingNetworks = qdbus_cast<QStringList>(arg);
QString devicetype;
@@ -502,10 +511,18 @@ QNetworkConfiguration::StateFlags QConnmanEngine::getStateForService(const QStri
QMutexLocker locker(&mutex);
QConnmanServiceInterface serv(service);
QNetworkConfiguration::StateFlags flag = QNetworkConfiguration::Defined;
- if(serv.isFavorite()) {
- flag = ( flag | QNetworkConfiguration::Discovered);
+ if( serv.getType() == "cellular") {
+ if(serv.isSetupRequired()) {
+ flag = ( flag | QNetworkConfiguration::Defined);
+ } else {
+ flag = ( flag | QNetworkConfiguration::Discovered);
+ }
} else {
- flag = QNetworkConfiguration::Undefined;
+ if(serv.isFavorite()) {
+ flag = ( flag | QNetworkConfiguration::Discovered);
+ } else {
+ flag = QNetworkConfiguration::Undefined;
+ }
}
if(serv.getState() == "ready" || serv.getState() == "online") {
@@ -524,8 +541,7 @@ QNetworkConfiguration::BearerType QConnmanEngine::typeToBearer(const QString &ty
if (type == "bluetooth")
return QNetworkConfiguration::BearerBluetooth;
if (type == "cellular") {
- return QNetworkConfiguration::Bearer2G;
- // not handled: CDMA2000 HSPA
+ return ofonoTechToBearerType(type);
}
if (type == "wimax")
return QNetworkConfiguration::BearerWiMAX;
@@ -536,6 +552,51 @@ QNetworkConfiguration::BearerType QConnmanEngine::typeToBearer(const QString &ty
return QNetworkConfiguration::BearerUnknown;
}
+QNetworkConfiguration::BearerType QConnmanEngine::ofonoTechToBearerType(const QString &/*type*/)
+{
+ QOfonoManagerInterface ofonoManager(this);
+ QOfonoNetworkRegistrationInterface ofonoNetwork(ofonoManager.currentModem().path(),this);
+
+ if(ofonoNetwork.isValid()) {
+ foreach(const QDBusObjectPath op,ofonoNetwork.getOperators() ) {
+ QOfonoNetworkOperatorInterface opIface(op.path(),this);
+
+ foreach(const QString opTech, opIface.getTechnologies()) {
+
+ if(opTech == "gsm") {
+ return QNetworkConfiguration::Bearer2G;
+ }
+ if(opTech == "edge"){
+ return QNetworkConfiguration::BearerCDMA2000; //wrong, I know
+ }
+ if(opTech == "umts"){
+ return QNetworkConfiguration::BearerWCDMA;
+ }
+ if(opTech == "hspa"){
+ return QNetworkConfiguration::BearerHSPA;
+ }
+ if(opTech == "lte"){
+ return QNetworkConfiguration::BearerWiMAX; //not exact
+ }
+ }
+ }
+ }
+ return QNetworkConfiguration::BearerUnknown;
+}
+
+bool QConnmanEngine::isRoamingAllowed(const QString &context)
+{
+ QOfonoManagerInterface ofonoManager(this);
+ QString modemPath = ofonoManager.currentModem().path();
+ QOfonoDataConnectionManagerInterface dc(modemPath,this);
+ foreach(const QDBusObjectPath dcPath,dc.getPrimaryContexts()) {
+ if(dcPath.path().contains(context.section("_",-1))) {
+ return dc.isRoamingAllowed();
+ }
+ }
+ return false;
+}
+
void QConnmanEngine::removeConfiguration(const QString &id)
{
QMutexLocker locker(&mutex);
@@ -564,7 +625,6 @@ void QConnmanEngine::removeConfiguration(const QString &id)
void QConnmanEngine::addServiceConfiguration(const QString &servicePath)
{
-
QMutexLocker locker(&mutex);
QConnmanServiceInterface *serv;
serv = new QConnmanServiceInterface(servicePath);
@@ -589,36 +649,31 @@ void QConnmanEngine::addServiceConfiguration(const QString &servicePath)
QString networkName = serv->getName();
- if(serv->getType() == "cellular") {
- networkName = serv->getAPN();
- if(networkName.isEmpty()) {
- networkName = serv->getName();
- }
- }
-
- cpPriv->name = networkName;
- cpPriv->isValid = true;
- cpPriv->id = id;
- cpPriv->type = QNetworkConfiguration::InternetAccessPoint;
-
-
const QString connectionType = serv->getType();
if (connectionType == "ethernet") {
cpPriv->bearerType = QNetworkConfiguration::BearerEthernet;
} else if (connectionType == "wifi") {
cpPriv->bearerType = QNetworkConfiguration::BearerWLAN;
} else if (connectionType == "cellular") {
- const QString mode = serv->getMode();
- if (mode == "gprs" || mode == "edge")
- cpPriv->bearerType = QNetworkConfiguration::Bearer2G;
- else if (mode == "umts")
- cpPriv->bearerType = QNetworkConfiguration::BearerWCDMA;
+ cpPriv->bearerType = ofonoTechToBearerType("cellular");
+ if(servicePath.isEmpty()) {
+ networkName = serv->getAPN();
+ if(networkName.isEmpty()) {
+ networkName = serv->getName();
+ }
+ }
+ cpPriv->roamingSupported = isRoamingAllowed(servicePath);
} else if (connectionType == "wimax") {
cpPriv->bearerType = QNetworkConfiguration::BearerWiMAX;
} else {
cpPriv->bearerType = QNetworkConfiguration::BearerUnknown;
}
+ cpPriv->name = networkName;
+ cpPriv->isValid = true;
+ cpPriv->id = id;
+ cpPriv->type = QNetworkConfiguration::InternetAccessPoint;
+
if(serv->getSecurity() == "none") {
cpPriv->purpose = QNetworkConfiguration::PublicPurpose;
} else {
@@ -635,7 +690,6 @@ void QConnmanEngine::addServiceConfiguration(const QString &servicePath)
foundConfigurations.append(cpPriv);
configInterfaces[cpPriv->id] = device.getInterface();
-
locker.unlock();
emit configurationAdded(ptr);
locker.relock();
@@ -646,7 +700,6 @@ void QConnmanEngine::addServiceConfiguration(const QString &servicePath)
void QConnmanEngine::addNetworkConfiguration(const QString &networkPath)
{
QMutexLocker locker(&mutex);
-
if(networkPath.isNull())
return;
@@ -662,10 +715,9 @@ void QConnmanEngine::addNetworkConfiguration(const QString &networkPath)
id = QString::number(qHash(networkPath));
} else {
id = QString::number(qHash(servicePath));
- serv = new QConnmanServiceInterface(servicePath,this);
- connect(serv,SIGNAL(propertyChangedContext(QString,QString,QDBusVariant)),
- this,SLOT(servicePropertyChangedContext(QString,QString, QDBusVariant)));
-
+ serv = new QConnmanServiceInterface(servicePath,this);
+ connect(serv,SIGNAL(propertyChangedContext(QString,QString,QDBusVariant)),
+ this,SLOT(servicePropertyChangedContext(QString,QString, QDBusVariant)));
}
if (!id.isEmpty() && !accessPointConfigurations.contains(id)) {
@@ -684,7 +736,6 @@ void QConnmanEngine::addNetworkConfiguration(const QString &networkPath)
if(networkName.isEmpty())
networkName = "Hidden Network";
-
QNetworkConfiguration::BearerType bearerType;
if(servicePath.isEmpty()) {
@@ -693,21 +744,14 @@ void QConnmanEngine::addNetworkConfiguration(const QString &networkPath)
QConnmanDeviceInterface device(devicePath,this);
bearerType = typeToBearer(device.getType());
} else {
- bearerType = typeToBearer(serv->getType());
- }
-
- if (bearerType == QNetworkConfiguration::Bearer2G) {
- QString mode = serv->getMode();
- if (mode == "gprs" || mode == "edge") {
- bearerType = QNetworkConfiguration::Bearer2G;
- } else if (mode == "umts") {
- bearerType = QNetworkConfiguration::BearerWCDMA;
- }
- if(servicePath.isEmpty()) {
- networkName = serv->getAPN();
- if(networkName.isEmpty()) {
+ if(serv->getType() == "cellular") {
+ bearerType = ofonoTechToBearerType("cellular");
+ if(servicePath.isEmpty()) {
networkName = serv->getName();
}
+ cpPriv->roamingSupported = isRoamingAllowed(servicePath);
+ } else {
+ bearerType = typeToBearer(serv->getType());
}
}
@@ -775,7 +819,19 @@ void QConnmanConnectThread::run()
if(!serv.isValid()) {
emit connectionError(identifier, QBearerEngineImpl::InterfaceLookupError);
} else {
- serv.connect();
+ if(serv.getType() != "cellular") {
+ serv.connect();
+ } else {
+ QOfonoManagerInterface ofonoManager(0);
+ QString modemPath = ofonoManager.currentModem().path();
+ QOfonoDataConnectionManagerInterface dc(modemPath,0);
+ foreach(const QDBusObjectPath dcPath,dc.getPrimaryContexts()) {
+ if(dcPath.path().contains(servicePath.section("_",-1))) {
+ QOfonoPrimaryDataContextInterface primaryContext(dcPath.path(),0);
+ primaryContext.setActive(true);
+ }
+ }
+ }
}
}
diff --git a/src/plugins/bearer/connman/qconnmanengine.h b/src/plugins/bearer/connman/qconnmanengine.h
index 2ee6da5..569bbc7 100644
--- a/src/plugins/bearer/connman/qconnmanengine.h
+++ b/src/plugins/bearer/connman/qconnmanengine.h
@@ -137,7 +137,8 @@ private:
QMap<QString,QStringList> deviceMap; //tech path, device path
QMap<QString, QString> serviceNetworks; //service, network
-
+ QNetworkConfiguration::BearerType ofonoTechToBearerType(const QString &type);
+ bool isRoamingAllowed(const QString &context);
protected:
bool requiresPolling() const;
QConnmanConnectThread *connThread;
diff --git a/src/plugins/bearer/connman/qconnmanservice_linux.cpp b/src/plugins/bearer/connman/qconnmanservice_linux.cpp
index 3722c43..549a07a 100644
--- a/src/plugins/bearer/connman/qconnmanservice_linux.cpp
+++ b/src/plugins/bearer/connman/qconnmanservice_linux.cpp
@@ -984,12 +984,17 @@ QConnmanCounterInterface::~QConnmanCounterInterface()
quint32 QConnmanCounterInterface::getReceivedByteCount()
{
-return 0;
+ return 0;
}
quint32 QConnmanCounterInterface::getTransmittedByteCount()
{
-return 0;
+ return 0;
+}
+
+quint64 QConnmanCounterInterface::getTimeOnline()
+{
+ return 0;
}
/////////////////////////////////////////
diff --git a/src/plugins/bearer/connman/qconnmanservice_linux_p.h b/src/plugins/bearer/connman/qconnmanservice_linux_p.h
index a2b1e73..6e6b702 100644
--- a/src/plugins/bearer/connman/qconnmanservice_linux_p.h
+++ b/src/plugins/bearer/connman/qconnmanservice_linux_p.h
@@ -331,6 +331,7 @@ public:
QString getInterface();
quint32 getReceivedByteCount();
quint32 getTransmittedByteCount();
+ quint64 getTimeOnline();
private:
QConnmanCounterInterfacePrivate *d;
diff --git a/src/plugins/bearer/connman/qofonoservice_linux.cpp b/src/plugins/bearer/connman/qofonoservice_linux.cpp
new file mode 100644
index 0000000..955f4b1
--- /dev/null
+++ b/src/plugins/bearer/connman/qofonoservice_linux.cpp
@@ -0,0 +1,940 @@
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <QObject>
+#include <QList>
+#include <QtDBus/QtDBus>
+#include <QtDBus/QDBusConnection>
+#include <QtDBus/QDBusError>
+#include <QtDBus/QDBusInterface>
+#include <QtDBus/QDBusMessage>
+#include <QtDBus/QDBusReply>
+#include <QtDBus/QDBusPendingCallWatcher>
+#include <QtDBus/QDBusObjectPath>
+#include <QtDBus/QDBusPendingCall>
+
+#include "qofonoservice_linux_p.h"
+
+
+QT_BEGIN_NAMESPACE
+static QDBusConnection dbusConnection = QDBusConnection::systemBus();
+
+
+QOfonoManagerInterface::QOfonoManagerInterface( QObject *parent)
+ : QDBusAbstractInterface(QLatin1String(OFONO_SERVICE),
+ QLatin1String(OFONO_MANAGER_PATH),
+ OFONO_MANAGER_INTERFACE,
+ QDBusConnection::systemBus(), parent)
+{
+}
+
+QOfonoManagerInterface::~QOfonoManagerInterface()
+{
+}
+
+QList <QDBusObjectPath> QOfonoManagerInterface::getModems()
+{
+ QVariant var = getProperty("Modems");
+ return qdbus_cast<QList<QDBusObjectPath> >(var);
+}
+
+QDBusObjectPath QOfonoManagerInterface::currentModem()
+{
+ QList<QDBusObjectPath> modems = getModems();
+ foreach(const QDBusObjectPath modem, modems) {
+ QOfonoModemInterface device(modem.path());
+ if(device.isPowered() && device.isOnline())
+ return modem;;
+ }
+ return QDBusObjectPath();
+}
+
+
+void QOfonoManagerInterface::connectNotify(const char *signal)
+{
+if (QLatin1String(signal) == SIGNAL(propertyChanged(QString,QDBusVariant))) {
+ if(!connection().connect(QLatin1String(OFONO_SERVICE),
+ QLatin1String(OFONO_MANAGER_PATH),
+ QLatin1String(OFONO_MANAGER_INTERFACE),
+ QLatin1String("PropertyChanged"),
+ this,SIGNAL(propertyChanged(const QString &, const QDBusVariant & )))) {
+ qWarning() << "PropertyCHanged not connected";
+ }
+ }
+
+ if (QLatin1String(signal) == SIGNAL(propertyChangedContext(QString,QString,QDBusVariant))) {
+ QOfonoDBusHelper *helper;
+ helper = new QOfonoDBusHelper(this);
+
+ dbusConnection.connect(QLatin1String(OFONO_SERVICE),
+ QLatin1String(OFONO_MANAGER_PATH),
+ QLatin1String(OFONO_MANAGER_INTERFACE),
+ QLatin1String("PropertyChanged"),
+ helper,SLOT(propertyChanged(QString,QDBusVariant)));
+
+
+ QObject::connect(helper,SIGNAL(propertyChangedContext(const QString &,const QString &,const QDBusVariant &)),
+ this,SIGNAL(propertyChangedContext(const QString &,const QString &,const QDBusVariant &)));
+ }
+}
+
+void QOfonoManagerInterface::disconnectNotify(const char *signal)
+{
+ if (QLatin1String(signal) == SIGNAL(propertyChanged(QString,QVariant))) {
+
+ }
+}
+
+QVariant QOfonoManagerInterface::getProperty(const QString &property)
+{
+ QVariantMap map = getProperties();
+ if (map.contains(property)) {
+ return map.value(property);
+ } else {
+ qDebug() << Q_FUNC_INFO << "does not contain" << property;
+ }
+ return QVariant();
+}
+
+QVariantMap QOfonoManagerInterface::getProperties()
+{
+ QDBusReply<QVariantMap > reply = this->call(QLatin1String("GetProperties"));
+ if(reply.isValid())
+ return reply.value();
+ else
+ return QVariantMap();
+}
+
+QOfonoDBusHelper::QOfonoDBusHelper(QObject * parent)
+ : QObject(parent)
+{
+}
+
+QOfonoDBusHelper::~QOfonoDBusHelper()
+{
+}
+
+void QOfonoDBusHelper::propertyChanged(const QString &item, const QDBusVariant &var)
+{
+ QDBusMessage msg = this->message();
+ Q_EMIT propertyChangedContext(msg.path() ,item, var);
+}
+
+
+QOfonoModemInterface::QOfonoModemInterface(const QString &dbusPathName, QObject *parent)
+ : QDBusAbstractInterface(QLatin1String(OFONO_SERVICE),
+ dbusPathName,
+ OFONO_MODEM_INTERFACE,
+ QDBusConnection::systemBus(), parent)
+{
+}
+
+QOfonoModemInterface::~QOfonoModemInterface()
+{
+}
+
+bool QOfonoModemInterface::isPowered()
+{
+ QVariant var = getProperty("Powered");
+ return qdbus_cast<bool>(var);
+}
+
+bool QOfonoModemInterface::isOnline()
+{
+ QVariant var = getProperty("Online");
+ return qdbus_cast<bool>(var);
+}
+
+QString QOfonoModemInterface::getName()
+{
+ QVariant var = getProperty("Name");
+ return qdbus_cast<QString>(var);
+}
+
+QString QOfonoModemInterface::getManufacturer()
+{
+ QVariant var = getProperty("Manufacturer");
+ return qdbus_cast<QString>(var);
+
+}
+
+QString QOfonoModemInterface::getModel()
+{
+
+ QVariant var = getProperty("Model");
+ return qdbus_cast<QString>(var);
+}
+
+QString QOfonoModemInterface::getRevision()
+{
+ QVariant var = getProperty("Revision");
+ return qdbus_cast<QString>(var);
+
+}
+QString QOfonoModemInterface::getSerial()
+{
+ QVariant var = getProperty("Serial");
+ return qdbus_cast<QString>(var);
+
+}
+
+QStringList QOfonoModemInterface::getFeatures()
+{
+ //sms, sim
+ QVariant var = getProperty("Features");
+ return qdbus_cast<QStringList>(var);
+}
+
+QStringList QOfonoModemInterface::getInterfaces()
+{
+ QVariant var = getProperty("Interfaces");
+ return qdbus_cast<QStringList>(var);
+}
+
+QString QOfonoModemInterface::defaultInterface()
+{
+ foreach(const QString &modem,getInterfaces()) {
+ return modem;
+ }
+ return QString();
+}
+
+
+void QOfonoModemInterface::connectNotify(const char *signal)
+{
+ if (QLatin1String(signal) == SIGNAL(propertyChanged(QString,QDBusVariant))) {
+ if(!connection().connect(QLatin1String(OFONO_SERVICE),
+ this->path(),
+ QLatin1String(OFONO_MODEM_INTERFACE),
+ QLatin1String("PropertyChanged"),
+ this,SIGNAL(propertyChanged(const QString &, const QDBusVariant & )))) {
+ qWarning() << "PropertyCHanged not connected";
+ }
+ }
+
+ if (QLatin1String(signal) == SIGNAL(propertyChangedContext(QString,QString,QDBusVariant))) {
+ QOfonoDBusHelper *helper;
+ helper = new QOfonoDBusHelper(this);
+
+ dbusConnection.connect(QLatin1String(OFONO_SERVICE),
+ this->path(),
+ QLatin1String(OFONO_MODEM_INTERFACE),
+ QLatin1String("PropertyChanged"),
+ helper,SLOT(propertyChanged(QString,QDBusVariant)));
+
+
+ QObject::connect(helper,SIGNAL(propertyChangedContext(const QString &,const QString &,const QDBusVariant &)),
+ this,SIGNAL(propertyChangedContext(const QString &,const QString &,const QDBusVariant &)));
+ }}
+
+void QOfonoModemInterface::disconnectNotify(const char *signal)
+{
+ if (QLatin1String(signal) == SIGNAL(propertyChanged(QString,QVariant))) {
+
+ }
+}
+
+QVariantMap QOfonoModemInterface::getProperties()
+{
+ QDBusReply<QVariantMap > reply = this->call(QLatin1String("GetProperties"));
+ return reply.value();
+}
+
+QVariant QOfonoModemInterface::getProperty(const QString &property)
+{
+ QVariant var;
+ QVariantMap map = getProperties();
+ if (map.contains(property)) {
+ var = map.value(property);
+ } else {
+ qDebug() << Q_FUNC_INFO << "does not contain" << property;
+ }
+ return var;
+}
+
+
+QOfonoNetworkRegistrationInterface::QOfonoNetworkRegistrationInterface(const QString &dbusPathName, QObject *parent)
+ : QDBusAbstractInterface(QLatin1String(OFONO_SERVICE),
+ dbusPathName,
+ OFONO_NETWORK_REGISTRATION_INTERFACE,
+ QDBusConnection::systemBus(), parent)
+{
+}
+
+QOfonoNetworkRegistrationInterface::~QOfonoNetworkRegistrationInterface()
+{
+}
+
+QString QOfonoNetworkRegistrationInterface::getStatus()
+{
+ /*
+ "unregistered" Not registered to any network
+ "registered" Registered to home network
+ "searching" Not registered, but searching
+ "denied" Registration has been denied
+ "unknown" Status is unknown
+ "roaming" Registered, but roaming*/
+ QVariant var = getProperty("Status");
+ return qdbus_cast<QString>(var);
+}
+
+quint16 QOfonoNetworkRegistrationInterface::getLac()
+{
+ QVariant var = getProperty("LocationAreaCode");
+ return var.value<quint16>();
+}
+
+
+quint32 QOfonoNetworkRegistrationInterface::getCellId()
+{
+ QVariant var = getProperty("CellId");
+ return var.value<quint32>();
+}
+
+QString QOfonoNetworkRegistrationInterface::getTechnology()
+{
+ // "gsm", "edge", "umts", "hspa","lte"
+ QVariant var = getProperty("Technology");
+ return qdbus_cast<QString>(var);
+}
+
+QString QOfonoNetworkRegistrationInterface::getOperatorName()
+{
+ QVariant var = getProperty("Name");
+ return qdbus_cast<QString>(var);
+}
+
+int QOfonoNetworkRegistrationInterface::getSignalStrength()
+{
+ QVariant var = getProperty("Strength");
+ return qdbus_cast<int>(var);
+
+}
+
+QString QOfonoNetworkRegistrationInterface::getBaseStation()
+{
+ QVariant var = getProperty("BaseStation");
+ return qdbus_cast<QString>(var);
+}
+
+QList <QDBusObjectPath> QOfonoNetworkRegistrationInterface::getOperators()
+{
+ QVariant var = getProperty("Operators");
+ return qdbus_cast<QList <QDBusObjectPath> >(var);
+}
+
+void QOfonoNetworkRegistrationInterface::connectNotify(const char *signal)
+{
+if (QLatin1String(signal) == SIGNAL(propertyChanged(QString,QDBusVariant))) {
+ if(!connection().connect(QLatin1String(OFONO_SERVICE),
+ this->path(),
+ QLatin1String(OFONO_NETWORK_REGISTRATION_INTERFACE),
+ QLatin1String("PropertyChanged"),
+ this,SIGNAL(propertyChanged(const QString &, const QDBusVariant & )))) {
+ qWarning() << "PropertyCHanged not connected";
+ }
+ }
+
+ if (QLatin1String(signal) == SIGNAL(propertyChangedContext(QString,QString,QDBusVariant))) {
+ QOfonoDBusHelper *helper;
+ helper = new QOfonoDBusHelper(this);
+
+ dbusConnection.connect(QLatin1String(OFONO_SERVICE),
+ this->path(),
+ QLatin1String(OFONO_NETWORK_REGISTRATION_INTERFACE),
+ QLatin1String("PropertyChanged"),
+ helper,SLOT(propertyChanged(QString,QDBusVariant)));
+
+
+ QObject::connect(helper,SIGNAL(propertyChangedContext(const QString &,const QString &,const QDBusVariant &)),
+ this,SIGNAL(propertyChangedContext(const QString &,const QString &,const QDBusVariant &)));
+ }
+}
+
+void QOfonoNetworkRegistrationInterface::disconnectNotify(const char *signal)
+{
+ if (QLatin1String(signal) == SIGNAL(propertyChanged(QString,QVariant))) {
+
+ }
+}
+
+QVariant QOfonoNetworkRegistrationInterface::getProperty(const QString &property)
+{
+ QVariant var;
+ QVariantMap map = getProperties();
+ if (map.contains(property)) {
+ var = map.value(property);
+ } else {
+ qDebug() << Q_FUNC_INFO << "does not contain" << property;
+ }
+ return var;
+}
+
+QVariantMap QOfonoNetworkRegistrationInterface::getProperties()
+{
+ QDBusReply<QVariantMap > reply = this->call(QLatin1String("GetProperties"));
+ return reply.value();
+}
+
+
+
+QOfonoNetworkOperatorInterface::QOfonoNetworkOperatorInterface(const QString &dbusPathName, QObject *parent)
+ : QDBusAbstractInterface(QLatin1String(OFONO_SERVICE),
+ dbusPathName,
+ OFONO_NETWORK_OPERATOR_INTERFACE,
+ QDBusConnection::systemBus(), parent)
+{
+}
+
+QOfonoNetworkOperatorInterface::~QOfonoNetworkOperatorInterface()
+{
+}
+
+QString QOfonoNetworkOperatorInterface::getName()
+{
+ QVariant var = getProperty("Name");
+ return qdbus_cast<QString>(var);
+}
+
+QString QOfonoNetworkOperatorInterface::getStatus()
+{
+ // "unknown", "available", "current" and "forbidden"
+ QVariant var = getProperty("Status");
+ return qdbus_cast<QString>(var);
+}
+
+QString QOfonoNetworkOperatorInterface::getMcc()
+{
+ QVariant var = getProperty("MobileCountryCode");
+ return qdbus_cast<QString>(var);
+}
+
+QString QOfonoNetworkOperatorInterface::getMnc()
+{
+ QVariant var = getProperty("MobileNetworkCode");
+ return qdbus_cast<QString>(var);
+}
+
+QStringList QOfonoNetworkOperatorInterface::getTechnologies()
+{
+ QVariant var = getProperty("Technologies");
+ return qdbus_cast<QStringList>(var);
+}
+
+void QOfonoNetworkOperatorInterface::connectNotify(const char *signal)
+{
+if (QLatin1String(signal) == SIGNAL(propertyChanged(QString,QDBusVariant))) {
+ if(!connection().connect(QLatin1String(OFONO_SERVICE),
+ this->path(),
+ QLatin1String(OFONO_NETWORK_OPERATOR_INTERFACE),
+ QLatin1String("PropertyChanged"),
+ this,SIGNAL(propertyChanged(const QString &, const QDBusVariant & )))) {
+ qWarning() << "PropertyCHanged not connected";
+ }
+ }
+
+ if (QLatin1String(signal) == SIGNAL(propertyChangedContext(QString,QString,QDBusVariant))) {
+ QOfonoDBusHelper *helper;
+ helper = new QOfonoDBusHelper(this);
+
+ dbusConnection.connect(QLatin1String(OFONO_SERVICE),
+ this->path(),
+ QLatin1String(OFONO_NETWORK_OPERATOR_INTERFACE),
+ QLatin1String("PropertyChanged"),
+ helper,SLOT(propertyChanged(QString,QDBusVariant)));
+
+
+ QObject::connect(helper,SIGNAL(propertyChangedContext(const QString &,const QString &,const QDBusVariant &)),
+ this,SIGNAL(propertyChangedContext(const QString &,const QString &,const QDBusVariant &)));
+ }
+}
+
+void QOfonoNetworkOperatorInterface::disconnectNotify(const char *signal)
+{
+ if (QLatin1String(signal) == SIGNAL(propertyChanged(QString,QVariant))) {
+
+ }
+}
+
+QVariant QOfonoNetworkOperatorInterface::getProperty(const QString &property)
+{
+ QVariant var;
+ QVariantMap map = getProperties();
+ if (map.contains(property)) {
+ var = map.value(property);
+ } else {
+ qDebug() << Q_FUNC_INFO << "does not contain" << property;
+ }
+ return var;
+}
+
+QVariantMap QOfonoNetworkOperatorInterface::getProperties()
+{
+ QDBusReply<QVariantMap > reply = this->call(QLatin1String("GetProperties"));
+ return reply.value();
+}
+
+QOfonoSimInterface::QOfonoSimInterface(const QString &dbusPathName, QObject *parent)
+ : QDBusAbstractInterface(QLatin1String(OFONO_SERVICE),
+ dbusPathName,
+ OFONO_SIM_MANAGER_INTERFACE,
+ QDBusConnection::systemBus(), parent)
+{
+}
+
+QOfonoSimInterface::~QOfonoSimInterface()
+{
+}
+
+bool QOfonoSimInterface::isPresent()
+{
+ QVariant var = getProperty("Present");
+ return qdbus_cast<bool>(var);
+}
+
+QString QOfonoSimInterface::getHomeMcc()
+{
+ QVariant var = getProperty("MobileCountryCode");
+ return qdbus_cast<QString>(var);
+}
+
+QString QOfonoSimInterface::getHomeMnc()
+{
+ QVariant var = getProperty("MobileNetworkCode");
+ return qdbus_cast<QString>(var);
+}
+
+// QStringList subscriberNumbers();
+// QMap<QString,QString> serviceNumbers();
+QString QOfonoSimInterface::pinRequired()
+{
+ QVariant var = getProperty("PinRequired");
+ return qdbus_cast<QString>(var);
+}
+
+QString QOfonoSimInterface::lockedPins()
+{
+ QVariant var = getProperty("LockedPins");
+ return qdbus_cast<QString>(var);
+}
+
+QString QOfonoSimInterface::cardIdentifier()
+{
+ QVariant var = getProperty("CardIdentifier");
+ return qdbus_cast<QString>(var);
+}
+
+void QOfonoSimInterface::connectNotify(const char *signal)
+{
+if (QLatin1String(signal) == SIGNAL(propertyChanged(QString,QDBusVariant))) {
+ if(!connection().connect(QLatin1String(OFONO_SERVICE),
+ this->path(),
+ QLatin1String(OFONO_SIM_MANAGER_INTERFACE),
+ QLatin1String("PropertyChanged"),
+ this,SIGNAL(propertyChanged(const QString &, const QDBusVariant & )))) {
+ qWarning() << "PropertyCHanged not connected";
+ }
+ }
+
+ if (QLatin1String(signal) == SIGNAL(propertyChangedContext(QString,QString,QDBusVariant))) {
+ QOfonoDBusHelper *helper;
+ helper = new QOfonoDBusHelper(this);
+
+ dbusConnection.connect(QLatin1String(OFONO_SERVICE),
+ this->path(),
+ QLatin1String(OFONO_SIM_MANAGER_INTERFACE),
+ QLatin1String("PropertyChanged"),
+ helper,SLOT(propertyChanged(QString,QDBusVariant)));
+
+
+ QObject::connect(helper,SIGNAL(propertyChangedContext(const QString &,const QString &,const QDBusVariant &)),
+ this,SIGNAL(propertyChangedContext(const QString &,const QString &,const QDBusVariant &)));
+ }
+}
+
+void QOfonoSimInterface::disconnectNotify(const char *signal)
+{
+ if (QLatin1String(signal) == SIGNAL(propertyChanged(QString,QVariant))) {
+
+ }
+}
+
+QVariant QOfonoSimInterface::getProperty(const QString &property)
+{
+ QVariant var;
+ QVariantMap map = getProperties();
+ if (map.contains(property)) {
+ var = map.value(property);
+ } else {
+ qDebug() << Q_FUNC_INFO << "does not contain" << property;
+ }
+ return var;
+}
+
+QVariantMap QOfonoSimInterface::getProperties()
+{
+ QDBusReply<QVariantMap > reply = this->call(QLatin1String("GetProperties"));
+ return reply.value();
+}
+
+QOfonoDataConnectionManagerInterface::QOfonoDataConnectionManagerInterface(const QString &dbusPathName, QObject *parent)
+ : QDBusAbstractInterface(QLatin1String(OFONO_SERVICE),
+ dbusPathName,
+ OFONO_DATA_CONNECTION_MANAGER_INTERFACE,
+ QDBusConnection::systemBus(), parent)
+{
+}
+
+QOfonoDataConnectionManagerInterface::~QOfonoDataConnectionManagerInterface()
+{
+}
+
+QList<QDBusObjectPath> QOfonoDataConnectionManagerInterface::getPrimaryContexts()
+{
+ QVariant var = getProperty("PrimaryContexts");
+ return qdbus_cast<QList<QDBusObjectPath> >(var);
+}
+
+bool QOfonoDataConnectionManagerInterface::isAttached()
+{
+ QVariant var = getProperty("Attached");
+ return qdbus_cast<bool>(var);
+}
+
+bool QOfonoDataConnectionManagerInterface::isRoamingAllowed()
+{
+ QVariant var = getProperty("RoamingAllowed");
+ return qdbus_cast<bool>(var);
+}
+
+bool QOfonoDataConnectionManagerInterface::isPowered()
+{
+ QVariant var = getProperty("Powered");
+ return qdbus_cast<bool>(var);
+}
+
+void QOfonoDataConnectionManagerInterface::connectNotify(const char *signal)
+{
+if (QLatin1String(signal) == SIGNAL(propertyChanged(QString,QDBusVariant))) {
+ if(!connection().connect(QLatin1String(OFONO_SERVICE),
+ this->path(),
+ QLatin1String(OFONO_DATA_CONNECTION_MANAGER_INTERFACE),
+ QLatin1String("PropertyChanged"),
+ this,SIGNAL(propertyChanged(const QString &, const QDBusVariant & )))) {
+ qWarning() << "PropertyCHanged not connected";
+ }
+ }
+
+ if (QLatin1String(signal) == SIGNAL(propertyChangedContext(QString,QString,QDBusVariant))) {
+ QOfonoDBusHelper *helper;
+ helper = new QOfonoDBusHelper(this);
+
+ dbusConnection.connect(QLatin1String(OFONO_SERVICE),
+ this->path(),
+ QLatin1String(OFONO_DATA_CONNECTION_MANAGER_INTERFACE),
+ QLatin1String("PropertyChanged"),
+ helper,SLOT(propertyChanged(QString,QDBusVariant)));
+
+
+ QObject::connect(helper,SIGNAL(propertyChangedContext(const QString &,const QString &,const QDBusVariant &)),
+ this,SIGNAL(propertyChangedContext(const QString &,const QString &,const QDBusVariant &)));
+ }
+}
+
+void QOfonoDataConnectionManagerInterface::disconnectNotify(const char *signal)
+{
+ if (QLatin1String(signal) == SIGNAL(propertyChanged(QString,QVariant))) {
+
+ }
+}
+
+QVariant QOfonoDataConnectionManagerInterface::getProperty(const QString &property)
+{
+ QVariant var;
+ QVariantMap map = getProperties();
+ if (map.contains(property)) {
+ var = map.value(property);
+ } else {
+ qDebug() << Q_FUNC_INFO << "does not contain" << property;
+ }
+ return var;
+}
+
+QVariantMap QOfonoDataConnectionManagerInterface::getProperties()
+{
+ QDBusReply<QVariantMap > reply = this->call(QLatin1String("GetProperties"));
+ return reply.value();
+}
+
+QOfonoPrimaryDataContextInterface::QOfonoPrimaryDataContextInterface(const QString &dbusPathName, QObject *parent)
+ : QDBusAbstractInterface(QLatin1String(OFONO_SERVICE),
+ dbusPathName,
+ OFONO_DATA_CONTEXT_INTERFACE,
+ QDBusConnection::systemBus(), parent)
+{
+}
+
+QOfonoPrimaryDataContextInterface::~QOfonoPrimaryDataContextInterface()
+{
+}
+
+bool QOfonoPrimaryDataContextInterface::isActive()
+{
+ QVariant var = getProperty("Active");
+ return qdbus_cast<bool>(var);
+}
+
+QString QOfonoPrimaryDataContextInterface::getApName()
+{
+ QVariant var = getProperty("AccessPointName");
+ return qdbus_cast<QString>(var);
+}
+
+QString QOfonoPrimaryDataContextInterface::getType()
+{
+ QVariant var = getProperty("Type");
+ return qdbus_cast<QString>(var);
+}
+
+QString QOfonoPrimaryDataContextInterface::getName()
+{
+ QVariant var = getProperty("Name");
+ return qdbus_cast<QString>(var);
+}
+
+QVariantMap QOfonoPrimaryDataContextInterface::getSettings()
+{
+ QVariant var = getProperty("Settings");
+ return qdbus_cast<QVariantMap>(var);
+}
+
+QString QOfonoPrimaryDataContextInterface::getInterface()
+{
+ QVariant var = getProperty("Interface");
+ return qdbus_cast<QString>(var);
+}
+
+QString QOfonoPrimaryDataContextInterface::getAddress()
+{
+ QVariant var = getProperty("Address");
+ return qdbus_cast<QString>(var);
+}
+
+bool QOfonoPrimaryDataContextInterface::setActive(bool on)
+{
+// this->setProperty("Active", QVariant(on));
+
+ return setProp("Active", qVariantFromValue(on));
+}
+
+bool QOfonoPrimaryDataContextInterface::setApn(const QString &name)
+{
+ return setProp("AccessPointName", QVariant::fromValue(name));
+}
+
+void QOfonoPrimaryDataContextInterface::connectNotify(const char *signal)
+{
+if (QLatin1String(signal) == SIGNAL(propertyChanged(QString,QDBusVariant))) {
+ if(!connection().connect(QLatin1String(OFONO_SERVICE),
+ this->path(),
+ QLatin1String(OFONO_DATA_CONTEXT_INTERFACE),
+ QLatin1String("PropertyChanged"),
+ this,SIGNAL(propertyChanged(const QString &, const QDBusVariant & )))) {
+ qWarning() << "PropertyCHanged not connected";
+ }
+ }
+
+ if (QLatin1String(signal) == SIGNAL(propertyChangedContext(QString,QString,QDBusVariant))) {
+ QOfonoDBusHelper *helper;
+ helper = new QOfonoDBusHelper(this);
+
+ dbusConnection.connect(QLatin1String(OFONO_SERVICE),
+ this->path(),
+ QLatin1String(OFONO_DATA_CONTEXT_INTERFACE),
+ QLatin1String("PropertyChanged"),
+ helper,SLOT(propertyChanged(QString,QDBusVariant)));
+
+
+ QObject::connect(helper,SIGNAL(propertyChangedContext(const QString &,const QString &,const QDBusVariant &)),
+ this,SIGNAL(propertyChangedContext(const QString &,const QString &,const QDBusVariant &)));
+ }
+}
+
+void QOfonoPrimaryDataContextInterface::disconnectNotify(const char *signal)
+{
+ if (QLatin1String(signal) == SIGNAL(propertyChanged(QString,QVariant))) {
+
+ }
+}
+
+QVariant QOfonoPrimaryDataContextInterface::getProperty(const QString &property)
+{
+ QVariant var;
+ QVariantMap map = getProperties();
+ if (map.contains(property)) {
+ var = map.value(property);
+ } else {
+ qDebug() << Q_FUNC_INFO << "does not contain" << property;
+ }
+ return var;
+}
+
+QVariantMap QOfonoPrimaryDataContextInterface::getProperties()
+{
+ QDBusReply<QVariantMap > reply = this->call(QLatin1String("GetProperties"));
+ return reply.value();
+}
+
+bool QOfonoPrimaryDataContextInterface::setProp(const QString &property, const QVariant &var)
+{
+ QList<QVariant> args;
+ args << qVariantFromValue(property) << qVariantFromValue(QDBusVariant(var));
+
+ QDBusMessage reply = this->callWithArgumentList(QDBus::AutoDetect,
+ QLatin1String("SetProperty"),
+ args);
+ bool ok = true;
+ if(reply.type() != QDBusMessage::ReplyMessage) {
+ qWarning() << reply.errorMessage();
+ ok = false;
+ }
+ qWarning() << reply.errorMessage();
+ return ok;
+}
+
+QOfonoSmsInterface::QOfonoSmsInterface(const QString &dbusPathName, QObject *parent)
+ : QDBusAbstractInterface(QLatin1String(OFONO_SERVICE),
+ dbusPathName,
+ OFONO_SMS_MANAGER_INTERFACE,
+ QDBusConnection::systemBus(), parent)
+{
+}
+
+QOfonoSmsInterface::~QOfonoSmsInterface()
+{
+}
+
+void QOfonoSmsInterface::connectNotify(const char *signal)
+{
+ if (QLatin1String(signal) == SIGNAL(propertyChanged(QString,QDBusVariant))) {
+ if(!connection().connect(QLatin1String(OFONO_SERVICE),
+ this->path(),
+ QLatin1String(OFONO_SMS_MANAGER_INTERFACE),
+ QLatin1String("PropertyChanged"),
+ this,SIGNAL(propertyChanged(const QString &, const QDBusVariant & )))) {
+ qWarning() << "PropertyCHanged not connected";
+ }
+ }
+
+ if (QLatin1String(signal) == SIGNAL(propertyChangedContext(QString,QString,QDBusVariant))) {
+ QOfonoDBusHelper *helper;
+ helper = new QOfonoDBusHelper(this);
+
+ dbusConnection.connect(QLatin1String(OFONO_SERVICE),
+ this->path(),
+ QLatin1String(OFONO_SMS_MANAGER_INTERFACE),
+ QLatin1String("PropertyChanged"),
+ helper,SLOT(propertyChanged(QString,QDBusVariant)));
+
+
+ QObject::connect(helper,SIGNAL(propertyChangedContext(const QString &,const QString &,const QDBusVariant &)),
+ this,SIGNAL(propertyChangedContext(const QString &,const QString &,const QDBusVariant &)));
+ }
+
+ if (QLatin1String(signal) == SIGNAL(immediateMessage(QString,QVariantMap))) {
+ if(!connection().connect(QLatin1String(OFONO_SERVICE),
+ this->path(),
+ QLatin1String(OFONO_SMS_MANAGER_INTERFACE),
+ QLatin1String("ImmediateMessage"),
+ this,SIGNAL(immediateMessage(QString,QVariantMap )))) {
+ qWarning() << "PropertyCHanged not connected";
+ }
+ }
+
+ if (QLatin1String(signal) == SIGNAL(incomingMessage(QString,QVariantMap))) {
+ if(!connection().connect(QLatin1String(OFONO_SERVICE),
+ this->path(),
+ QLatin1String(OFONO_SMS_MANAGER_INTERFACE),
+ QLatin1String("IncomingMessage"),
+ this,SIGNAL(incomingMessage(QString,QVariantMap)))) {
+ qWarning() << "PropertyCHanged not connected";
+ }
+ }
+}
+
+void QOfonoSmsInterface::disconnectNotify(const char *signal)
+{
+ if (QLatin1String(signal) == SIGNAL(propertyChanged(QString,QVariant))) {
+
+ }
+}
+
+QVariant QOfonoSmsInterface::getProperty(const QString &property)
+{
+ QVariant var;
+ QVariantMap map = getProperties();
+ if (map.contains(property)) {
+ var = map.value(property);
+ } else {
+ qDebug() << Q_FUNC_INFO << "does not contain" << property;
+ }
+ return var;
+}
+
+QVariantMap QOfonoSmsInterface::getProperties()
+{
+ QDBusReply<QVariantMap > reply = this->call(QLatin1String("GetProperties"));
+ return reply.value();
+}
+
+void QOfonoSmsInterface::sendMessage(const QString &to, const QString &message)
+{
+ QDBusReply<QString> reply = this->call(QLatin1String("SendMessage"),
+ QVariant::fromValue(to),
+ QVariant::fromValue(message));
+ bool ok = true;
+ if(reply.error().type() == QDBusError::InvalidArgs) {
+ qWarning() << reply.error().message();
+ ok = false;
+ }
+}
+
+QT_END_NAMESPACE
diff --git a/src/plugins/bearer/connman/qofonoservice_linux_p.h b/src/plugins/bearer/connman/qofonoservice_linux_p.h
new file mode 100644
index 0000000..4892666
--- /dev/null
+++ b/src/plugins/bearer/connman/qofonoservice_linux_p.h
@@ -0,0 +1,332 @@
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QOFONOSERVICE_H
+#define QOFONOSERVICE_H
+
+//
+// W A R N I N G
+// -------------
+//
+// This file is not part of the Qt API. It exists purely as an
+// implementation detail. This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <QtDBus/QtDBus>
+#include <QtDBus/QDBusConnection>
+#include <QtDBus/QDBusError>
+#include <QtDBus/QDBusInterface>
+#include <QtDBus/QDBusMessage>
+#include <QtDBus/QDBusReply>
+
+#include <QtDBus/QDBusPendingCallWatcher>
+#include <QtDBus/QDBusObjectPath>
+#include <QtDBus/QDBusContext>
+#include <QMap>
+
+#define OFONO_SERVICE "org.ofono"
+#define OFONO_MANAGER_INTERFACE "org.ofono.Manager"
+#define OFONO_MANAGER_PATH "/"
+#define OFONO_MODEM_INTERFACE "org.ofono.Modem"
+#define OFONO_NETWORK_REGISTRATION_INTERFACE "org.ofono.NetworkRegistration"
+#define OFONO_NETWORK_OPERATOR_INTERFACE "org.ofono.NetworkOperator"
+#define OFONO_DATA_CONNECTION_MANAGER_INTERFACE "org.ofono.DataConnectionManager"
+#define OFONO_SIM_MANAGER_INTERFACE "org.ofono.SimManager"
+#define OFONO_DATA_CONTEXT_INTERFACE "org.ofono.PrimaryDataContext"
+
+#define OFONO_SMS_MANAGER_INTERFACE "org.ofono.SmsManager"
+#define OFONO_PHONEBOOK_INTERFACE "org.ofono.Phonebook"
+#define OFONO_MESSAGE_WAITING_INTERFACE "org.ofono.MessageWaiting"
+
+
+
+QT_BEGIN_NAMESPACE
+
+QT_END_NAMESPACE
+
+
+QT_BEGIN_NAMESPACE
+
+class QOfonoManagerInterface : public QDBusAbstractInterface
+{
+ Q_OBJECT
+
+public:
+
+ QOfonoManagerInterface( QObject *parent = 0);
+ ~QOfonoManagerInterface();
+
+ QDBusObjectPath path() const;
+
+ QVariantMap getProperties();
+ bool setProperty(const QString &name, const QDBusVariant &value);
+ QList <QDBusObjectPath> getModems();
+ QDBusObjectPath currentModem();
+
+Q_SIGNALS:
+ void propertyChanged(const QString &, const QDBusVariant &value);
+ void propertyChangedContext(const QString &,const QString &,const QDBusVariant &);
+protected:
+ void connectNotify(const char *signal);
+ void disconnectNotify(const char *signal);
+ QVariant getProperty(const QString &);
+
+};
+
+
+class QOfonoDBusHelper: public QObject, protected QDBusContext
+ {
+ Q_OBJECT
+ public:
+ QOfonoDBusHelper(QObject *parent = 0);
+ ~QOfonoDBusHelper();
+
+ public slots:
+ void propertyChanged(const QString &, const QDBusVariant &);
+ Q_SIGNALS:
+ void propertyChangedContext(const QString &,const QString &,const QDBusVariant &);
+};
+
+class QOfonoModemInterface : public QDBusAbstractInterface
+{
+ Q_OBJECT
+
+public:
+
+ QOfonoModemInterface(const QString &dbusModemPathName, QObject *parent = 0);
+ ~QOfonoModemInterface();
+
+ QVariantMap getProperties();
+ //properties
+ bool isPowered();
+ bool isOnline();
+ QString getName();
+ QString getManufacturer();
+ QString getModel();
+ QString getRevision();
+ QString getSerial();
+
+ QStringList getFeatures(); //sms, sim
+ QStringList getInterfaces();
+ QString defaultInterface();
+
+protected:
+ void connectNotify(const char *signal);
+ void disconnectNotify(const char *signal);
+ QVariant getProperty(const QString &);
+Q_SIGNALS:
+ void propertyChanged(const QString &, const QDBusVariant &value);
+ void propertyChangedContext(const QString &,const QString &,const QDBusVariant &);
+};
+
+
+class QOfonoNetworkRegistrationInterface : public QDBusAbstractInterface
+{
+ Q_OBJECT
+
+public:
+
+ QOfonoNetworkRegistrationInterface(const QString &dbusModemPathName, QObject *parent = 0);
+ ~QOfonoNetworkRegistrationInterface();
+
+ QVariantMap getProperties();
+
+ //properties
+ QString getStatus();
+ quint16 getLac();
+ quint32 getCellId();
+ QString getTechnology();
+ QString getOperatorName();
+ int getSignalStrength();
+ QString getBaseStation();
+ QList <QDBusObjectPath> getOperators();
+
+protected:
+ void connectNotify(const char *signal);
+ void disconnectNotify(const char *signal);
+ QVariant getProperty(const QString &);
+Q_SIGNALS:
+ void propertyChanged(const QString &, const QDBusVariant &value);
+ void propertyChangedContext(const QString &,const QString &,const QDBusVariant &);
+
+};
+
+class QOfonoNetworkOperatorInterface : public QDBusAbstractInterface
+{
+ Q_OBJECT
+
+public:
+//modem or operator paths
+ QOfonoNetworkOperatorInterface(const QString &dbusPathName, QObject *parent = 0);
+ ~QOfonoNetworkOperatorInterface();
+
+ QVariantMap getProperties();
+
+ //properties
+ QString getName();
+ QString getStatus();// "unknown", "available", "current" and "forbidden"
+ QString getMcc();
+ QString getMnc();
+ QStringList getTechnologies();
+
+protected:
+ void connectNotify(const char *signal);
+ void disconnectNotify(const char *signal);
+ QVariant getProperty(const QString &);
+};
+
+class QOfonoSimInterface : public QDBusAbstractInterface
+{
+ Q_OBJECT
+
+public:
+
+ QOfonoSimInterface(const QString &dbusModemPathName, QObject *parent = 0);
+ ~QOfonoSimInterface();
+
+ QVariantMap getProperties();
+
+ //properties
+ bool isPresent();
+ QString getHomeMcc();
+ QString getHomeMnc();
+// QStringList subscriberNumbers();
+// QMap<QString,QString> serviceNumbers();
+ QString pinRequired();
+ QString lockedPins();
+ QString cardIdentifier();
+
+protected:
+ void connectNotify(const char *signal);
+ void disconnectNotify(const char *signal);
+ QVariant getProperty(const QString &);
+};
+
+
+class QOfonoDataConnectionManagerInterface : public QDBusAbstractInterface
+{
+ Q_OBJECT
+
+public:
+
+ QOfonoDataConnectionManagerInterface(const QString &dbusPathName, QObject *parent = 0);
+ ~QOfonoDataConnectionManagerInterface();
+
+ QVariantMap getProperties();
+
+ //properties
+ QList<QDBusObjectPath> getPrimaryContexts();
+ bool isAttached();
+ bool isRoamingAllowed();
+ bool isPowered();
+
+ bool setPower(bool on);
+
+protected:
+ void connectNotify(const char *signal);
+ void disconnectNotify(const char *signal);
+ QVariant getProperty(const QString &);
+};
+
+
+class QOfonoPrimaryDataContextInterface : public QDBusAbstractInterface
+{
+ Q_OBJECT
+
+public:
+
+ QOfonoPrimaryDataContextInterface(const QString &dbusPathName, QObject *parent = 0);
+ ~QOfonoPrimaryDataContextInterface();
+
+ QVariantMap getProperties();
+
+ //properties
+ bool isActive();
+ QString getApName();
+ QString getType();
+ QString getName();
+ QVariantMap getSettings();
+ QString getInterface();
+ QString getAddress();
+
+ bool setActive(bool on);
+ bool setApn(const QString &name);
+
+protected:
+ void connectNotify(const char *signal);
+ void disconnectNotify(const char *signal);
+ QVariant getProperty(const QString &);
+ bool setProp(const QString &, const QVariant &var);
+};
+
+class QOfonoSmsInterface : public QDBusAbstractInterface
+{
+ Q_OBJECT
+
+public:
+
+ QOfonoSmsInterface(const QString &dbusModemPathName, QObject *parent = 0);
+ ~QOfonoSmsInterface();
+
+ QVariantMap getProperties();
+ void sendMessage(const QString &to, const QString &message);
+
+ //properties
+ QString serviceCenterAddress();
+ bool useDeliveryReports();
+ QString bearer();
+
+protected:
+ void connectNotify(const char *signal);
+ void disconnectNotify(const char *signal);
+ QVariant getProperty(const QString &);
+
+Q_SIGNALS:
+ void propertyChanged(const QString &, const QDBusVariant &value);
+ void propertyChangedContext(const QString &,const QString &,const QDBusVariant &);
+ void immediateMessage(const QString &message, const QVariantMap &info);
+ void incomingMessage(const QString &message, const QVariantMap &info);
+};
+
+#endif //QOFONOSERVICE_H
generated by cgit v0.12 at 2024-11-12 16:47:40 (GMT)