Refactored Resource into multiple classes

5 files changed, 57 insertions, 274 deletions

diff --git a/src/libplayback-wrapper.cpp b/src/libplayback-wrapper.cpp
deleted file mode 100644
index ce3a43d..0000000
--- a/src/libplayback-wrapper.cpp
+++ /dev/null
@@ -1,163 +0,0 @@
-#include "libplayback-wrapper.h"
-
-using namespace ResourceTypes;
-static inline enum pb_class_e resourceClassToLibPlaybackClass(enum ResourceClass resourceClass);
-static inline quint16 resourceFlagsToLibPlaybackFlags(quint16 resourceFlags);
-static inline enum ResourceState libPlaybackStateToResourceState(enum pb_state_e libPlaybackState);
-static void libPlaybackStateHandler(pb_playback_t *libPlaybackHandler, enum pb_state_e newState,
-				    pb_req_t* playbackRequest, void *data);
-static void libPlaybackStateHintHandler(pb_playback_t *libPlaybackHandler, const int allowedStates[], void *data);
-
-LibPlaybackWrapper::LibPlaybackWrapper(Resource *res)
-    : QObject(res), dbusConnection(NULL), libPlaybackHandle(NULL)
-{
-    resource = res;
-}
-
-LibPlaybackWrapper::~LibPlaybackWrapper()
-{
-    pb_playback_destroy(libPlaybackHandle);
-}
-
-bool LibPlaybackWrapper::initialize()
-{
-    DBusError dbusError;
-    dbus_error_init(&dbusError);
-    dbusConnection = dbus_bus_get(DBUS_BUS_SESSION, &dbusError);
-    qDebug("dbusConnection=%p", dbusConnection);
-    if (dbus_error_is_set(&dbusError)) {
-	qDebug("D-Bus Connection Error (%s)\n", dbusError.message);
-	dbus_error_free(&dbusError);
-	return false;
-    }
-    if(dbusConnection == NULL) {
-	qDebug("Unable to connect to dbus, dbusConnection == NULL!");
-	return false;
-    }
-    return true;
-}
-
-bool LibPlaybackWrapper::connectToServer()
-{
-    enum pb_class_e libPlaybackClass = resourceClassToLibPlaybackClass(resource->applicationClass());
-    quint16 libPlaybackFlags = resourceFlagsToLibPlaybackFlags(resource->resources());
-
-    qDebug("libPlaybackFlags=%02x resources=%02x",libPlaybackFlags, resource->resources());
-    qDebug("dbusConnection=%p", dbusConnection);
-
-    libPlaybackHandle = pb_playback_new_2(dbusConnection, libPlaybackClass, libPlaybackFlags,
-					  PB_STATE_STOP, libPlaybackStateHandler, this);
-    if(libPlaybackHandle == NULL) {
-	return false;
-    }
-    return true;
-}
-
-inline enum pb_class_e resourceClassToLibPlaybackClass(enum ResourceClass resourceClass)
-{
-    switch(resourceClass) {
-    case InvalidClass:
-	return PB_CLASS_NONE;
-    case CallClass:
-	return PB_CLASS_CALL;
-    case MediaClass:
-	return PB_CLASS_MEDIA;
-    case BackgroundClass:
-	return PB_CLASS_BACKGROUND;
-    case RingtoneClass:
-	return PB_CLASS_RINGTONE;
-    case VoiceUIClass:
-	return PB_CLASS_VOICEUI;
-    case CameraClass:
-	return PB_CLASS_CAMERA;
-    case GameClass:
-	return PB_CLASS_GAME;
-    case AlarmClass:
-	return PB_CLASS_ALARM;
-    case FlashClass:
-	return PB_CLASS_FLASH;
-    case SystemClass:
-	return PB_CLASS_SYSTEM;
-    case InputClass:
-	return PB_CLASS_INPUT;
-    default:
-	return PB_CLASS_NONE;
-    }
-}
-
-inline quint16 resourceFlagsToLibPlaybackFlags(quint16 resourceFlags)
-{
-    quint16 libPlaybackFlags = 0;
-    for (int flag=AudioResource;flag<VideoRecorderResource;flag=flag<<1) {
-	if((resourceFlags & flag) == flag) {
-	    switch(flag) {
-	    case AudioResource:
-		libPlaybackFlags += PB_FLAG_AUDIO;
-		break;
-	    case VideoResource:
-		libPlaybackFlags += PB_FLAG_VIDEO;
-		break;
-	    case AudioRecorderResource:
-		libPlaybackFlags += PB_FLAG_AUDIO_RECORDING;
-		break;
-	    case VideoRecorderResource:
-		libPlaybackFlags += PB_FLAG_VIDEO_RECORDING;
-		break;
-	    }
-	}
-    }
-    return libPlaybackFlags;
-}
-
-void libPlaybackStateHandler(pb_playback_t *libPlaybackHandler, enum pb_state_e newState,
-			     pb_req_t* playbackRequest, void *data)
-{
-    LibPlaybackWrapper *libPlaybackWrapper = static_cast<LibPlaybackWrapper*>(data);
-
-    pb_playback_req_completed(libPlaybackHandler, playbackRequest);
-    libPlaybackWrapper->stateChanged(newState);
-}
-
-void LibPlaybackWrapper::stateChanged(enum pb_state_e newState)
-{
-    enum ResourceState resourceState;
-    resourceState = libPlaybackStateToResourceState(newState);
-    
-    resource->handleStateChange(resourceState);
-}
-
-inline enum ResourceState libPlaybackStateToResourceState(enum pb_state_e libPlaybackState)
-{
-    switch(libPlaybackState) {
-    case PB_STATE_STOP:
-	return NotOwnedState;
-    case PB_STATE_PLAY:
-	return OwnedState;
-    default:
-	return UnknownState;
-    }	
-}
-
-static void libPlaybackStateHintHandler(pb_playback_t *libPlaybackHandler, const int allowedStates[], void *data)
-{
-    LibPlaybackWrapper *libPlaybackWrapper = static_cast<LibPlaybackWrapper*>(data);
-
-    libPlaybackWrapper->hintReceived(allowedStates);
-}
-
-void LibPlaybackWrapper::hintReceived(const int allowedStates[])
-{
-    if(allowedStates[PB_STATE_PLAY]) {
-	resource->emitReservable();
-    }
-    // Ignore PB_STATE_STOP
-/*    else if(allowedStates[PB_STATE_STOP]) {
-	
-    }
-*/
-}
-
-bool LibPlaybackWrapper::reserve()
-{
-    return false;
-}
diff --git a/src/libplayback-wrapper.h b/src/libplayback-wrapper.h
deleted file mode 100644
index 9a473fe..0000000
--- a/src/libplayback-wrapper.h
+++ /dev/null
@@ -1,29 +0,0 @@
-#ifndef LIBPLAYBACKWRAPPER_H
-#define LIBPLAYBACKWRAPPER_H
-
-#include "resource-library.h"
-#include "resource.h"
-#include <libplayback/playback.h>
-
-class LibPlaybackWrapper: public QObject, public ResourceLibrary
-{
-   Q_OBJECT
-   Q_DISABLE_COPY( LibPlaybackWrapper );
-private:
-   DBusConnection *dbusConnection;
-   pb_playback_t *libPlaybackHandle;
-   Resource *resource;
-
-public:
-   LibPlaybackWrapper(Resource *resource);
-   ~LibPlaybackWrapper();
-   bool initialize();
-   bool connectToServer();
-
-   bool reserve();
-
-   void stateChanged(enum pb_state_e newState);
-   void hintReceived(const int allowedStates[]);
-};
-
-#endif
diff --git a/src/resource-library.h b/src/resource-library.h
deleted file mode 100644
index 9f9c303..0000000
--- a/src/resource-library.h
+++ /dev/null
@@ -1,13 +0,0 @@
-#ifndef RESOURCELIBRARY_H
-#define RESOURCELIBRARY_H
-
-class ResourceLibrary
-{
-public:
-   virtual ~ResourceLibrary() {}
-   virtual bool initialize() = 0;
-   virtual bool connectToServer() = 0;
-   virtual bool reserve() = 0;
-};
-
-#endif
diff --git a/src/resource-set.cpp b/src/resource-set.cpp
index 8f6431b..73a4bc4 100644
--- a/src/resource-set.cpp
+++ b/src/resource-set.cpp
@@ -3,55 +3,47 @@ using namespace ResourcePolicy;
 
 
 ResourceSet::ResourceSet(const QString &applicationClass, QObject * parent)
