[prev in list] [next in list] [prev in thread] [next in thread] 

List:       kde-commits
Subject:    [libmm-qt] /: Merge branch 'mm08'
From:       Lamarque V. Souza <lamarque () kde ! org>
Date:       2013-09-30 19:38:53
Message-ID: E1VQjIz-0001K7-0f () scm ! kde ! org
[Download RAW message or body]

Git commit 0b461c3fff6731149ce3d65d51a8bafff70a26d1 by Lamarque V. Souza.
Committed on 30/09/2013 at 18:39.
Pushed by lvsouza into branch 'master'.

Merge branch 'mm08'

Conflicts:
	dbus/dbus.h
	dbus/generic-types.h
	dbus/introspection/mm-modem-gsm-card.xml
	dbus/mm-modem-gsm-cardinterface.cpp
	dbus/mm-modem-gsm-cardinterface.h
	manager.cpp
	modembearerinterface_p.h
	modemgsmcardinterface.cpp
	modemgsmcardinterface.h
	modemgsmcardinterface_p.h
	modemgsmcontactsinterface.h
	modemgsmnetworkinterface.h
	modemgsmnetworkinterface_p.h
	modemgsmsmsinterface.cpp
	modemgsmsmsinterface.h
	modemtimeinterface.h
	modemtimeinterface_p.h

M  +47   -23   CMakeLists.txt
M  +59   -49   dbus/generic-types.h
M  +139  -89   manager.cpp
M  +14   -6    manager.h
M  +14   -11   manager_p.h
M  +21   -32   modemcdmainterface.h
M  +2    -3    modemcdmainterface_p.h
M  +38   -67   modemgsmcardinterface.cpp
M  +22   -25   modemgsmcardinterface.h
M  +6    -12   modemgsmcardinterface_p.h
M  +20   -16   modemgsmussdinterface.h
M  +4    -5    modemgsmussdinterface_p.h
M  +141  -150  modeminterface.h
M  +8    -14   modeminterface_p.h
M  +18   -14   modemlocationinterface.h
M  +2    -3    modemlocationinterface_p.h

http://commits.kde.org/libmm-qt/0b461c3fff6731149ce3d65d51a8bafff70a26d1

diff --cc dbus/generic-types.h
index 71ec9cd,37866d4..19101d8
--- a/dbus/generic-types.h
+++ b/dbus/generic-types.h
@@@ -18,75 -19,84 +19,84 @@@ You should have received a copy of the 
  License along with this library.  If not, see <http://www.gnu.org/licenses/>.
  */
  
 -#ifndef MODEMMANAGER_GENERIC_TYPES_H
 -#define MODEMMANAGER_GENERIC_TYPES_H
 +#ifndef MODEMMANAGERQT_GENERIC_TYPES_H
 +#define MODEMMANAGERQT_GENERIC_TYPES_H
  
+ #include <ModemManager/ModemManager.h>
+ 
  #include <QMetaType>
- #include <QDBusArgument>
  #include <QtDBus/QtDBus>
  
- #include "manager.h"
- #include "modemlocationinterface.h"
- #include "modemcdmainterface.h"
- #include "modemgsmcontactsinterface.h"
- #include "modemgsmnetworkinterface.h"
- //#include "networkipv4config.h"
+ typedef QMap<QString, QVariantMap> NMVariantMapMap;
+ Q_DECLARE_METATYPE(NMVariantMapMap)
+ 
+ typedef QMap<QDBusObjectPath, NMVariantMapMap> DBUSManagerStruct;
+ Q_DECLARE_METATYPE(DBUSManagerStruct)
+ 
+ typedef QList<uint> UIntList;
+ Q_DECLARE_METATYPE(UIntList)
  
- typedef QList<QVariantMap> QVariantMapList;
+ typedef QList<QList<uint> > UIntListList;
+ Q_DECLARE_METATYPE(UIntListList)
  
