implemented ResourceEngine::disconnect()

5 files changed, 126 insertions, 19 deletions

diff --git a/libresourceqt/include/qt4/policy/resource-set.h b/libresourceqt/include/qt4/policy/resource-set.h
index 632ed71..d998807 100644
--- a/libresourceqt/include/qt4/policy/resource-set.h
+++ b/libresourceqt/include/qt4/policy/resource-set.h
@@ -32,7 +32,7 @@
  * resources->addResource(audioResource);
  * resources->addResource(videoResource);
  * resources->initialize();
- * QObject::connect(resources, SIGNAL(connectedToManager), this, SLOT(connectedHandler()));
+ * QObject::connect(resources, SIGNAL(connectedToManager()), this, SLOT(connectedHandler()));
  * resources->connectToManager();
  * \endcode
  * Then the when you want to acquire the \ref ResourcePolicy::ResourceSet you simply use the
diff --git a/libresourceqt/src/resource-engine.cpp b/libresourceqt/src/resource-engine.cpp
index a25c789..9f42a48 100644
--- a/libresourceqt/src/resource-engine.cpp
+++ b/libresourceqt/src/resource-engine.cpp
@@ -61,8 +61,8 @@ static void handleUnregisterMessage(resmsg_t *, resset_t *, void *data)
 void ResourceEngine::disconnected()
 {
     qDebug("disconnected");
-
     connected = false;
+    emit disconnectedFromManager();
 }
 
 static void handleGrantMessage(resmsg_t *msg, resset_t *, void *data)
@@ -124,6 +124,39 @@ bool ResourceEngine::connect()
     return true;
 }
 
+bool ResourceEngine::disconnect()
+{
+    resmsg_t resourceMessage;
+    resourceMessage.record.type = RESMSG_UNREGISTER;
+    resourceMessage.record.id = resourceSet->id();
+    resourceMessage.record.reqno = ++requestId;
+
+    messageMap.insert(requestId, RESMSG_UNREGISTER);
+
+    uint32_t allResources, optionalResources, sharedResources;
+    allResources = allResourcesToBitmask(resourceSet);
+    optionalResources = optionalResourcesToBitmask(resourceSet);
+    sharedResources = sharedResourcesToBitmask(resourceSet);
+
+    resourceMessage.record.rset.all = allResources;
+    resourceMessage.record.rset.opt = optionalResources;
+    resourceMessage.record.rset.share = sharedResources;
+    resourceMessage.record.rset.mask = 0; //find out what it is
+
+    QByteArray ba = resourceSet->applicationClass().toLatin1();
+    resourceMessage.record.klass = ba.data();
+
+    resourceMessage.record.mode = 0; //No auto release
+
+    int r = resconn_disconnect(libresourceSet, &resourceMessage,
+                               statusCallbackHandler);
+    connected = false;
+    if(r)
+        return true;
+    else
+        return false;
+}
+
 static inline quint32 allResourcesToBitmask(const ResourceSet *resourceSet)
 {
     QList<Resource *> resourceList = resourceSet->resources();
@@ -161,6 +194,7 @@ static inline quint32 resourceTypeToLibresourceType(ResourceType type)
             break;
         case SystemButtonType:
             bitmask += RESMSG_SYSTEM_BUTTON;
+            break;
         case LockButtonType:
             bitmask += RESMSG_LOCK_BUTTON;
             break;
@@ -203,14 +237,32 @@ static inline quint32 sharedResourcesToBitmask(const ResourceSet *resourceSet)
     return bitmask;
 }
 
-static void statusCallbackHandler(resset_t *rset, resmsg_t *msg)
+static void statusCallbackHandler(resset_t *libresourceSet, resmsg_t *message)
 {
+    ResourceEngine *resourceEngine = reinterpret_cast<ResourceEngine *>(libresourceSet->userdata);
     qDebug("Received a status notification");
+    resourceEngine->handleStatusMessage(message->status.reqno);
+}
+
+void ResourceEngine::handleStatusMessage(quint32 requestNo)
+{
+    resmsg_type_t messageType = messageMap.take(requestNo);
+    if(messageType == RESMSG_REGISTER) {
+        qDebug("connected!");
+        connected = true;
+        emit connectedToManager();
+    }
+    else if(messageType == RESMSG_UNREGISTER) {
+        qDebug("disconnected!");
+        connected = false;
+        emit disconnectedFromManager();
+    }
+
 }
 
 bool ResourceEngine::isConnected()
 {
-    return false;
+    return connected;
 }
 
 bool ResourceEngine::acquireResources()
@@ -237,7 +289,7 @@ static void connectionIsUp(resconn_t *connection)
 {
     ResourceEngine *resourceEngine;
 
-    resourceEngine = (ResourceEngine *)(connection->dbus.rsets->userdata);
+    resourceEngine = reinterpret_cast<ResourceEngine *>(connection->dbus.rsets->userdata);
 
     resourceEngine->handleConnectionIsUp();
 }