-    : QObject(parent), applicationClass(applicationClass),
-      resourceSet(ResourceGuard)
+    : QObject(parent), applicationClass(applicationClass)
 {
     identifier = (quint32)this;
+    memset(resourceSet, 0, sizeof(QPointer<Resource>)*NumberOfTypes);
 }
 
 ResourceSet::~ResourceSet()
 {
+    for(int i=0;i<NumberOfTypes;i++) {
+        delete resourceSet[i];
+    }
 }
 
-void ResourceSet::addResource(const Resource &resource)
-{
-    resourceSet.insert(resource.type(), resource);
-}
-
-void ResourceSet::addResources(const QList<Resource> &resources)
+void ResourceSet::addResource(const Resource *resource)
 {
-    for(int i=0; i < resources.size(); i++) {
-	addResource(resources.at(i));
-    }
+    resourceSet[resource->type()] = resource->clone();
 }
 
-void ResourceSet::setResources(const QList<Resource> &resources)
+void ResourceSet::addResources(const QList<Resource *>resources)
 {
-    Resource invalidResource;
-    resourceSet.clear();
-    resourceSet.resize(ResourceGuard);
     for(int i=0; i < resources.size(); i++) {
-	addResource(resources.at(i));
+        addResource(resources.at(i));
     }
 }
 