- Q_DECLARE_METATYPE(ModemManager::ModemInterface::Ip4ConfigType)
- Q_DECLARE_METATYPE(ModemManager::ModemInterface::InfoType)
- Q_DECLARE_METATYPE(ModemManager::ModemLocationInterface::LocationInformationMap)
- Q_DECLARE_METATYPE(ModemManager::ModemCdmaInterface::ServingSystemType)
- Q_DECLARE_METATYPE(ModemManager::ModemCdmaInterface::RegistrationStateResult)
- Q_DECLARE_METATYPE(ModemManager::ModemGsmContactsInterface::ContactType)
- Q_DECLARE_METATYPE(ModemManager::ModemGsmContactsInterface::ContactTypeList)
- Q_DECLARE_METATYPE(ModemManager::ModemGsmNetworkInterface::ScanResultsType)
- Q_DECLARE_METATYPE(ModemManager::ModemGsmNetworkInterface::RegistrationInfoType)
- Q_DECLARE_METATYPE(QList<QVariantMap>)
+ typedef QMap<QString, QString> NMStringMap;
+ Q_DECLARE_METATYPE(NMStringMap)
  
- // ModemManager::ModemManager::Modem::Ip4Configtype
- QDBusArgument &operator << (QDBusArgument &arg,
-     const ModemManager::ModemInterface::Ip4ConfigType &config);
+ typedef struct {
+     uint signal;
+     bool recent;
+ } SignalQualityPair;
+ Q_DECLARE_METATYPE(SignalQualityPair)
  
- const QDBusArgument &operator >> (const QDBusArgument &arg,
-     ModemManager::ModemInterface::Ip4ConfigType &config);
+ Q_DECLARE_BUILTIN_METATYPE(MMModemMode, UInt)
+ typedef struct {
+ public:
+     MMModemMode allowed; // bitfield
+     MMModemMode prefered;
+ } CurrentModesType;
+ Q_DECLARE_METATYPE(CurrentModesType)
  
- // ModemManager::ModemManager::Modem::InfoType
- QDBusArgument &operator << (QDBusArgument &arg,
-     const ModemManager::ModemInterface::InfoType &info);
+ typedef QList<CurrentModesType> SupportedModesType;
+ Q_DECLARE_METATYPE(SupportedModesType)
  
- const QDBusArgument &operator >> (const QDBusArgument &arg,
-     ModemManager::ModemInterface::InfoType &info);
+ Q_DECLARE_BUILTIN_METATYPE(MMModemLock, UInt)
+ typedef QMap</*MMModemLock*/uint, uint> UnlockRetriesMap;
+ Q_DECLARE_METATYPE(UnlockRetriesMap)
  
- // ModemManager::ModemCdmaInterface::ServingSystemType
- QDBusArgument &operator << (QDBusArgument &arg,
-     const ModemManager::ModemCdmaInterface::ServingSystemType &servingSystem);
+ typedef QList<QVariantMap> ScanResultsType;
+ Q_DECLARE_METATYPE(ScanResultsType)
  
- const QDBusArgument &operator >> (const QDBusArgument &arg,
-     ModemManager::ModemCdmaInterface::ServingSystemType &servingSystem);
+ Q_DECLARE_BUILTIN_METATYPE(MMModemLocationSource, UInt)
+ typedef QMap<MMModemLocationSource, QVariant> LocationInformationMap;
+ Q_DECLARE_METATYPE(LocationInformationMap)
  
- // ModemManager::ModemGsmContactsInterface::ContactType
- QDBusArgument &operator << (QDBusArgument &arg,
-     const ModemManager::ModemGsmContactsInterface::ContactType &contact);
+ Q_DECLARE_BUILTIN_METATYPE(MMSmsValidityType, UInt)
+ typedef struct {
+     MMSmsValidityType validity;
+     uint value;
+ } ValidityPair;
+ Q_DECLARE_METATYPE(ValidityPair)
  
- const QDBusArgument &operator >> (const QDBusArgument &arg,
-     ModemManager::ModemGsmContactsInterface::ContactType &contact);
+ // CurrentModesType
+ QDBusArgument &operator << (QDBusArgument &arg, const CurrentModesType &mode);
+ const QDBusArgument &operator >> (const QDBusArgument &arg, CurrentModesType &mode);
  