diff --git a/libresourceqt/src/resource-engine.h b/libresourceqt/src/resource-engine.h
index 863a23b..6d81d8e 100644
--- a/libresourceqt/src/resource-engine.h
+++ b/libresourceqt/src/resource-engine.h
@@ -13,6 +13,10 @@ class ResourceEngine: public QObject
 {
     Q_OBJECT
     Q_DISABLE_COPY( ResourceEngine )
+#ifndef QT_NO_DEBUG
+    friend class TestResourceEngine;
+#endif
+
 public:
     ResourceEngine(ResourceSet *resourceSet);
     ~ResourceEngine();
@@ -35,6 +39,8 @@ public:
     void receivedGrant(resmsg_notify_t *notifyMessage);
     void receivedAdvice(resmsg_notify_t *notifyMessage);
 
+    void handleStatusMessage(quint32 requestNo);
+
 signals:
     void resourcesBecameAvailable(QList<Resource *> availableResources);
     void resourcesAcquired(QList<Resource *> grantedResources);
diff --git a/tests/test-resource-engine/test-resource-engine.cpp b/tests/test-resource-engine/test-resource-engine.cpp
index ee2656f..fca6505 100644
--- a/tests/test-resource-engine/test-resource-engine.cpp
+++ b/tests/test-resource-engine/test-resource-engine.cpp
@@ -3,6 +3,9 @@
 
 using namespace ResourcePolicy;
 quint32 theID = 0;
+resset_t *libresourceSet = NULL;
+
+void statusCallbackHandler(resset_t *libresourceSet, resmsg_t *message);
 
 static void verify_resproto_init(resproto_role_t role,
                                  resproto_transport_t transport,
@@ -11,6 +14,8 @@ static void verify_resproto_init(resproto_role_t role,
 
 static void verify_resconn_connect(resconn_t *connection, resmsg_t *message,
                                    resproto_status_t callbackFunction);
+static void verify_resconn_disconnect(resset_t *resourceSet, resmsg_t *message,
+                                      resproto_status_t callbackFunction);
 
 TestResourceEngine::TestResourceEngine()
     : resourceEngine(NULL), resourceSet(NULL)
@@ -54,6 +59,27 @@ void TestResourceEngine::testConnect()
     QVERIFY(connectIsSuccessful);
 }
 
+void TestResourceEngine::testDisconnect()
+{
+    resourceEngine->connect();
+    bool disconnectIsSuccessful = resourceEngine->disconnect();
+    QVERIFY(disconnectIsSuccessful);
+}
+
+void TestResourceEngine::testStatusMessage()
+{
+    resourceEngine->connect();
+    libresourceSet = resourceEngine->libresourceSet;
+    resourceEngine->messageMap.insert(1, RESMSG_REGISTER);
+    QObject::connect(resourceEngine, SIGNAL(connectedToManager()), this, SLOT(connectedHandler()));
+    resourceEngine->handleStatusMessage(1);
+}
+
+void TestResourceEngine::connectedHandler()
+{
+    QVERIFY(resourceEngine->isConnected());
+}
+
 QTEST_MAIN(TestResourceEngine)
 
 ////////////////////////////////////////////////////////////////
@@ -132,3 +158,21 @@ int resproto_set_handler(union resconn_u *, resmsg_type_t, resproto_handler_t)
     return 1;
 }
 
+int resconn_disconnect(resset_t *resSet, resmsg_t *message,
+                       resproto_status_t callbackFunction)
+{
+    verify_resconn_disconnect(resSet, message, callbackFunction);
+
+    return 1;
+}
+
+static void verify_resconn_disconnect(resset_t *resourceSet, resmsg_t *message,
+                                      resproto_status_t callbackFunction)
+{
+    QVERIFY(resourceSet == libresourceSet);
+    QVERIFY(message->record.type == RESMSG_UNREGISTER);
+    QVERIFY(message->record.id == theID);
+    QVERIFY(message->record.reqno > 1);
+    QVERIFY(callbackFunction != NULL);
+}
+
diff --git a/tests/test-resource-engine/test-resource-engine.h b/tests/test-resource-engine/test-resource-engine.h
index 5e7a79b..131eaf1 100644
--- a/tests/test-resource-engine/test-resource-engine.h
+++ b/tests/test-resource-engine/test-resource-engine.h
@@ -4,29 +4,34 @@
 #include <QtTest/QTest>
 #include "resource-engine.h"
 
-using namespace ResourcePolicy;
+namespace ResourcePolicy
+{
 
 class TestResourceEngine: public QObject
 {
-   Q_OBJECT
+    Q_OBJECT
 private:
-   ResourceEngine *resourceEngine;
-   AudioResource *audioPlayback;
-   VideoResource *videoPlayback;
-   AudioRecorderResource *audioRecorder;
-   VideoRecorderResource *videoRecorder;
-   bool libresourceInitialized;
+    ResourceEngine *resourceEngine;
+    AudioResource *audioPlayback;
+    VideoResource *videoPlayback;
+    AudioRecorderResource *audioRecorder;
+    VideoRecorderResource *videoRecorder;
+    bool libresourceInitialized;
 public:
-   ResourceSet *resourceSet;
+    ResourceSet *resourceSet;
 
-   TestResourceEngine();
-   ~TestResourceEngine();
+    TestResourceEngine();
+    ~TestResourceEngine();
 public slots:
+    void connectedHandler();
 
 private slots:
-   void init();
+    void init();
 
-   void testConnect();
+    void testConnect();
+    void testDisconnect();
+    
+    void testStatusMessage();
 };
-
+}
 #endif