-bool ResourceSet::contains(const Resource &resource) const
+bool ResourceSet::contains(ResourceType type) const
 {
-    if(resourceSet.at(resource.type()) == resource)
-	return true;
+    if((type < NumberOfTypes) && (resourceSet[type] != NULL))
+        return true;
     else
-	return false;
+        return false;
 }
 
-bool ResourceSet::contains(const QList<Resource> &resources) const
+bool ResourceSet::contains(const QList<ResourceType> &types) const
 {
-    bool containsAll=false;
-    for(int i=0; i<resources.size(); i++) {
-	containsAll = contains(resources.at(i));
-	if(!containsAll) {
-	    break;
-	}
-    }
+    bool containsAll=true;
+    int i=0;
+    do {
+        containsAll = contains(types.at(i));
+        i++;
+    } while((i < NumberOfTypes) && containsAll);
     return containsAll;
 }
 
@@ -60,17 +52,26 @@ quint32 ResourceSet::id() const
     return identifier;
 }
 
-QList<Resource> ResourceSet::resources()
+QList<Resource *> ResourceSet::resources()
 {
-    QList<Resource> listOfResources;
-    for(int i=0; i < resourceSet.size(); i++) {
-	if(resourceSet.at(i).type() != InvalidResource) {
-	    listOfResources.append(resourceSet.at(i));
-	}
+    QList<Resource *> listOfResources;
+    for(int i=0; i < NumberOfTypes; i++) {
+        if(resourceSet[i] != NULL) {
+            Resource *clone = resourceSet[i]->clone();
+            listOfResources.append(clone);
+        }
     }
     return listOfResources;
 }
 
+Resource * ResourceSet::resource(ResourceType type) const
+{
+    if(contains(type))
+        return resourceSet[type]->clone();
+    else
+        return NULL;
+}
+
 bool ResourceSet::connectToManager(bool reconnectOnDisconnect)
 {
     return false;
@@ -99,3 +100,4 @@ bool ResourceSet::update()
 {
     return false;
 }
+
diff --git a/src/resource.cpp b/src/resource.cpp
index 72ac24e..8207b66 100644
--- a/src/resource.cpp
+++ b/src/resource.cpp
@@ -2,44 +2,21 @@
 
 using namespace ResourcePolicy;
 
-Resource::Resource(enum ResourceType type)
-    : resourceType(type), optional(false), shared(false)
-{
-}
-
-Resource::~Resource()
+Resource::Resource()
+    :   optional(false), shared(false),
+        identifier(0), granted(false)
 {
+    identifier = (quint32)this;
 }
 
 Resource::Resource(const Resource &other)
-    : resourceType(other.resourceType), optional(other.optional),
-      shared(other.shared)
-{
-}
-
-Resource & Resource::operator=(const Resource &other)
-{
-    resourceType = other.resourceType;
-    optional = other.optional;
-    shared = other.shared;
-
-    return *this;
-}
-
-ResourceType Resource::type() const
+    :   optional(other.optional), shared(other.shared),
+        identifier(other.identifier), granted(other.granted)
 {
-    return resourceType;
 }
 
-bool Resource::setType(ResourceType type)
+Resource::~Resource()
 {
-    if(type != InvalidResource) {
-	resourceType = type;
-	return true;
-    }
-    else {
-	return false;
-    }
 }
 
 bool Resource::isOptional() const
@@ -62,10 +39,19 @@ void Resource::setShared(bool shared)
     this->shared = shared;
 }
 
-bool Resource::operator==(const Resource &other) const
+bool Resource::isGranted() const
+{
+    return granted;
+}
+
+void Resource::setGranted()
 {
-    if(resourceType != other.resourceType) {
-	return false;
-    }
-    return true;
+    granted = true;
 }
+
+void Resource::unsetGranted()
+{
+    granted = false;
+}
+
+