- // ModemManager::ModemManager::Modem::Gsm::Network::RegistrationInfoType
- QDBusArgument &operator << (QDBusArgument &arg,
-     const ModemManager::ModemGsmNetworkInterface::RegistrationInfoType &info);
+ // SignalQualityPair
+ QDBusArgument &operator << (QDBusArgument &arg, const SignalQualityPair &sqp);
+ const QDBusArgument &operator >> (const QDBusArgument &arg, SignalQualityPair &sqp);
  
- const QDBusArgument &operator >> (const QDBusArgument &arg,
-     ModemManager::ModemGsmNetworkInterface::RegistrationInfoType &info);
+ // ValidityPair
+ QDBusArgument &operator << (QDBusArgument &arg, const ValidityPair &vp);
+ const QDBusArgument &operator >> (const QDBusArgument &arg, ValidityPair &vp);
  
  inline void registerModemManagerTypes() {
-         qDBusRegisterMetaType<ModemManager::ModemInterface::Ip4ConfigType>();
-         qDBusRegisterMetaType<ModemManager::ModemInterface::InfoType>();
-         qDBusRegisterMetaType<ModemManager::ModemCdmaInterface::ServingSystemType>();
-         qDBusRegisterMetaType<ModemManager::ModemGsmContactsInterface::ContactType>();
-         qDBusRegisterMetaType<ModemManager::ModemGsmNetworkInterface::RegistrationInfoType>();
-         qDBusRegisterMetaType<QList<QVariantMap> >();
+     qDBusRegisterMetaType<CurrentModesType>();
+     qDBusRegisterMetaType<SignalQualityPair>();
+     qDBusRegisterMetaType<SupportedModesType>();
+     qDBusRegisterMetaType<UnlockRetriesMap>();
+     qDBusRegisterMetaType<ScanResultsType>();
+     //qDBusRegisterMetaType<LocationInformationMap>();
+     qDBusRegisterMetaType<ValidityPair>();
  }
  
 -#endif // MODEMMANAGER_TYPES_H
 +#endif // MODEMMANAGERQT_TYPES_H
diff --cc manager.cpp
index aaf82d3,74f6773..ce94b6c
--- a/manager.cpp
+++ b/manager.cpp
@@@ -37,17 -36,38 +36,38 @@@ License along with this library.  If no
  
  MM_GLOBAL_STATIC(ModemManager::ModemManagerPrivate, globalModemManager)
  
--ModemManager::ModemManagerPrivate::ModemManagerPrivate() :
-     watcher(ModemManager::DBUS_SERVICE, QDBusConnection::systemBus(), \
                QDBusServiceWatcher::WatchForRegistration | QDBusServiceWatcher::WatchForUnregistration, \
                this),
-     iface(ModemManager::DBUS_SERVICE, ModemManager::DBUS_DAEMON_PATH, QDBusConnection::systemBus())
 -    watcher(MM_DBUS_SERVICE, QDBusConnection::systemBus(), QDBusServiceWatcher::WatchForRegistration | \
                QDBusServiceWatcher::WatchForUnregistration, this),
 -    iface(MM_DBUS_SERVICE, MM_DBUS_PATH, QDBusConnection::systemBus(), this),
 -    manager(MM_DBUS_SERVICE, MM_DBUS_PATH, QDBusConnection::systemBus(), this)
