summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--libresourceqt/include/qt4/policy/resource-set.h2
-rw-r--r--libresourceqt/src/resource-engine.cpp88
-rw-r--r--libresourceqt/src/resource-engine.h7
-rw-r--r--tests/test-resource-engine/test-resource-engine.cpp63
-rw-r--r--tests/test-resource-engine/test-resource-engine.h3
5 files changed, 110 insertions, 53 deletions
diff --git a/libresourceqt/include/qt4/policy/resource-set.h b/libresourceqt/include/qt4/policy/resource-set.h
index 9de0e08..be794d3 100644
--- a/libresourceqt/include/qt4/policy/resource-set.h
+++ b/libresourceqt/include/qt4/policy/resource-set.h
@@ -1,11 +1,11 @@
#ifndef RESOURCE_SET_H
#define RESOURCE_SET_H
-#include <policy/resources.h>
#include <QString>
#include <QObject>
#include <QVector>
#include <QList>
+#include <policy/resources.h>
/**
* \mainpage Resource Policy Library
diff --git a/libresourceqt/src/resource-engine.cpp b/libresourceqt/src/resource-engine.cpp
index 0bc8fcd..bc29de9 100644
--- a/libresourceqt/src/resource-engine.cpp
+++ b/libresourceqt/src/resource-engine.cpp
@@ -5,7 +5,6 @@ using namespace ResourcePolicy;
static inline quint32 allResourcesToBitmask(const ResourceSet *resourceSet);
static inline quint32 optionalResourcesToBitmask(const ResourceSet *resourceSet);
-static inline quint32 resourceTypeToLibresourceType(ResourceType type);
static void connectionIsUp(resconn_t *connection);
static void statusCallbackHandler(resset_t *rset, resmsg_t *msg);
@@ -73,9 +72,13 @@ static void handleGrantMessage(resmsg_t *msg, resset_t *, void *data)
void ResourceEngine::receivedGrant(resmsg_notify_t *notifyMessage)
{
- char buf[80];
- resmsg_res_str(notifyMessage->resrc, buf, sizeof(buf));
- qDebug("%s: %s", __FUNCTION__, buf);
+ qDebug("received a grant message");
+ if(notifyMessage->resrc == 0) {
+ emit resourcesDenied();
+ }
+ else {
+ emit resourcesAcquired(notifyMessage->resrc);
+ }
}
static void handleAdviceMessage(resmsg_t *msg, resset_t *, void *data)
@@ -164,50 +167,36 @@ static inline quint32 allResourcesToBitmask(const ResourceSet *resourceSet)
return bitmask;
}
-static inline quint32 resourceTypeToLibresourceType(ResourceType type)
+quint32 ResourcePolicy::resourceTypeToLibresourceType(ResourceType type)
{
- quint32 bitmask = 0;
switch (type) {
case AudioPlaybackType:
- bitmask += RESMSG_AUDIO_PLAYBACK;
- break;
+ return RESMSG_AUDIO_PLAYBACK;
case VideoPlaybackType:
- bitmask += RESMSG_VIDEO_PLAYBACK;
- break;
+ return RESMSG_VIDEO_PLAYBACK;
case AudioRecorderType:
- bitmask += RESMSG_AUDIO_RECORDING;
- break;
+ return RESMSG_AUDIO_RECORDING;
case VideoRecorderType:
- bitmask += RESMSG_VIDEO_RECORDING;
- break;
+ return RESMSG_VIDEO_RECORDING;
case VibraType:
- bitmask += RESMSG_VIBRA;
- break;
+ return RESMSG_VIBRA;
case LedsType:
- bitmask += RESMSG_LEDS;
- break;
+ return RESMSG_LEDS;
case BacklightType:
- bitmask += RESMSG_BACKLIGHT;
- break;
+ return RESMSG_BACKLIGHT;
case SystemButtonType:
- bitmask += RESMSG_SYSTEM_BUTTON;
- break;
+ return RESMSG_SYSTEM_BUTTON;
case LockButtonType:
- bitmask += RESMSG_LOCK_BUTTON;
- break;
+ return RESMSG_LOCK_BUTTON;
case ScaleButtonType:
- bitmask += RESMSG_SCALE_BUTTON;
- break;
+ return RESMSG_SCALE_BUTTON;
case SnapButtonType:
- bitmask += RESMSG_SNAP_BUTTON;
- break;
+ return RESMSG_SNAP_BUTTON;
case LensCoverType:
- bitmask += RESMSG_LENS_COVER;
- break;
+ return RESMSG_LENS_COVER;
default:
- break;
+ return 0;
}
- return bitmask;
}
static inline quint32 optionalResourcesToBitmask(const ResourceSet *resourceSet)
@@ -226,12 +215,23 @@ 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);
+ if (message->type != RESMSG_STATUS) {
+ qDebug("Invalid message type.. (got %x, expected %x", message->type, RESMSG_STATUS);
+ return;
+ }
+ if (message->status.errcod) {
+ resourceEngine->handleError(message->status.reqno, message->status.errcod, message->status.errmsg);
+ }
+ else {
+// resourceEngine->handleStatusMessage(message->status.reqno);
+ qDebug("Received a status message of type 0x%02x and #:%u", message->type, message->status.reqno);
+ }
}
void ResourceEngine::handleStatusMessage(quint32 requestNo)
{
resmsg_type_t messageType = messageMap.take(requestNo);
+ qDebug("Received a status message: %u(0x%02x)", requestNo, messageType);
if (messageType == RESMSG_REGISTER) {
qDebug("connected!");
connected = true;
@@ -242,7 +242,12 @@ void ResourceEngine::handleStatusMessage(quint32 requestNo)
connected = false;
emit disconnectedFromManager();
}
+}
+void ResourceEngine::handleError(quint32 requestNo, quint32 code, const char *message)
+{
+ resmsg_type_t messageType = messageMap.take(requestNo);
+ qDebug("Error on request %u(0x%02x): %u - %s", requestNo, messageType, code, message);
}
bool ResourceEngine::isConnected()
@@ -252,7 +257,22 @@ bool ResourceEngine::isConnected()
bool ResourceEngine::acquireResources()
{
- return false;
+ resmsg_t message;
+ memset(&message, 0, sizeof(resmsg_t));
+
+ message.possess.type = RESMSG_ACQUIRE;
+ message.any.id = resourceSet->id();
+ message.any.reqno = ++requestId;
+
+ messageMap.insert(requestId, RESMSG_ACQUIRE);
+
+ qDebug("acquire %u:%u", resourceSet->id(), requestId);
+ int success = resproto_send_message(libresourceSet, &message, statusCallbackHandler);
+
+ if(!success)
+ return false;
+ else
+ return true;
}
bool ResourceEngine::releaseResources()
diff --git a/libresourceqt/src/resource-engine.h b/libresourceqt/src/resource-engine.h
index 0375a92..72b567d 100644
--- a/libresourceqt/src/resource-engine.h
+++ b/libresourceqt/src/resource-engine.h
@@ -3,12 +3,15 @@
#include <QObject>
#include <QMap>
+#include <QString>
#include <dbus/dbus.h>
#include <res-conn.h>
#include <policy/resource-set.h>
namespace ResourcePolicy {
+quint32 resourceTypeToLibresourceType(ResourceType type);
+
class ResourceEngine: public QObject
{
Q_OBJECT
@@ -40,14 +43,14 @@ public:
void receivedAdvice(resmsg_notify_t *notifyMessage);
void handleStatusMessage(quint32 requestNo);
+ void handleError(quint32 requestNo, quint32 code, const char *message);
void setMode(quint32 newMode);
signals:
void resourcesBecameAvailable(QList<ResourceType> availableResources);
- void resourcesAcquired(QList<ResourceType> grantedResources);
+ void resourcesAcquired(quint32 bitmaskOfGrantedResources);
void resourcesDenied();
- void lostResources();
void connectedToManager();
void disconnectedFromManager();
diff --git a/tests/test-resource-engine/test-resource-engine.cpp b/tests/test-resource-engine/test-resource-engine.cpp
index dc16405..df5b187 100644
--- a/tests/test-resource-engine/test-resource-engine.cpp
+++ b/tests/test-resource-engine/test-resource-engine.cpp
@@ -19,8 +19,9 @@ static void verify_resproto_send_message(resset_t *resourceSet, resmsg_t *messag
resproto_status_t callbackFunction);
TestResourceEngine::TestResourceEngine()
- : resourceEngine(NULL), resourceSet(NULL)
{
+ resourceEngine = NULL;
+ acquireOrDenyWasCalled = false;
audioPlayback = new AudioResource;
videoPlayback = new VideoResource;
audioRecorder = new AudioRecorderResource;
@@ -50,6 +51,7 @@ void TestResourceEngine::init()
{
resourceEngine = new ResourceEngine(resourceSet);
bool initializeSucceeded = resourceEngine->initialize();
+ acquireOrDenyWasCalled = false;
QVERIFY(!resourceEngine->isConnected());
QVERIFY(initializeSucceeded);
}
@@ -87,7 +89,7 @@ void TestResourceEngine::connectedHandler()
void TestResourceEngine::testAcquire_data()
{
- QTest::addColumn<bool>("aquireSucceeds");
+ QTest::addColumn<bool>("acquireSucceeds");
QTest::addColumn<ResourceType>("optionalTypeAvailable");
QTest::addColumn<bool>("requestFails");
QTest::addColumn<QString>("errorMessage");
@@ -119,34 +121,50 @@ void TestResourceEngine::testAcquire()
QByteArray ba = errorMessage.toLatin1();
requestErrorMessage = ba.data();
- QObject::connect(resourceEngine, SIGNAL(resourcesAcquired(QList<ResourceType>)),
- this, SLOT(handleAcquire(QList<ResourceType>)));
- QObject::connect(resourceEngine, SIGNAL(resourcesDenies()),
- this, SLOT(handleDeny(QList<ResourceType>)));
+ QObject::connect(resourceEngine, SIGNAL(resourcesAcquired(quint32)),
+ this, SLOT(handleAcquire(quint32)));
+ QObject::connect(resourceEngine, SIGNAL(resourcesDenied()),
+ this, SLOT(handleDeny()));
bool acquireRequestSucceeded = resourceEngine->acquireResources();
- QVERIFY(acquireRequestSucceeded);
+ QVERIFY(acquireRequestSucceeded == !requestShouldFail);
+ QVERIFY(acquireOrDenyWasCalled);
}
-void TestResourceEngine::handleAcquire(QList<ResourceType> optionalResources)
+void TestResourceEngine::handleAcquire(quint32 bitmaskOfGrantedResources)
{
+ qDebug("Acquired resources: 0x%04x", bitmaskOfGrantedResources);
QVERIFY(acquireShouldSucceed);
bool hasOptionalResource = false;
- for (int i = 0; i < optionalResources.size(); i++) {
- if (optionalResources.at(i) == optionalType) {
- hasOptionalResource = true;
- break;
+ QList<Resource *> resourceList = resourceSet->resources();
+ for (int i=0; i < resourceList.size(); i++) {
+ quint32 bitmask = resourceTypeToLibresourceType(resourceList.at(i)->type());
+ qDebug("Checking if resource %x(%x) is in the list", resourceList.at(i)->type(), bitmask);
+ if ((bitmask & bitmaskOfGrantedResources) == bitmask)
+ {
+ qDebug("Yes :)");
+ if (resourceList.at(i)->type() == optionalType) {
+ qDebug("Resource is the one we are looking for. :D");
+ hasOptionalResource = true;
+ break;
+ }
+ }
+ else {
+ qDebug("No :(");
}
}
- if ((optionalType == NumberOfTypes) && (optionalResources.size() == 0)) {
+ if ((optionalType == NumberOfTypes) && (bitmaskOfGrantedResources > 0)) {
+ qDebug("Expected to get no optional resources");
hasOptionalResource = true;
}
QVERIFY(hasOptionalResource);
+ acquireOrDenyWasCalled = true;
}
void TestResourceEngine::handleDeny()
{
QVERIFY(!acquireShouldSucceed);
+ acquireOrDenyWasCalled = true;
}
QTEST_MAIN(TestResourceEngine)
@@ -257,19 +275,34 @@ int resproto_send_message(resset_t *resourceSet, resmsg_t *message,
{
resmsg_t replyMessage, statusMessage;
+ qDebug("%s(): id:%u req#: %u", __FUNCTION__, message->record.id, message->record.reqno);
+
replyMessage.type = RESMSG_GRANT;
- replyMessage.notify.resrc = RESMSG_VIDEO_PLAYBACK | RESMSG_VIDEO_RECORDING;
+ if (acquireShouldSucceed) {
+ replyMessage.notify.resrc = RESMSG_AUDIO_PLAYBACK | RESMSG_AUDIO_RECORDING
+ | RESMSG_VIDEO_PLAYBACK | RESMSG_VIDEO_RECORDING;
+ }
+ else {
+ replyMessage.notify.resrc = 0;
+ }
+ replyMessage.record.id = message->record.id;
+ replyMessage.record.reqno = message->record.reqno;
verify_resproto_send_message(resourceSet, message, callbackFunction);
statusMessage.type = RESMSG_STATUS;
statusMessage.status.errcod = requestShouldFail;
statusMessage.status.errmsg = requestErrorMessage;
+ statusMessage.record.id = 11;
+ statusMessage.record.reqno = 77;
callbackFunction(resSet, &statusMessage);
grantCallback(&replyMessage, resSet, resSet->userdata);
- return 1;
+ if (requestShouldFail)
+ return 0;
+ else
+ return 1;
}
static void verify_resproto_send_message(resset_t *resourceSet, resmsg_t *message,
diff --git a/tests/test-resource-engine/test-resource-engine.h b/tests/test-resource-engine/test-resource-engine.h
index 151f26a..c94cce9 100644
--- a/tests/test-resource-engine/test-resource-engine.h
+++ b/tests/test-resource-engine/test-resource-engine.h
@@ -19,6 +19,7 @@ private:
AudioRecorderResource *audioRecorder;
VideoRecorderResource *videoRecorder;
bool libresourceInitialized;
+ bool acquireOrDenyWasCalled;
public:
ResourceSet *resourceSet;
@@ -28,7 +29,7 @@ public:
public slots:
void connectedHandler();
void handleDeny();
- void handleAcquire(QList<ResourceType> optionalResources);
+ void handleAcquire(quint32 bitmaskOfResources);
private slots:
void init();