Merge lp:~tiagosh/telepathy-ofono/sim-presence into lp:telepathy-ofono

[Tiago Salem Herrmann]

- Report "away" status if there is no network and "offline" if the sim card is not present.
- Remove legacy code
- Expose operator name to apps via presence message.

- Report "away" status if there is no network and "offline" if the sim card is not present.
- Remove legacy code
- Expose operator name to apps via presence message.

--Checklist--
Are there any related MPs required for this MP to build/function as expected? Please list.
https://code.launchpad.net/~tiagosh/telephony-service/sim-presence/+merge/231045

Is your branch in sync with latest trunk (e.g. bzr pull lp:trunk -> no changes)
Yes

Did you perform an exploratory manual test run of your code change and any related functionality on device or emulator?
Yes

Did you successfully run all tests found in your component's Test Plan (https://wiki.ubuntu.com/Process/Merges/TestPlan/telepathy-ofono) on device or emulator?
Yes

If you changed the UI, was the change specified/approved by design?
N/A

If you changed UI labels, did you update the pot file?
N/A

If you changed the packaging (debian), did you add a core-dev as a reviewer to this MP?
N/A

[lp:~tiagosh/telepathy-ofono/sim-presence]

98. By Tiago Salem Herrmann on 2014-08-15

merge trunk

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:98
http://jenkins.qa.ubuntu.com/job/telepathy-ofono-ci/109/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/telepathy-ofono-utopic-amd64-ci/26
    SUCCESS: http://jenkins.qa.ubuntu.com/job/telepathy-ofono-utopic-armhf-ci/26
        deb: http://jenkins.qa.ubuntu.com/job/telepathy-ofono-utopic-armhf-ci/26/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/telepathy-ofono-utopic-i386-ci/26

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/telepathy-ofono-ci/109/rebuild

review: Approve (continuous-integration)

[lp:~tiagosh/telepathy-ofono/sim-presence]

99. By Tiago Salem Herrmann on 2014-08-19

report new status: nomodem, nosim, flightmode, and all ofono network status

100. By Tiago Salem Herrmann on 2014-08-19

- refresh properties when interfaces become available
- export the actual status to upper layers

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:100
http://jenkins.qa.ubuntu.com/job/telepathy-ofono-ci/113/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/telepathy-ofono-utopic-amd64-ci/30/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/telepathy-ofono-utopic-armhf-ci/30/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/telepathy-ofono-utopic-i386-ci/30/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/telepathy-ofono-ci/113/rebuild

review: Needs Fixing (continuous-integration)

[lp:~tiagosh/telepathy-ofono/sim-presence]

101. By Tiago Salem Herrmann on 2014-08-20

add SimManager interface to ofono-qt mock

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:101
http://jenkins.qa.ubuntu.com/job/telepathy-ofono-ci/114/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/telepathy-ofono-utopic-amd64-ci/31
    SUCCESS: http://jenkins.qa.ubuntu.com/job/telepathy-ofono-utopic-armhf-ci/31
        deb: http://jenkins.qa.ubuntu.com/job/telepathy-ofono-utopic-armhf-ci/31/artifact/work/output/*zip*/output.zip
    FAILURE: http://jenkins.qa.ubuntu.com/job/telepathy-ofono-utopic-i386-ci/31/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/telepathy-ofono-ci/114/rebuild

review: Needs Fixing (continuous-integration)

[Gustavo Pichorim Boiko (boiko)]

Did you perform an exploratory manual test run of the code change and any related functionality on device or emulator?
Yes

Did CI run pass? If not, please explain why.
No, but not related to the MR.

Have you checked that submitter has accurately filled out the submitter checklist and has taken no shortcut?
Yes

Code looks good and works as expected!

review: Approve

=== modified file 'connection.cpp'
--- connection.cpp	2014-08-12 20:51:37 +0000
+++ connection.cpp	2014-08-20 19:00:56 +0000
@@ -23,9 +23,6 @@
 #include <TelepathyQt/BaseChannel>
 #include <TelepathyQt/DBusObject>
 
-// ofono-qt
-#include <ofonomodem.h>
-
 // telepathy-ofono
 #include "connection.h"
 #include "phoneutils_p.h"
@@ -71,9 +68,6 @@
 #endif
 }
 