++ModemManager::ModemManagerPrivate::ModemManagerPrivate()
++    : watcher(MM_DBUS_SERVICE, QDBusConnection::systemBus(), QDBusServiceWatcher::WatchForRegistration \
| QDBusServiceWatcher::WatchForUnregistration, this) ++    , iface(MM_DBUS_SERVICE, MM_DBUS_PATH, \
QDBusConnection::systemBus(), this) ++    , manager(MM_DBUS_SERVICE, MM_DBUS_PATH, \
QDBusConnection::systemBus(), this)  {
      qDBusRegisterMetaType<QList<QDBusObjectPath> >();
+     qDBusRegisterMetaType<NMVariantMapMap>();
+     qDBusRegisterMetaType<DBUSManagerStruct>();
+     qDBusRegisterMetaType<UIntList>();
      registerModemManagerTypes();
  
-     connect(&iface, SIGNAL(DeviceAdded(QDBusObjectPath)),
-             this, SLOT(deviceAdded(QDBusObjectPath)));
-     connect(&iface, SIGNAL(DeviceRemoved(QDBusObjectPath)),
-             this, SLOT(deviceRemoved(QDBusObjectPath)));
+     bool serviceFound = manager.isValid();
+     if (!serviceFound) {
+         // find out whether it will be activated automatically
+         QDBusMessage message = QDBusMessage::createMethodCall("org.freedesktop.DBus",
+                                                               "/org/freedesktop/DBus",
+                                                               "org.freedesktop.DBus",
+                                                               "ListActivatableNames");
+ 
+         QDBusReply<QStringList> reply = QDBusConnection::systemBus().call(message);
+         if (reply.isValid() && reply.value().contains(MM_DBUS_SERVICE)) {
+             QDBusConnection::systemBus().interface()->startService(MM_DBUS_SERVICE);
+             serviceFound = true;
+         }
+     }
+ 
+     if (serviceFound) {
+         connect(&manager, SIGNAL(InterfacesAdded(QDBusObjectPath,NMVariantMapMap)),
+                 this, SLOT(onInterfacesAdded(QDBusObjectPath,NMVariantMapMap)));
+         connect(&manager, SIGNAL(InterfacesRemoved(QDBusObjectPath,QStringList)),
+                 this, SLOT(onInterfacesRemoved(QDBusObjectPath,QStringList)));
+     }
  
      connect(&watcher, SIGNAL(serviceRegistered(QString)), SLOT(daemonRegistered()));
      connect(&watcher, SIGNAL(serviceUnregistered(QString)), SLOT(daemonUnregistered()));
@@@ -60,75 -81,62 +81,62 @@@ ModemManager::ModemManagerPrivate::~Mod
  
  void ModemManager::ModemManagerPrivate::init()
  {
-     QDBusReply< QList<QDBusObjectPath> > deviceList = iface.EnumerateDevices();
-     if (deviceList.isValid())
-     {
-         QList <QDBusObjectPath> devices = deviceList.value();
-         foreach (const QDBusObjectPath &op, devices)
-         {
-             modemMap.insert(op.path(), ModemInterfaceIfaceMap());
-             mmDebug() << "  " << op.path();
-         }
-     } else {
-         mmDebug() << "Error getting device list: " << deviceList.error().name() << ": " << \
                deviceList.error().message();
-     }
- }
+     devices.clear();
  
- ModemManager::ModemInterface::Ptr ModemManager::ModemManagerPrivate::findModemInterface(const QString \
                &udi, const ModemManager::ModemInterface::GsmInterfaceType ifaceType)
- {
-     ModemManager::ModemInterface::Ptr modem;
-     QMap<QString, ModemInterfaceIfaceMap>::ConstIterator mapIt = modemMap.constFind(udi);
-     if (mapIt != modemMap.constEnd()) {
-         ModemInterfaceIfaceMap map = modemMap.value(udi);
-         if (map.contains(ifaceType)) {
-             modem = map.value(ifaceType);
-         } else {
-             modem = createModemInterface(udi, ifaceType);
-             if (modem) {
-                 map.insert(ifaceType, modem);
-                 modemMap.insert(udi, map);
-             }
+     QDBusPendingReply<DBUSManagerStruct> reply = manager.GetManagedObjects();
+     reply.waitForFinished();
+     if (!reply.isError()) {  // enum devices
+         Q_FOREACH(const QDBusObjectPath &path, reply.value().keys()) {
+             const QString udi = path.path();
+             mmDebug() << "Adding device" << udi;
+ 
+             if (udi == MM_DBUS_PATH || !udi.startsWith(MM_DBUS_MODEM_PREFIX)) // TODO checkme
+                 continue;
+ 
+             devices.append(udi);
          }
+     } else { // show error
+         qWarning() << "Failed enumerating MM objects:" << reply.error().name() << "\n" << \
reply.error().message();  }
-     return modem;
  }
  
- ModemManager::ModemInterface::Ptr ModemManager::ModemManagerPrivate::createModemInterface(const QString \
&udi, const ModemManager::ModemInterface::GsmInterfaceType ifaceType) + ModemManager::ModemInterface::Ptr \
ModemManager::ModemManagerPrivate::findModemInterface(const QString &udi, ModemInterface::InterfaceType \
ifaceType)  {
      mmDebug();
-     OrgFreedesktopModemManagerModemInterface modemIface(ModemManager::DBUS_SERVICE, udi, \
                QDBusConnection::systemBus());
-     uint modemType = modemIface.type();
+ 
+     ModemInterface modem(udi, this);
      ModemInterface::Ptr createdInterface;
-     switch ( modemType ) {
-     case ModemInterface::GsmType:
-         switch (ifaceType) {
-         case ModemInterface::GsmCard:
-             createdInterface = ModemInterface::Ptr(new ModemGsmCardInterface(udi, this));
-             break;
-         case ModemInterface::GsmContacts:
-             createdInterface = ModemInterface::Ptr(new ModemGsmContactsInterface(udi, this));
-             break;
-         case ModemInterface::GsmNetwork:
-             createdInterface = ModemInterface::Ptr(new ModemGsmNetworkInterface(udi, this));
-             break;
-         case ModemInterface::GsmSms:
-             createdInterface = ModemInterface::Ptr(new ModemGsmSmsInterface(udi, this));
-             break;
-         case ModemInterface::GsmHso:
-             createdInterface = ModemInterface::Ptr(new ModemGsmHsoInterface(udi, this));
-             break;
-         case ModemInterface::GsmUssd:
-             createdInterface = ModemInterface::Ptr(new ModemGsmUssdInterface(udi, this));
-             break;
-         case ModemInterface::NotGsm: // to prevent compilation warning
-             break;
-         }
+ 
+     if (!modem.isValid())
+         return createdInterface;
+ 
+     switch (ifaceType) {
+     case ModemInterface::Gsm:
+         if (modem.hasInterface(MM_DBUS_INTERFACE_MODEM_MODEM3GPP))
+             createdInterface = ModemInterface::Ptr(new Modem3gppInterface(udi, this));
+         break;
+     case ModemInterface::Messaging:
+         if (modem.hasInterface(MM_DBUS_INTERFACE_MODEM_MESSAGING))
+             createdInterface = ModemInterface::Ptr(new ModemMessagingInterface(udi, this));
+         break;
+     case ModemInterface::GsmUssd:
+         if (modem.hasInterface(MM_DBUS_INTERFACE_MODEM_MODEM3GPP_USSD))
+             createdInterface = ModemInterface::Ptr(new Modem3gppUssdInterface(udi, this));
          break;
-     case ModemInterface::CdmaType:
-         createdInterface = ModemInterface::Ptr(new ModemCdmaInterface(udi, this));
+     case ModemInterface::Cdma:
+         if (modem.hasInterface(MM_DBUS_INTERFACE_MODEM_MODEMCDMA))
+             createdInterface = ModemInterface::Ptr(new ModemCdmaInterface(udi, this));
+         break;
+     case ModemInterface::Location:
+         if (modem.hasInterface(MM_DBUS_INTERFACE_MODEM_LOCATION))
+             createdInterface = ModemInterface::Ptr(new ModemLocationInterface(udi, this));
+         break;
+     case ModemInterface::Time:
+         if (modem.hasInterface(MM_DBUS_INTERFACE_MODEM_TIME))
+             createdInterface = ModemInterface::Ptr(new ModemTimeInterface(udi, this));
          break;
      default:
-         mmDebug() << "ModemManagerQt: Can't create object of type " << modemType << "for" << udi;
 -        mmDebug() << "libQtModemManager: Can't create object of type " << ifaceType << "for" << udi;
++        mmDebug() << "ModemManagerQt: Can't create object of type " << ifaceType << "for" << udi;
          break;
      }
  
diff --cc modemcdmainterface_p.h
index 23a2ced,7ac8960..4fa7933
--- a/modemcdmainterface_p.h
+++ b/modemcdmainterface_p.h
@@@ -19,11 -19,11 +19,11 @@@ You should have received a copy of the 
  License along with this library.  If not, see <http://www.gnu.org/licenses/>.
  */
  
 -#ifndef MODEMMANAGER_MODEMCDMAINTERFACE_P_H
 -#define MODEMMANAGER_MODEMCDMAINTERFACE_P_H
 +#ifndef MODEMMANAGERQT_MODEMCDMAINTERFACE_P_H
 +#define MODEMMANAGERQT_MODEMCDMAINTERFACE_P_H
  
  #include "modeminterface_p.h"
- #include "dbus/mm-modem-cdmainterface.h"
+ #include "dbus/ModemCdma.h"
  
  class ModemCdmaInterfacePrivate: public ModemInterfacePrivate
  {
diff --cc modemgsmcardinterface.h
index ff81d49,f77320c..c442999
--- a/modemgsmcardinterface.h
+++ b/modemgsmcardinterface.h
@@@ -52,18 -55,13 +55,12 @@@ public
      QDBusPendingReply<> enablePin(const QString & pin, bool enabled);
      QDBusPendingReply<> changePin(const QString & oldPin, const QString & newPin);
  
-     // Properties
-     ModemManager::ModemInterface::Band getSupportedBands() const; // deprecated
-     ModemManager::ModemInterface::Mode getSupportedModes() const;
-     QString simIdentifier() const;
+ #if 0
  Q_SIGNALS:
-     // properties
-     void supportedBandsChanged(const ModemManager::ModemInterface::Band band);
-     void supportedModesChanged(const ModemManager::ModemInterface::Mode modes);
-     void simIdentifierChanged(const QString &simIdentifier);
  
 -
  private Q_SLOTS:
--    void propertiesChanged(const QString & interface, const QVariantMap & properties);
++    void propertiesChanged(const QString &interface, const QVariantMap &properties);
+ #endif
  
  };
  } // namespace ModemManager
diff --cc modemgsmcardinterface_p.h
index 4c96e95,d7f9262..31fbc45
--- a/modemgsmcardinterface_p.h
+++ b/modemgsmcardinterface_p.h
@@@ -19,22 -19,17 +19,17 @@@ You should have received a copy of the 
  License along with this library.  If not, see <http://www.gnu.org/licenses/>.
  */
  
- #ifndef MODEMMANAGERQT_MODEMGSMCARDINTERFACE_P_H
- #define MODEMMANAGERQT_MODEMGSMCARDINTERFACE_P_H
+ #ifndef MODEMMANAGER_MODEMSIMCARDINTERFACE_P_H
+ #define MODEMMANAGER_MODEMSIMCARDINTERFACE_P_H
  
  #include "modeminterface_p.h"
- #include "dbus/mm-modem-gsm-cardinterface.h"
- #include "modeminterface.h"
+ #include "dbus/Sim.h"
  
- class ModemGsmCardInterfacePrivate: public ModemInterfacePrivate
+ class ModemSimCardInterfacePrivate: public ModemInterfacePrivate
  {
  public:
-     ModemGsmCardInterfacePrivate(const QString &path, QObject *owner);
-     OrgFreedesktopModemManagerModemGsmCardInterface modemGsmCardIface;
- 
-     ModemManager::ModemInterface::Band supportedBands;
-     ModemManager::ModemInterface::Mode supportedModes;
-     QString simIdentifier;
 -    ModemSimCardInterfacePrivate(const QString &path, QObject * owner);
++    ModemSimCardInterfacePrivate(const QString &path, QObject *owner);
+     OrgFreedesktopModemManager1SimInterface modemSimCardIface;
  };
  
  #endif
diff --cc modemgsmussdinterface_p.h
index 318298b,6b3bd79..6d580c3
--- a/modemgsmussdinterface_p.h
+++ b/modemgsmussdinterface_p.h
@@@ -19,17 -19,17 +19,17 @@@ You should have received a copy of the 
  License along with this library.  If not, see <http://www.gnu.org/licenses/>.
  */
  
 -#ifndef MODEMMANAGER_MODEMGSMUSSDINTERFACE_P_H
 -#define MODEMMANAGER_MODEMGSMUSSDINTERFACE_P_H
 +#ifndef MODEMMANAGERQT_MODEMGSMUSSDINTERFACE_P_H
 +#define MODEMMANAGERQT_MODEMGSMUSSDINTERFACE_P_H
  
  #include "modeminterface_p.h"
- #include "dbus/mm-modem-gsm-ussdinterface.h"
+ #include "dbus/Modem3gppUssd.h"
  
- class ModemGsmUssdInterfacePrivate: public ModemInterfacePrivate
+ class Modem3gppUssdInterfacePrivate: public ModemInterfacePrivate
  {
  public:
-     ModemGsmUssdInterfacePrivate(const QString &path, QObject *owner);
-     OrgFreedesktopModemManagerModemGsmUssdInterface modemGsmUssdIface;
+     Modem3gppUssdInterfacePrivate(const QString &path, QObject *owner);
+     OrgFreedesktopModemManager1ModemModem3gppUssdInterface ussdIface;
  };
  
  #endif
diff --cc modeminterface.h
index 36adfff,abf0a57..e3ae08b
--- a/modeminterface.h
+++ b/modeminterface.h
@@@ -20,9 -21,11 +21,11 @@@ You should have received a copy of the 
  License along with this library.  If not, see <http://www.gnu.org/licenses/>.
  */
  
 -#ifndef MODEMMANAGER_MODEMINTERFACE_H
 -#define MODEMMANAGER_MODEMINTERFACE_H
 +#ifndef MODEMMANAGERQT_MODEMINTERFACE_H
 +#define MODEMMANAGERQT_MODEMINTERFACE_H
  
+ #include <ModemManager/ModemManager.h>
+ 
  #include "ModemManagerQt-export.h"
  
  #include <QObject>
diff --cc modeminterface_p.h
index f4b013f,7baca51..9240e2b
--- a/modeminterface_p.h
+++ b/modeminterface_p.h
@@@ -19,28 -19,23 +19,23 @@@ You should have received a copy of the 
  License along with this library.  If not, see <http://www.gnu.org/licenses/>.
  */
  
 -#ifndef MODEMMANAGER_MODEMINTERFACE_P_H
 -#define MODEMMANAGER_MODEMINTERFACE_P_H
 +#ifndef MODEMMANAGERQT_MODEMINTERFACE_P_H
 +#define MODEMMANAGERQT_MODEMINTERFACE_P_H
  
- #include "dbus/mm-modeminterface.h"
- #include "dbus/mm-modem-simpleinterface.h"
+ #include "dbus/Modem.h"
+ #include "dbus/ModemSimple.h"
  
- 
- class ModemInterfacePrivate
+ class ModemInterfacePrivate: public QObject
  {
  public:
-     ModemInterfacePrivate( const QString & path, QObject * owner );
+     ModemInterfacePrivate(const QString & path, QObject * parent);
      virtual ~ModemInterfacePrivate();
-     OrgFreedesktopModemManagerModemInterface modemIface;
-     OrgFreedesktopModemManagerModemSimpleInterface modemSimpleIface;
+     OrgFreedesktopModemManager1ModemInterface modemIface;
+     OrgFreedesktopModemManager1ModemSimpleInterface modemSimpleIface;
      QString udi;
      QString device;
-     QString masterDevice;
-     QString driver;
-     ModemManager::ModemInterface::Type type;
-     bool enabled;
-     QString unlockRequired;
-     ModemManager::ModemInterface::Method ipMethod;
+     QStringList drivers;
+     QStringList interfaces;
  };
  
  #endif
diff --cc modemlocationinterface_p.h
index c8b5e47,49bf4a0..4920323
--- a/modemlocationinterface_p.h
+++ b/modemlocationinterface_p.h
@@@ -19,11 -19,11 +19,11 @@@ You should have received a copy of the 
  License along with this library.  If not, see <http://www.gnu.org/licenses/>.
  */
  
 -#ifndef MODEMMANAGER_MODEMLOCATIONINTERFACE_P_H
 -#define MODEMMANAGER_MODEMLOCATIONINTERFACE_P_H
 +#ifndef MODEMMANAGERQT_MODEMLOCATIONINTERFACE_P_H
 +#define MODEMMANAGERQT_MODEMLOCATIONINTERFACE_P_H
  
  #include "modeminterface_p.h"
- #include "dbus/mm-modem-locationinterface.h"
+ #include "dbus/Location.h"
  
  class ModemLocationInterfacePrivate: public ModemInterfacePrivate
  {


[prev in list] [next in list] [prev in thread] [next in thread] 

Configure | About | News | Add a list | Sponsored by KoreLogic