Renamed things to improive the API and implemented the mandatory State

Changed handler. Added access methods to Resource.

4 files changed, 87 insertions, 28 deletions

diff --git a/src/libplayback-wrapper.cpp b/src/libplayback-wrapper.cpp
index 6b51f94..a869b63 100644
--- a/src/libplayback-wrapper.cpp
+++ b/src/libplayback-wrapper.cpp
@@ -1,5 +1,12 @@
 #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);
+
 LibPlaybackWrapper::LibPlaybackWrapper(Resource *res)
     : QObject(res), dbusConnection(NULL), libPlaybackHandle(NULL)
 {
@@ -30,8 +37,8 @@ bool LibPlaybackWrapper::initialize()
 
 bool LibPlaybackWrapper::connectToServer()
 {
-    enum pb_class_e libPlaybackClass = resourceClassToLibPlaybackClass(resource->getResourceClass());
-    quint16 libPlaybackFlags = resourceFlagToLibPlaybackFlags(resource->getResourceFlags());
+    enum pb_class_e libPlaybackClass = resourceClassToLibPlaybackClass(resource->applicationClass());
+    quint16 libPlaybackFlags = resourceFlagsToLibPlaybackFlags(resource->resources());
     libPlaybackHandle = pb_playback_new_2(dbusConnection, libPlaybackClass, libPlaybackFlags,
 					  PB_STATE_STOP, libPlaybackStateHandler, this);
     if(libPlaybackHandle == NULL) {
@@ -40,7 +47,7 @@ bool LibPlaybackWrapper::connectToServer()
     return true;
 }
 
-enum pb_class_e resourceClassToLibPlaybackClass(enum ResourceClass resourceClass)
+inline enum pb_class_e resourceClassToLibPlaybackClass(enum ResourceClass resourceClass)
 {
     switch(resourceClass) {
     case InvalidClass:
@@ -72,22 +79,22 @@ enum pb_class_e resourceClassToLibPlaybackClass(enum ResourceClass resourceClass
     }
 }
 
-quint16 resourceFlagToLibPlaybackFlags(quint16 resourceFlags)
+inline quint16 resourceFlagsToLibPlaybackFlags(quint16 resourceFlags)
 {
     quint16 libPlaybackFlags = 0;
-    for (int flag=RP_FLAGS_AUDIO;flag<RP_FLAGS_VIDEO_RECORDING;flag=flag<<1) {
+    for (int flag=AudioResource;flag<VideoRecorderResource;flag=flag<<1) {
 	if((resourceFlags & flag) == flag) {
 	    switch(flag) {
-	    case RP_FLAGS_AUDIO:
+	    case AudioResource:
 		libPlaybackFlags += PB_FLAG_AUDIO;
 		break;
-	    case RP_FLAGS_VIDEO:
+	    case VideoResource:
 		libPlaybackFlags += PB_FLAG_VIDEO;
 		break;
-	    case RP_FLAGS_AUDIO_RECORDING:
+	    case AudioRecorderResource:
 		libPlaybackFlags += PB_FLAG_AUDIO_RECORDING;
 		break;
-	    case RP_FLAGS_VIDEO_RECORDING:
+	    case VideoRecorderResource:
 		libPlaybackFlags += PB_FLAG_VIDEO_RECORDING;
 		break;
 	    }
@@ -96,12 +103,33 @@ quint16 resourceFlagToLibPlaybackFlags(quint16 resourceFlags)
     return libPlaybackFlags;
 }
 
-void libPlaybackStateHandler(pb_playback_t *libPlaybackHandle, enum pb_state_e requestedState,
+void libPlaybackStateHandler(pb_playback_t *libPlaybackHandler, enum pb_state_e newState,
 			     pb_req_t* playbackRequest, void *data)
 {
-//    LibPlaybackWrapper *libPlaybackWrapper = (LibPlaybackWrapper*)data;
+    LibPlaybackWrapper *libPlaybackWrapper = static_cast<LibPlaybackWrapper*>(data);
+
+    libPlaybackWrapper->stateChanged(newState);
 
-//    libPlaybackWrapper->handleNewState(requestedState);
+    pb_playback_req_completed(libPlaybackHandler, playbackRequest);
+}
 
-    pb_playback_req_completed(libPlaybackHandle, playbackRequest);
+
+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;
+    }	
 }
diff --git a/src/libplayback-wrapper.h b/src/libplayback-wrapper.h
index be86c7f..103d710 100644
--- a/src/libplayback-wrapper.h
+++ b/src/libplayback-wrapper.h
@@ -1,10 +1,10 @@
+#ifndef LIBPLAYBACKWRAPPER_H
+#define LIBPLAYBACKWRAPPER_H
+
 #include "resource-library.h"
 #include "resource.h"
 #include <libplayback/playback.h>
 
-#ifndef LIBPLAYBACKWRAPPER_H
-#define LIBPLAYBACKWRAPPER_H
-
 class LibPlaybackWrapper: public QObject, public ResourceLibrary
 {
    Q_OBJECT
@@ -13,16 +13,13 @@ private:
    DBusConnection *dbusConnection;
    pb_playback_t *libPlaybackHandle;
    Resource *resource;
+
 public:
    LibPlaybackWrapper(Resource *resource);
    ~LibPlaybackWrapper();
    bool initialize();
    bool connectToServer();
+   void stateChanged(enum pb_state_e newState);
 };
 
-void libPlaybackStateHandler(pb_playback_t *libPlaybackHandle, enum pb_state_e requestedState,
-			     pb_req_t* playbackRequest, void *data);
-
-inline enum pb_class_e resourceClassToLibPlaybackClass(enum ResourceClass resourceClass);
-inline quint16 resourceFlagToLibPlaybackFlags(quint16 resourceFlag);
 #endif
diff --git a/src/resource-factory.cpp b/src/resource-factory.cpp
index b042b34..c012bb9 100644
--- a/src/resource-factory.cpp
+++ b/src/resource-factory.cpp
@@ -1,6 +1,8 @@
 #include "resource-factory.h"
 #include "libplayback-wrapper.h"
 
+using namespace ResourceTypes;
+
 ResourceFactory::ResourceFactory(QObject *parent)
     : QObject(parent), sessionBusConnection(QDBusConnection::sessionBus())
 {
@@ -10,9 +12,10 @@ ResourceFactory::~ResourceFactory()
 {
 }
 
-Resource * ResourceFactory::createResource(enum ResourceClass type, quint16 usageFlags)
+Resource * ResourceFactory::createResource(enum ResourceClass applicationClass,
+					   quint16 requestedResources)
 {
-    Resource *resource = new Resource(type, usageFlags, this);
+    Resource *resource = new Resource(applicationClass, requestedResources, this);
     ResourceLibrary *libPlayback = new LibPlaybackWrapper(resource);
 
     bool resourceProperlyInitialized = resource->initialize(libPlayback);
diff --git a/src/resource.cpp b/src/resource.cpp
index 2de05ee..1765c04 100644
--- a/src/resource.cpp
+++ b/src/resource.cpp
@@ -1,7 +1,9 @@
 #include "resource.h"
 
-Resource::Resource(enum ResourceClass type, quint16 resourceFlags, QObject *parent)
-    : QObject(parent), resourceClass(type), flags(resourceFlags)
+Resource::Resource(enum ResourceClass requestedClass, quint16 requestedResources,
+		   QObject *parent)
+    : QObject(parent), resourceClass(requestedClass),
+      resourceType(requestedResources), resourceState(UnknownState)
 {
 }
 
@@ -20,16 +22,44 @@ bool Resource::connectToServer()
     return resourceLibrary->connectToServer();
 }
 
-quint16 Resource::getResourceFlags()
+quint16 Resource::resources() const
 {
-    return flags;
+    return resourceType;
 }
 
-enum ResourceClass Resource::getResourceClass()
+enum ResourceClass Resource::applicationClass() const
 {
     return resourceClass;
 }
 
+bool Resource::hasResource(enum ResourceType resourceType) const
+{
+    if((this->resourceType & resourceType) == resourceType)
+	return true;
+    else
+	return false;
+}
+
+bool Resource::hasExclusiveAccess() const
+{
+    if(resourceState == OwnedState)
+	return true;
+    else
+	return false;
+}
+
+void Resource::handleStateChange(enum ResourceState newState)
+{
+    if(resourceState == UnknownState) {
+	resourceState = newState;
+	emit connectedToServer();
+    }
+    else {
+	resourceState = newState;
+	emit stateChanged(resourceState);
+    }
+}
+
 bool Resource::requestExclusiveAccess()
 {
     return false;
@@ -44,3 +74,4 @@ bool Resource::getExclusiveAccessState()
 {
     return false;
 }
+