-// miliseconds
-#define OFONO_REGISTER_RETRY_TIME 5000
-
 oFonoConnection::oFonoConnection(const QDBusConnection &dbusConnection,
                             const QString &cmName,
                             const QString &protocolName,
@@ -96,6 +90,8 @@
     mOfonoNetworkRegistration = new OfonoNetworkRegistration(setting, mModemPath);
     mOfonoMessageWaiting = new OfonoMessageWaiting(setting, mModemPath);
     mOfonoSupplementaryServices = new OfonoSupplementaryServices(setting, mModemPath);
+    mOfonoSimManager = new OfonoSimManager(setting, mModemPath);
+    mOfonoModem = mOfonoSimManager->modem();
 
     setSelfHandle(newHandle("<SelfHandle>"));
 
@@ -158,38 +154,43 @@
     supplementaryServicesIface->setRespondCallback(Tp::memFun(this,&oFonoConnection::USSDRespond));
     supplementaryServicesIface->setCancelCallback(Tp::memFun(this,&oFonoConnection::USSDCancel));
     supplementaryServicesIface->StateChanged(mOfonoSupplementaryServices->state());
-    supplementaryServicesIface->setSerial(mOfonoSupplementaryServices->modem()->serial());
+    supplementaryServicesIface->setSerial(mOfonoModem->serial());
     plugInterface(Tp::AbstractConnectionInterfacePtr::dynamicCast(supplementaryServicesIface));
 
     // Set Presence
     Tp::SimpleStatusSpec presenceOnline;
     presenceOnline.type = Tp::ConnectionPresenceTypeAvailable;
-    presenceOnline.maySetOnSelf = true;
-    presenceOnline.canHaveMessage = false;
+    presenceOnline.maySetOnSelf = false;
+    presenceOnline.canHaveMessage = true;
 
     Tp::SimpleStatusSpec presenceOffline;
     presenceOffline.type = Tp::ConnectionPresenceTypeOffline;
     presenceOffline.maySetOnSelf = false;
-    presenceOffline.canHaveMessage = false;
+    presenceOffline.canHaveMessage = true;
+
+    Tp::SimpleStatusSpec presenceAway;
+    presenceAway.type = Tp::ConnectionPresenceTypeAway;
+    presenceAway.maySetOnSelf = false;
+    presenceAway.canHaveMessage = true;
 
     Tp::SimpleStatusSpecMap statuses;
-    statuses.insert(QLatin1String("available"), presenceOnline);
-    statuses.insert(QLatin1String("offline"), presenceOffline);
+    statuses.insert(QLatin1String("registered"), presenceOnline);
+    statuses.insert(QLatin1String("roaming"), presenceOnline);
+    statuses.insert(QLatin1String("flightmode"), presenceOffline);
+    statuses.insert(QLatin1String("nosim"), presenceOffline);
+    statuses.insert(QLatin1String("nomodem"), presenceOffline);
+    statuses.insert(QLatin1String("unregistered"), presenceAway);
+    statuses.insert(QLatin1String("denied"), presenceAway);
+    statuses.insert(QLatin1String("unknown"), presenceAway);
+    statuses.insert(QLatin1String("searching"), presenceAway);
 
     simplePresenceIface->setStatuses(statuses);
-    mSelfPresence.type = Tp::ConnectionPresenceTypeOffline;
-    mRequestedSelfPresence.type = Tp::ConnectionPresenceTypeOffline;
 
-    bool validModem = false;
-    if (mOfonoVoiceCallManager->modem()) {
-        validModem = mOfonoVoiceCallManager->modem()->isValid();
-        if (validModem) {
-            supplementaryServicesIface->setSerial(mOfonoSupplementaryServices->modem()->serial());
-            QObject::connect(mOfonoVoiceCallManager->modem(), SIGNAL(onlineChanged(bool)), SLOT(onValidityChanged(bool)));
-        }
+    if (mOfonoModem->isValid()) {
+        supplementaryServicesIface->setSerial(mOfonoModem->serial());
     }
     // force update current presence
-    onOfonoNetworkRegistrationChanged(mOfonoNetworkRegistration->status());
+    updateOnlineStatus();
 
     contactsIface = Tp::BaseConnectionContactsInterface::create();
     contactsIface->setGetContactAttributesCallback(Tp::memFun(this,&oFonoConnection::getContactAttributes));
@@ -198,12 +199,17 @@
                                                  << TP_QT_IFACE_CONNECTION_INTERFACE_SIMPLE_PRESENCE);
     plugInterface(Tp::AbstractConnectionInterfacePtr::dynamicCast(contactsIface));
 
+    QObject::connect(mOfonoModem, SIGNAL(onlineChanged(bool)), SLOT(updateOnlineStatus()));
+    QObject::connect(mOfonoModem, SIGNAL(interfacesChanged(QStringList)), SLOT(updateOnlineStatus()));
     QObject::connect(mOfonoMessageManager, SIGNAL(incomingMessage(QString,QVariantMap)), this, SLOT(onOfonoIncomingMessage(QString,QVariantMap)));
     QObject::connect(mOfonoMessageManager, SIGNAL(immediateMessage(QString,QVariantMap)), this, SLOT(onOfonoImmediateMessage(QString,QVariantMap)));
     QObject::connect(mOfonoMessageManager, SIGNAL(statusReport(QString,QVariantMap)), this, SLOT(onDeliveryReportReceived(QString,QVariantMap)));
     QObject::connect(mOfonoVoiceCallManager, SIGNAL(callAdded(QString,QVariantMap)), SLOT(onOfonoCallAdded(QString, QVariantMap)));
-    QObject::connect(mOfonoVoiceCallManager, SIGNAL(validityChanged(bool)), SLOT(onValidityChanged(bool)));
-    QObject::connect(mOfonoNetworkRegistration, SIGNAL(statusChanged(QString)), SLOT(onOfonoNetworkRegistrationChanged(QString)));
+    QObject::connect(mOfonoSimManager, SIGNAL(validityChanged(bool)), SLOT(onValidityChanged(bool)));
+    QObject::connect(mOfonoSimManager, SIGNAL(presenceChanged(bool)), SLOT(updateOnlineStatus()));
+    QObject::connect(mOfonoNetworkRegistration, SIGNAL(statusChanged(QString)), SLOT(updateOnlineStatus()));
+    QObject::connect(mOfonoNetworkRegistration, SIGNAL(nameChanged(QString)), SLOT(updateOnlineStatus()));
+    QObject::connect(mOfonoNetworkRegistration, SIGNAL(validityChanged(bool)), SLOT(updateOnlineStatus()));
     QObject::connect(mOfonoMessageWaiting, SIGNAL(voicemailMessageCountChanged(int)), voicemailIface.data(), SLOT(setVoicemailCount(int)));
     QObject::connect(mOfonoMessageWaiting, SIGNAL(voicemailWaitingChanged(bool)), voicemailIface.data(), SLOT(setVoicemailIndicator(bool)));
     QObject::connect(mOfonoMessageWaiting, SIGNAL(voicemailMailboxNumberChanged(QString)), voicemailIface.data(), SLOT(setVoicemailNumber(QString)));
@@ -412,8 +418,11 @@
 bool oFonoConnection::isNetworkRegistered()
 {
     QString status = mOfonoNetworkRegistration->status();
-    return  !(!mOfonoNetworkRegistration->modem() ||
-              !mOfonoNetworkRegistration->modem()->online() ||
+    if (!mOfonoNetworkRegistration->isValid()) {
+        return false;
+    }
+    return  !(!mOfonoModem->isValid() ||
+              !mOfonoModem->online() ||
               status == "unregistered" ||
               status == "denied" ||
               status == "unknown" ||
@@ -432,26 +441,11 @@
     return false;
 }
 
-void oFonoConnection::onOfonoNetworkRegistrationChanged(const QString &status)
-{
-    qDebug() << "onOfonoNetworkRegistrationChanged" << status << "is network registered: " << isNetworkRegistered();
-    if (!isNetworkRegistered() && mRequestedSelfPresence.type == Tp::ConnectionPresenceTypeAvailable) {
-        setOnline(false);
-        return;
-    }
-    setOnline(isNetworkRegistered());
-}
-
 uint oFonoConnection::setPresence(const QString& status, const QString& statusMessage, Tp::DBusError *error)
 {
     qDebug() << "setPresence" << status;
-    if (status == "available") {
-        mRequestedSelfPresence.type = Tp::ConnectionPresenceTypeAvailable;
-    }
-    if(!mOfonoNetworkRegistration->modem() ||!mOfonoNetworkRegistration->modem()->online() || !isNetworkRegistered()) {
-        // this prevents tp-qt to propagate the available status
-        error->set(TP_QT_ERROR_NETWORK_ERROR, "Modem is offline");
-    }
+    // this prevents tp-qt to propagate the available status
+    error->set(TP_QT_ERROR_NOT_AVAILABLE, "Can't change online status: Operation not supported");
     return selfHandle();
 }
 
@@ -477,28 +471,38 @@
 
 void oFonoConnection::onValidityChanged(bool valid)
 {
-    qDebug() << "validityChanged" << valid << "is network registered: " << isNetworkRegistered() << mRequestedSelfPresence.type;
-    QObject::disconnect(mOfonoVoiceCallManager->modem(), 0,0,0);
-    QObject::connect(mOfonoVoiceCallManager->modem(), SIGNAL(onlineChanged(bool)), SLOT(onValidityChanged(bool)));
-    supplementaryServicesIface->setSerial(mOfonoSupplementaryServices->modem()->serial());
-    if (!isNetworkRegistered() && mRequestedSelfPresence.type == Tp::ConnectionPresenceTypeAvailable) {
-        setOnline(false);
+    // WORKAROUND: ofono-qt does not refresh the properties once the interface
+    // becomes available, so it contains old values.
+    Q_EMIT mOfonoSimManager->modem()->pathChanged(mOfonoModem->path());
+    Q_EMIT mOfonoNetworkRegistration->modem()->pathChanged(mOfonoModem->path());
+    QString modemSerial;
+    if (valid) {
+        modemSerial = mOfonoModem->serial();
     }
-    setOnline(isNetworkRegistered());
+    supplementaryServicesIface->setSerial(modemSerial);
+    updateOnlineStatus();
 }
 
-void oFonoConnection::setOnline(bool online)
+void oFonoConnection::updateOnlineStatus()
 {
-    qDebug() << "setOnline" << online;
     Tp::SimpleContactPresences presences;
-    if (online) {
-        mSelfPresence.status = "available";
-        mSelfPresence.statusMessage = "";
+    mSelfPresence.statusMessage = "";
+    mSelfPresence.type = Tp::ConnectionPresenceTypeOffline;
+
+    if (!mOfonoModem->isValid()) {
+        mSelfPresence.status = "nomodem";
+    } else if (!mOfonoModem->online()) {
+        mSelfPresence.status = "flightmode";
+    } else if ((mOfonoSimManager->isValid() && !mOfonoSimManager->present()) ||
+                !mOfonoSimManager->isValid()) {
+        mSelfPresence.status = "nosim";
+    } else if (isNetworkRegistered()) {
+        mSelfPresence.status = mOfonoNetworkRegistration->status();
+        mSelfPresence.statusMessage = mOfonoNetworkRegistration->name();
         mSelfPresence.type = Tp::ConnectionPresenceTypeAvailable;
     } else {
-        mSelfPresence.status = "offline";
-        mSelfPresence.statusMessage = "";
-        mSelfPresence.type = Tp::ConnectionPresenceTypeOffline;
+        mSelfPresence.status = mOfonoNetworkRegistration->status();
+        mSelfPresence.type = Tp::ConnectionPresenceTypeAway;
     }
     presences[selfHandle()] = mSelfPresence;
     simplePresenceIface->setPresences(presences);

=== modified file 'connection.h'
--- connection.h	2014-08-12 20:51:37 +0000
+++ connection.h	2014-08-20 19:00:56 +0000
@@ -27,6 +27,7 @@
 #include <TelepathyQt/DBusError>
 
 // ofono-qt
+#include <ofonomodem.h>
 #include <ofonomodemmanager.h>
 #include <ofonomessagemanager.h>
 #include <ofonovoicecallmanager.h>
@@ -35,6 +36,7 @@
 #include <ofononetworkregistration.h>
 #include <ofonomessagewaiting.h>
 #include <ofonosupplementaryservices.h>
+#include <ofonosimmanager.h>
 
 // telepathy-ofono
 #include "ofonotextchannel.h"
@@ -70,7 +72,6 @@
     Tp::ContactAttributesMap getContactAttributes(const Tp::UIntList &handles, const QStringList &ifaces, Tp::DBusError *error);
     uint setPresence(const QString& status, const QString& statusMessage, Tp::DBusError *error);
     void connect(Tp::DBusError *error);
-    void setOnline(bool online);
     void setSpeakerMode(bool active);
     bool speakerMode();
     QStringList emergencyNumbers(Tp::DBusError *error);
@@ -123,7 +124,6 @@
     void onOfonoIncomingMessage(const QString &message, const QVariantMap &info);
     void onOfonoImmediateMessage(const QString &message, const QVariantMap &info);
     void onOfonoCallAdded(const QString &call, const QVariantMap &properties);
-    void onOfonoNetworkRegistrationChanged(const QString &status);
     void onTextChannelClosed();
     void onCallChannelClosed();
     void onCallChannelDestroyed();
@@ -140,6 +140,7 @@
     void onCallChannelSplitted();
     void onMultipartyCallHeld();
     void onMultipartyCallActive();
+    void updateOnlineStatus();
 
 private:
     bool isNetworkRegistered();
@@ -159,9 +160,10 @@
     OfonoNetworkRegistration *mOfonoNetworkRegistration;
     OfonoMessageWaiting *mOfonoMessageWaiting;
     OfonoSupplementaryServices *mOfonoSupplementaryServices;
+    OfonoSimManager *mOfonoSimManager;
+    OfonoModem *mOfonoModem;
     uint mHandleCount;
     Tp::SimplePresence mSelfPresence;
-    Tp::SimplePresence mRequestedSelfPresence;
     MMSDManager *mMmsdManager;
     QMap<QString, MMSDService*> mMmsdServices;
     QMap<QString, QList<MMSDMessage*> > mServiceMMSList;

=== modified file 'tests/CallTest.cpp'
--- tests/CallTest.cpp	2014-05-08 20:11:46 +0000
+++ tests/CallTest.cpp	2014-08-20 19:00:56 +0000
@@ -76,6 +76,7 @@
     QSignalSpy spy(TelepathyHelper::instance(), SIGNAL(accountReady()));
     QTRY_COMPARE(spy.count(), 1);
 
+    OfonoMockController::instance()->SimManagerSetPresence(true);
     OfonoMockController::instance()->ModemSetOnline();
     OfonoMockController::instance()->NetworkRegistrationSetStatus("registered");
     // the account should be connected

=== modified file 'tests/ConnectionTest.cpp'
--- tests/ConnectionTest.cpp	2014-05-08 20:11:46 +0000
+++ tests/ConnectionTest.cpp	2014-08-20 19:00:56 +0000
@@ -40,6 +40,7 @@
                    SIGNAL(accountReady()));
     QTRY_COMPARE(spy.count(), 1);
 
+    OfonoMockController::instance()->SimManagerSetPresence(true);
     OfonoMockController::instance()->ModemSetOnline();
     OfonoMockController::instance()->NetworkRegistrationSetStatus("registered");
 
@@ -63,7 +64,7 @@
     OfonoMockController::instance()->NetworkRegistrationSetStatus("unregistered");
     QTRY_COMPARE(signalSpy.count(), 1);
     Tp::Presence presence = signalSpy.first().first().value<Tp::Presence>();
-    QCOMPARE(presence.type(), Tp::ConnectionPresenceTypeOffline);
+    QCOMPARE(presence.type(), Tp::ConnectionPresenceTypeAway);
     signalSpy.clear();
 
     // now set the modem as registered to the network again to see if it works
@@ -73,21 +74,21 @@
     QCOMPARE(presence.type(), Tp::ConnectionPresenceTypeAvailable);
     signalSpy.clear();
 
-    // searching should be reported as offline
+    // searching should be reported as away
     OfonoMockController::instance()->NetworkRegistrationSetStatus("searching");
     QTRY_COMPARE(signalSpy.count(), 1);
     presence = signalSpy.first().first().value<Tp::Presence>();
-    QCOMPARE(presence.type(), Tp::ConnectionPresenceTypeOffline);
+    QCOMPARE(presence.type(), Tp::ConnectionPresenceTypeAway);
     signalSpy.clear();
 
-    // denied should be reported as offline (set registered first to force the signal to be emitted)
+    // denied should be reported as away (set registered first to force the signal to be emitted)
     OfonoMockController::instance()->NetworkRegistrationSetStatus("registered");
     QTRY_COMPARE(signalSpy.count(), 1);
     signalSpy.clear();
     OfonoMockController::instance()->NetworkRegistrationSetStatus("denied");
     QTRY_COMPARE(signalSpy.count(), 1);
     presence = signalSpy.first().first().value<Tp::Presence>();
-    QCOMPARE(presence.type(), Tp::ConnectionPresenceTypeOffline);
+    QCOMPARE(presence.type(), Tp::ConnectionPresenceTypeAway);
     signalSpy.clear();
 
     // unknown should be reported as offline (set registered first to force the signal to be emitted)
@@ -97,7 +98,7 @@
     OfonoMockController::instance()->NetworkRegistrationSetStatus("unknown");
     QTRY_COMPARE(signalSpy.count(), 1);
     presence = signalSpy.first().first().value<Tp::Presence>();
-    QCOMPARE(presence.type(), Tp::ConnectionPresenceTypeOffline);
+    QCOMPARE(presence.type(), Tp::ConnectionPresenceTypeAway);
     signalSpy.clear();
 
     // roaming should be reported as available
@@ -105,6 +106,13 @@
     QTRY_COMPARE(signalSpy.count(), 1);
     presence = signalSpy.first().first().value<Tp::Presence>();
     QCOMPARE(presence.type(), Tp::ConnectionPresenceTypeAvailable);
+    signalSpy.clear();
+
+    // offline modem should be reported as offline (flightmode)
+    OfonoMockController::instance()->ModemSetOnline(false);
+    QTRY_COMPARE(signalSpy.count(), 1);
+    presence = signalSpy.first().first().value<Tp::Presence>();
+    QCOMPARE(presence.type(), Tp::ConnectionPresenceTypeOffline);
 }
 
 QTEST_MAIN(ConnectionTest)

=== modified file 'tests/MessagesTest.cpp'
--- tests/MessagesTest.cpp	2014-05-08 20:11:46 +0000
+++ tests/MessagesTest.cpp	2014-08-20 19:00:56 +0000
@@ -65,6 +65,7 @@
     QSignalSpy spy(TelepathyHelper::instance(), SIGNAL(accountReady()));
     QTRY_COMPARE(spy.count(), 1);
 
+    OfonoMockController::instance()->SimManagerSetPresence(true);
     OfonoMockController::instance()->ModemSetOnline();
     OfonoMockController::instance()->NetworkRegistrationSetStatus("registered");
     // the account should be connected

=== modified file 'tests/mock/CMakeLists.txt'
--- tests/mock/CMakeLists.txt	2013-12-03 14:22:45 +0000
+++ tests/mock/CMakeLists.txt	2014-08-20 19:00:56 +0000
@@ -5,6 +5,7 @@
     modemprivate.cpp
     voicecallmanagerprivate.cpp
     voicecallprivate.cpp
+    simmanagerprivate.cpp
     networkregistrationprivate.cpp
     ofonocallvolume.cpp
     ofonointerface.cpp
@@ -17,6 +18,7 @@
     ofononetworkregistration.cpp
     ofonovoicecall.cpp
     ofonovoicecallmanager.cpp
+    ofonosimmanager.cpp
     )
 
 include_directories(
@@ -30,6 +32,7 @@
 qt5_add_dbus_adaptor(library_SRCS MessagePrivate.xml messageprivate.h MessagePrivate)
 qt5_add_dbus_adaptor(library_SRCS VoiceCallManagerPrivate.xml voicecallmanagerprivate.h VoiceCallManagerPrivate)
 qt5_add_dbus_adaptor(library_SRCS VoiceCallPrivate.xml voicecallprivate.h VoiceCallPrivate)
+qt5_add_dbus_adaptor(library_SRCS SimManagerPrivate.xml simmanagerprivate.h SimManagerPrivate)
 
 add_library(ofono-qt SHARED ${library_SRCS})
 

=== added file 'tests/mock/SimManagerPrivate.xml'
--- tests/mock/SimManagerPrivate.xml	1970-01-01 00:00:00 +0000
+++ tests/mock/SimManagerPrivate.xml	2014-08-20 19:00:56 +0000
@@ -0,0 +1,17 @@
+<!DOCTYPE node PUBLIC "-//freedesktop//DTD D-BUS Object Introspection 1.0//EN" "http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd">
+<node>
+  <interface name="org.ofono.SimManager">
+    <signal name="PropertyChanged">
+      <arg type="s" direction="out"/>
+      <arg type="v" direction="out"/>
+    </signal>
+    <method name="GetProperties">
+      <arg type="a{sv}" direction="out"/>
+      <annotation name="org.qtproject.QtDBus.QtTypeName.Out0" value="QVariantMap"/>
+    </method>
+    <method name="SetProperty">
+      <arg name="name" type="s" direction="in"/>
+      <arg name="value" type="v" direction="in"/>
+    </method>
+  </interface>
+</node>

=== modified file 'tests/mock/mock_common.h'
--- tests/mock/mock_common.h	2013-12-03 14:22:45 +0000
+++ tests/mock/mock_common.h	2014-08-20 19:00:56 +0000
@@ -3,3 +3,4 @@
 #define OFONO_MOCK_NETWORK_REGISTRATION_OBJECT "/OfonoNetworkRegistration"
 #define OFONO_MOCK_VOICECALL_MANAGER_OBJECT "/OfonoVoiceCallManager"
 #define OFONO_MOCK_CALL_VOLUME_OBJECT "/OfonoCallVolume"
+#define OFONO_MOCK_SIM_MANAGER_OBJECT "/OfonoSimManager"

=== added file 'tests/mock/ofonosimmanager.cpp'
--- tests/mock/ofonosimmanager.cpp	1970-01-01 00:00:00 +0000
+++ tests/mock/ofonosimmanager.cpp	2014-08-20 19:00:56 +0000
@@ -0,0 +1,313 @@
+/*
+ * This file is part of ofono-qt
+ *
+ * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+ *
+ * Contact: Alexander Kanavin <[e-mail]>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License
+ * version 2.1 as published by the Free Software Foundation.
+ *
+ * This library is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+#include <QtDBus/QtDBus>
+#include <QtCore/QObject>
+
+#include "ofonosimmanager.h"
+#include "ofonointerface.h"
+#include "simmanagerprivate.h"
+
+OfonoSimManager::OfonoSimManager(OfonoModem::SelectionSetting modemSetting, const QString &modemPath, QObject *parent)
+    : OfonoModemInterface(modemSetting, modemPath, "org.ofono.SimManager", OfonoGetAllOnStartup, parent)
+{
+    qRegisterMetaType<OfonoServiceNumbers>("OfonoServiceNumbers");
+    qRegisterMetaType<OfonoPinRetries>("OfonoPinRetries");
+
+    m_if->setPath(OFONO_MOCK_SIM_MANAGER_OBJECT);
+    if (!simManagerData.keys().contains(modem()->path())) {
+        simManagerData[modem()->path()] = new SimManagerPrivate();
+    }
+
+    connect(m_if, SIGNAL(propertyChanged(const QString&, const QVariant&)), 
+            this, SLOT(propertyChanged(const QString&, const QVariant&)));
+    connect(m_if, SIGNAL(setPropertyFailed(const QString&)), 
+            this, SLOT(setPropertyFailed(const QString&)));
+
+}
+
+OfonoSimManager::~OfonoSimManager()
+{
+}
+
+void OfonoSimManager::changePin(const QString &pintype, const QString &oldpin, const QString &newpin)
+{
+    QDBusMessage request;
+
+    request = QDBusMessage::createMethodCall("org.ofono",
+					     path(), m_if->ifname(),
+					     "ChangePin");
+    request << pintype << oldpin << newpin;
+
+    QDBusConnection::sessionBus().callWithCallback(request, this,
+					SLOT(changePinResp()),
+					SLOT(changePinErr(const QDBusError&)));
+}
+
+void OfonoSimManager::enterPin(const QString &pintype, const QString &pin)
+{
+    QDBusMessage request;
+
+    request = QDBusMessage::createMethodCall("org.ofono",
+					     path(), m_if->ifname(),
+					     "EnterPin");
+    request << pintype << pin;
+
+    QDBusConnection::sessionBus().callWithCallback(request, this,
+					SLOT(enterPinResp()),
+					SLOT(enterPinErr(const QDBusError&)));
+}
+
+void OfonoSimManager::resetPin(const QString &pintype, const QString &puk, const QString &newpin)
+{
+    QDBusMessage request;
+
+    request = QDBusMessage::createMethodCall("org.ofono",
+					     path(), m_if->ifname(),
+					     "ResetPin");
+    request << pintype << puk << newpin;
+
+    QDBusConnection::sessionBus().callWithCallback(request, this,
+					SLOT(resetPinResp()),
+					SLOT(resetPinErr(const QDBusError&)));
+}
+
+void OfonoSimManager::lockPin(const QString &pintype, const QString &pin)
+{
+    QDBusMessage request;
+
+    request = QDBusMessage::createMethodCall("org.ofono",
+					     path(), m_if->ifname(),
+					     "LockPin");
+    request << pintype << pin;
+
+    QDBusConnection::sessionBus().callWithCallback(request, this,
+					SLOT(lockPinResp()),
+					SLOT(lockPinErr(const QDBusError&)));
+}
+
+void OfonoSimManager::unlockPin(const QString &pintype, const QString &pin)
+{
+    QDBusMessage request;
+
+    request = QDBusMessage::createMethodCall("org.ofono",
+					     path(), m_if->ifname(),
+					     "UnlockPin");
+    request << pintype << pin;
+
+    QDBusConnection::sessionBus().callWithCallback(request, this,
+					SLOT(unlockPinResp()),
+					SLOT(unlockPinErr(const QDBusError&)));
+}
+
+void OfonoSimManager::getIcon(quint8 id)
+{
+    QDBusMessage request;
+
+    request = QDBusMessage::createMethodCall("org.ofono",
+					     path(), m_if->ifname(),
+					     "GetIcon");
+    request << qVariantFromValue(id);
+
+    QDBusConnection::sessionBus().callWithCallback(request, this,
+					SLOT(getIconResp(QByteArray)),
+					SLOT(getIconErr(const QDBusError&)));
+}
+
+void OfonoSimManager::setSubscriberNumbers(const QStringList &numbers)
+{
+    m_if->setProperty("SubscriberNumbers", qVariantFromValue(numbers));
+}
+
+bool OfonoSimManager::present() const
+{
+    return m_if->properties()["Present"].value<bool>();
+}
+
+QString OfonoSimManager::subscriberIdentity() const
+{
+    return m_if->properties()["SubscriberIdentity"].value<QString>();
+}
+
+QString OfonoSimManager::mobileCountryCode() const
+{
+    return m_if->properties()["MobileCountryCode"].value<QString>();
+}
+
+QString OfonoSimManager::mobileNetworkCode() const
+{
+    return m_if->properties()["MobileNetworkCode"].value<QString>();
+}
+
+QStringList OfonoSimManager::subscriberNumbers() const
+{
+    return m_if->properties()["SubscriberNumbers"].value<QStringList>();
+}
+
+OfonoServiceNumbers OfonoSimManager::serviceNumbers() const
+{
+    OfonoServiceNumbers map;
+    m_if->properties()["ServiceNumbers"].value<QDBusArgument>() >> map;
+    return map;
+}
+
+QString OfonoSimManager::pinRequired() const
+{
+    return m_if->properties()["PinRequired"].value<QString>();
+}
+
+QStringList OfonoSimManager::lockedPins() const
+{
+    return m_if->properties()["LockedPins"].value<QStringList>();
+}
+
+QString OfonoSimManager::cardIdentifier() const
+{
+    return m_if->properties()["CardIdentifier"].value<QString>();
+}
+
+QStringList OfonoSimManager::preferredLanguages() const
+{
+    return m_if->properties()["PreferredLanguages"].value<QStringList>();
+}
+
+OfonoPinRetries OfonoSimManager::pinRetries() const
+{
+    OfonoPinRetries retries;
+    m_if->properties()["Retries"].value<QDBusArgument>() >> retries;
+    return retries;
+}
+
+bool OfonoSimManager::fixedDialing() const
+{
+    return m_if->properties()["FixedDialing"].value<bool>();
+}
+
+bool OfonoSimManager::barredDialing() const
+{
+    return m_if->properties()["BarredDialing"].value<bool>();
+}
+
+void OfonoSimManager::propertyChanged(const QString& property, const QVariant& value)
+{
+    if (property == "Present") {	
+        Q_EMIT presenceChanged(value.value<bool>());
+    } else if (property == "SubscriberIdentity") {	
+        Q_EMIT subscriberIdentityChanged(value.value<QString>());
+    } else if (property == "MobileCountryCode") {	
+        Q_EMIT mobileCountryCodeChanged(value.value<QString>());
+    } else if (property == "MobileNetworkCode") {	
+        Q_EMIT mobileNetworkCodeChanged(value.value<QString>());
+    } else if (property == "SubscriberNumbers") {	
+        Q_EMIT subscriberNumbersChanged(value.value<QStringList>());
+    } else if (property == "ServiceNumbers") {	
+        OfonoServiceNumbers map;
+        value.value<QDBusArgument>() >> map;
+        Q_EMIT serviceNumbersChanged(map);
+    } else if (property == "PinRequired") {	
+        Q_EMIT pinRequiredChanged(value.value<QString>());
+    } else if (property == "LockedPins") {
+        Q_EMIT lockedPinsChanged(value.value<QStringList>());
+    } else if (property == "CardIdentifier") {	
+        Q_EMIT cardIdentifierChanged(value.value<QString>());
+    } else if (property == "PreferredLanguages") {	
+        Q_EMIT preferredLanguagesChanged(value.value<QStringList>());
+    } else if (property == "Retries") {
+        OfonoPinRetries retries;
+        value.value<QDBusArgument>() >> retries;
+        Q_EMIT pinRetriesChanged(retries);
+    } else if (property == "FixedDialing") {	
+        Q_EMIT fixedDialingChanged(value.value<bool>());
+    } else if (property == "BarredDialing") {	
+        Q_EMIT barredDialingChanged(value.value<bool>());
+    }
+}
+
+void OfonoSimManager::setPropertyFailed(const QString& property)
+{
+    if (property == "SubscriberNumbers")
+        Q_EMIT setSubscriberNumbersFailed();
+}
+
+void OfonoSimManager::changePinResp()
+{
+    Q_EMIT changePinComplete(true);
+}
+
+void OfonoSimManager::changePinErr(QDBusError error)
+{
+    m_if->setError(error.name(), error.message());    
+    Q_EMIT changePinComplete(false);
+}
+
+void OfonoSimManager::enterPinResp()
+{
+    Q_EMIT enterPinComplete(true);
+}
+
+void OfonoSimManager::enterPinErr(QDBusError error)
+{
+    m_if->setError(error.name(), error.message());
+    Q_EMIT enterPinComplete(false);
+}
+
+void OfonoSimManager::resetPinResp()
+{
+    Q_EMIT resetPinComplete(true);
+}
+
+void OfonoSimManager::resetPinErr(QDBusError error)
+{
+    m_if->setError(error.name(), error.message());
+    Q_EMIT resetPinComplete(false);
+}
+
+void OfonoSimManager::lockPinResp()
+{
+    Q_EMIT lockPinComplete(true);
+}
+void OfonoSimManager::lockPinErr(QDBusError error)
+{
+    m_if->setError(error.name(), error.message());
+    Q_EMIT lockPinComplete(false);
+}
+
+void OfonoSimManager::unlockPinResp()
+{
+    Q_EMIT unlockPinComplete(true);
+}
+void OfonoSimManager::unlockPinErr(QDBusError error)
+{
+    m_if->setError(error.name(), error.message()); 
+    Q_EMIT unlockPinComplete(false);
+}
+
+void OfonoSimManager::getIconResp(QByteArray icon)
+{
+    Q_EMIT getIconComplete(true, icon);
+}
+void OfonoSimManager::getIconErr(QDBusError error)
+{
+    m_if->setError(error.name(), error.message()); 
+    Q_EMIT getIconComplete(false, QByteArray());
+}

=== added file 'tests/mock/ofonosimmanager.h'
--- tests/mock/ofonosimmanager.h	1970-01-01 00:00:00 +0000
+++ tests/mock/ofonosimmanager.h	2014-08-20 19:00:56 +0000
@@ -0,0 +1,134 @@
+/*
+ * This file is part of ofono-qt
+ *
+ * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+ *
+ * Contact: Alexander Kanavin <[e-mail]>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License
+ * version 2.1 as published by the Free Software Foundation.
+ *
+ * This library is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+#ifndef OFONOSIMMANAGER_H
+#define OFONOSIMMANAGER_H
+
+#include <QtCore/QObject>
+#include <QStringList>
+#include <QDBusError>
+#include "ofonomodeminterface.h"
+#include "libofono-qt_global.h"
+
+typedef QMap<QString, QString> OfonoServiceNumbers;
+Q_DECLARE_METATYPE(OfonoServiceNumbers);
+
+typedef QMap<QString, quint8> OfonoPinRetries;
+Q_DECLARE_METATYPE(OfonoPinRetries);
+
+//! This class is used to access oFono SIM API
+/*!
+ * The API is documented in
+ * http://git.kernel.org/?p=network/ofono/ofono.git;a=blob_plain;f=doc/sim-api.txt
+ */
+class OFONO_QT_EXPORT OfonoSimManager : public OfonoModemInterface
+{
+    Q_OBJECT
+
+    Q_PROPERTY(bool present READ present NOTIFY presenceChanged)
+    Q_PROPERTY(QString subscriberIdentity READ subscriberIdentity NOTIFY subscriberIdentityChanged)
+    Q_PROPERTY(QString mobileCountryCode READ mobileCountryCode NOTIFY mobileCountryCodeChanged)
+    Q_PROPERTY(QString mobileNetworkCode READ mobileNetworkCode NOTIFY mobileNetworkCodeChanged)
+    Q_PROPERTY(QStringList subscriberNumbers READ subscriberNumbers WRITE setSubscriberNumbers NOTIFY subscriberNumbersChanged)
+    Q_PROPERTY(QString pinRequired READ pinRequired NOTIFY pinRequiredChanged)
+    Q_PROPERTY(QStringList lockedPins READ lockedPins NOTIFY lockedPinsChanged)
+    Q_PROPERTY(QString cardIdentifier READ cardIdentifier NOTIFY cardIdentifierChanged)
+    Q_PROPERTY(QStringList preferredLanguages READ preferredLanguages NOTIFY preferredLanguagesChanged)
+    Q_PROPERTY(OfonoPinRetries pinRetries READ pinRetries NOTIFY pinRetriesChanged)
+    Q_PROPERTY(bool fixedDialing READ fixedDialing NOTIFY fixedDialingChanged)
+    Q_PROPERTY(bool barredDialing READ barredDialing NOTIFY barredDialingChanged)
+
+public:
+    OfonoSimManager(OfonoModem::SelectionSetting modemSetting, const QString &modemPath, QObject *parent=0);
+    ~OfonoSimManager();
+
+    /* Properties */
+    bool present() const;
+    QString subscriberIdentity() const;
+    QString mobileCountryCode() const;
+    QString mobileNetworkCode() const;
+    QStringList subscriberNumbers() const;
+    OfonoServiceNumbers serviceNumbers() const;
+    QString pinRequired() const;
+    QStringList lockedPins() const;
+    QString cardIdentifier() const;
+    QStringList preferredLanguages() const;
+    OfonoPinRetries pinRetries() const;
+    bool fixedDialing() const;
+    bool barredDialing() const;
+
+public Q_SLOTS:
+    void changePin(const QString &pintype, const QString &oldpin, const QString &newpin);
+    void enterPin(const QString &pintype, const QString &pin);
+    void resetPin(const QString &pintype, const QString &puk, const QString &newpin);
+    void lockPin(const QString &pintype, const QString &pin);
+    void unlockPin(const QString &pintype, const QString &pin);
+    void getIcon(quint8 id);
+
+    void setSubscriberNumbers(const QStringList &numbers);
+
+Q_SIGNALS:
+    void presenceChanged(bool ispresent);
+    void subscriberIdentityChanged(const QString &imsi);
+    void mobileCountryCodeChanged(const QString &mcc);
+    void mobileNetworkCodeChanged(const QString &mnc);
+    void subscriberNumbersChanged(const QStringList &msisdns);
+    void setSubscriberNumbersFailed();
+    void serviceNumbersChanged(const OfonoServiceNumbers &sdns);
+    void pinRequiredChanged(const QString &pintype);
+    void lockedPinsChanged(const QStringList &pins);
+    void cardIdentifierChanged(const QString &iccid);
+    void preferredLanguagesChanged(const QStringList &languages);
+    void pinRetriesChanged(const OfonoPinRetries &pinRetries);
+    void fixedDialingChanged(bool fixedDialing);
+    void barredDialingChanged(bool barredDialing);
+
+    void changePinComplete(bool success);
+    void enterPinComplete(bool success);
+    void resetPinComplete(bool success);
+    void lockPinComplete(bool success);
+    void unlockPinComplete(bool success);
+    void getIconComplete(bool success, const QByteArray &icon);
+
+private Q_SLOTS:
+    void propertyChanged(const QString& property, const QVariant& value);
+    void setPropertyFailed(const QString& property);    
+
+    void changePinResp();
+    void changePinErr(QDBusError error);
+    void enterPinResp();
+    void enterPinErr(QDBusError error);
+    void resetPinResp();
+    void resetPinErr(QDBusError error);
+    void lockPinResp();
+    void lockPinErr(QDBusError error);
+    void unlockPinResp();
+    void unlockPinErr(QDBusError error);
+    void getIconResp(QByteArray icon);
+    void getIconErr(QDBusError error);
+
+private:
+
+};
+
+#endif  /* !OFONOSIMMANAGER_H */

=== added file 'tests/mock/simmanagerprivate.cpp'
--- tests/mock/simmanagerprivate.cpp	1970-01-01 00:00:00 +0000
+++ tests/mock/simmanagerprivate.cpp	2014-08-20 19:00:56 +0000
@@ -0,0 +1,46 @@
+/**
+ * Copyright (C) 2013 Canonical, Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License version 3, as published by
+ * the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+ * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors: Tiago Salem Herrmann <[e-mail]>
+ */
+
+#include <QDBusConnection>
+
+#include "simmanagerprivateadaptor.h"
+
+QMap<QString, SimManagerPrivate*> simManagerData;
+
+SimManagerPrivate::SimManagerPrivate(QObject *parent) :
+    QObject(parent)
+{
+    QDBusConnection::sessionBus().registerObject(OFONO_MOCK_SIM_MANAGER_OBJECT, this);
+    QDBusConnection::sessionBus().registerService("org.ofono");
+    new SimManagerAdaptor(this);
+}
+
+SimManagerPrivate::~SimManagerPrivate()
+{
+}
+
+QVariantMap SimManagerPrivate::GetProperties()
+{
+    return mProperties;
+}
+
+void SimManagerPrivate::SetProperty(const QString &name, const QDBusVariant& value)
+{
+    mProperties[name] = value.variant();
+    Q_EMIT PropertyChanged(name, value);
+}

=== added file 'tests/mock/simmanagerprivate.h'
--- tests/mock/simmanagerprivate.h	1970-01-01 00:00:00 +0000
+++ tests/mock/simmanagerprivate.h	2014-08-20 19:00:56 +0000
@@ -0,0 +1,42 @@
+/**
+ * Copyright (C) 2013 Canonical, Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License version 3, as published by
+ * the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+ * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors: Tiago Salem Herrmann <[e-mail]>
+ */
+
+#ifndef SIMMANAGERPRIVATE_H
+#define SIMMANAGERPRIVATE_H
+
+#include <QDBusContext>
+#include "mock_common.h"
+
+class SimManagerPrivate : public QObject, protected QDBusContext {
+    Q_OBJECT
+    Q_CLASSINFO("D-Bus Interface", "org.ofono.SimManager")
+public:
+    SimManagerPrivate(QObject *parent = 0);
+    ~SimManagerPrivate();
+Q_SIGNALS:
+    void PropertyChanged(const QString &, const QDBusVariant &);
+public Q_SLOTS:
+    QVariantMap GetProperties();
+    void SetProperty(const QString &name, const QDBusVariant &value);
+private:
+    QVariantMap mProperties;
+};
+
+extern QMap<QString, SimManagerPrivate*> simManagerData;
+
+#endif

=== modified file 'tests/ofonomockcontroller.cpp'
--- tests/ofonomockcontroller.cpp	2014-05-08 20:11:46 +0000
+++ tests/ofonomockcontroller.cpp	2014-08-20 19:00:56 +0000
@@ -26,12 +26,14 @@
     mNetworkRegistrationInterface("org.ofono", OFONO_MOCK_NETWORK_REGISTRATION_OBJECT, "org.ofono.NetworkRegistration"),
     mMessageManagerInterface("org.ofono", OFONO_MOCK_MESSAGE_MANAGER_OBJECT, "org.ofono.MessageManager"),
     mVoiceCallManagerInterface("org.ofono", OFONO_MOCK_VOICECALL_MANAGER_OBJECT, "org.ofono.VoiceCallManager"),
-    mModemInterface("org.ofono", OFONO_MOCK_MODEM_OBJECT, "org.ofono.Modem")
+    mModemInterface("org.ofono", OFONO_MOCK_MODEM_OBJECT, "org.ofono.Modem"),
+    mSimManagerInterface("org.ofono", OFONO_MOCK_SIM_MANAGER_OBJECT, "org.ofono.SimManager")
 {
     QDBusConnection::sessionBus().connect("org.ofono", OFONO_MOCK_MESSAGE_MANAGER_OBJECT, "org.ofono.MessageManager", "MessageAdded", this, SIGNAL(MessageAdded(QDBusObjectPath, QVariantMap)));
     QDBusConnection::sessionBus().connect("org.ofono", OFONO_MOCK_VOICECALL_MANAGER_OBJECT, "org.ofono.VoiceCallManager", "CallAdded", this, SIGNAL(CallAdded(QDBusObjectPath, QVariantMap)));
     QDBusConnection::sessionBus().connect("org.ofono", OFONO_MOCK_VOICECALL_MANAGER_OBJECT, "org.ofono.VoiceCallManager", "TonesReceived", this, SIGNAL(TonesReceived(QString)));
     QDBusConnection::sessionBus().connect("org.ofono", OFONO_MOCK_CALL_VOLUME_OBJECT, "org.ofono.CallVolume", "PropertyChanged", this, SLOT(onCallVolumePropertyChanged(QString, QDBusVariant)));
+    QDBusConnection::sessionBus().connect("org.ofono", OFONO_MOCK_SIM_MANAGER_OBJECT, "org.ofono.SimManager", "PropertyChanged", this, SLOT(onSimManagerPropertyChanged(QString, QDBusVariant)));
 }
 
 OfonoMockController *OfonoMockController::instance()
@@ -40,6 +42,13 @@
     return self;
 }
 
+void OfonoMockController::onSimManagerPropertyChanged(const QString& name, const QDBusVariant& value)
+{
+    if (name == "Present") {
+        Q_EMIT SimManagerPresenceChanged(value.variant().value<bool>());
+    }
+}
+
 void OfonoMockController::onCallVolumePropertyChanged(const QString& name, const QDBusVariant& value)
 {
     if (name == "Muted") {
@@ -110,8 +119,12 @@
     iface.call("Hangup");
 }
 
-void OfonoMockController::ModemSetOnline()
+void OfonoMockController::ModemSetOnline(bool online)
 {
-    mModemInterface.call("SetProperty", "Online", QVariant::fromValue(QDBusVariant(true)));
+    mModemInterface.call("SetProperty", "Online", QVariant::fromValue(QDBusVariant(online)));
 }
 
+void OfonoMockController::SimManagerSetPresence(bool present)
+{
+    mSimManagerInterface.call("SetProperty", "Present", QVariant::fromValue(QDBusVariant(present)));
+}

=== modified file 'tests/ofonomockcontroller.h'
--- tests/ofonomockcontroller.h	2014-05-08 20:11:46 +0000
+++ tests/ofonomockcontroller.h	2014-08-20 19:00:56 +0000
@@ -35,6 +35,7 @@
     void CallAdded(QDBusObjectPath, QVariantMap);
     void TonesReceived(QString);
     void CallVolumeMuteChanged(bool muted);
+    void SimManagerPresenceChanged(bool present);
 
 public Q_SLOTS:
     void NetworkRegistrationSetStatus(const QString &status);
@@ -48,10 +49,12 @@
     void VoiceCallHangup(const QString &objPath);
     void VoiceCallAnswer(const QString &objPath);
     void VoiceCallSetAlerting(const QString &objPath);
-    void ModemSetOnline();
+    void ModemSetOnline(bool online = true);
+    void SimManagerSetPresence(bool present);
 
 private Q_SLOTS:
     void onCallVolumePropertyChanged(const QString &name, const QDBusVariant &value);
+    void onSimManagerPropertyChanged(const QString &name, const QDBusVariant &value);
 
 private:
     explicit OfonoMockController(QObject *parent = 0);
@@ -59,6 +62,7 @@
     QDBusInterface mMessageManagerInterface;
     QDBusInterface mVoiceCallManagerInterface;
     QDBusInterface mModemInterface;
+    QDBusInterface mSimManagerInterface;
 };
 
 #endif // OFONOMOCKCONTROLLER_H