From 651c76249a7b63e0b4eeed3363607e7deb2e193a Mon Sep 17 00:00:00 2001 From: Wolf Bergenheim Date: Mon, 1 Feb 2010 10:24:13 +0200 Subject: Added ResourceEngine and fixed ResourceSet to work --- include/resources.h | 169 +++++++++++++++++++++ libresourceqt.pro | 3 +- src/resource-engine.cpp | 197 +++++++++++++++++++++++++ src/resource-engine.h | 55 +++++++ src/resource-set.cpp | 8 + src/resources.cpp | 347 ++++++++++++++++++++++++++++++++++++++++++++ tests/test-resource-set.pro | 4 +- 7 files changed, 779 insertions(+), 4 deletions(-) create mode 100644 include/resources.h create mode 100644 src/resource-engine.cpp create mode 100644 src/resource-engine.h create mode 100644 src/resources.cpp diff --git a/include/resources.h b/include/resources.h new file mode 100644 index 0000000..8e3da70 --- /dev/null +++ b/include/resources.h @@ -0,0 +1,169 @@ +#ifndef RESOURCES_H +#define RESOURCES_H + +#include "resource.h" +#include +#include + +namespace ResourcePolicy { + + class AudioResource: public Resource + { + public: + AudioResource(const QString &audioGroup=QString()); + AudioResource(const AudioResource &other); + virtual ~AudioResource(); + + QString audioGroup() const; + void setAudioGroup(const QString & newGroup); + + quint32 processID() const; + void setProcessID(quint32 newPID); + + QString streamTag() const; + void setStreamTag(const QString & newStreamTag); + + virtual ResourceType type() const; + virtual Resource * clone() const; + private: + QString group; + quint32 pid; + QString stream; + }; + + class AudioRecorderResource: public Resource + { + public: + AudioRecorderResource(const QString & audioGroup=QString()); + AudioRecorderResource(const AudioRecorderResource &other); + virtual ~AudioRecorderResource(); + + QString audioGroup() const; + void setAudioGroup(const QString & newGroup); + + quint32 processID() const; + void setProcessID(quint32 newPID); + + QString streamTag() const; + void setStreamTag(const QString & newStreamTag); + + virtual ResourceType type() const; + virtual Resource * clone() const; + private: + QString group; + quint32 pid; + QString stream; + }; + + class BacklightResource: public Resource + { + public: + BacklightResource(); + BacklightResource(const BacklightResource &other); + virtual ~BacklightResource(); + + virtual ResourceType type() const; + virtual Resource * clone() const; + }; + + class LedsResource: public Resource + { + public: + LedsResource(); + LedsResource(const LedsResource &other); + virtual ~LedsResource(); + + virtual ResourceType type() const; + virtual Resource * clone() const; + }; + + class VibraResource: public Resource + { + public: + VibraResource(); + VibraResource(const VibraResource &other); + virtual ~VibraResource(); + + virtual ResourceType type() const; + virtual Resource * clone() const; + }; + + class VideoRecorderResource: public Resource + { + public: + VideoRecorderResource(); + VideoRecorderResource(const VideoRecorderResource &other); + virtual ~VideoRecorderResource(); + + virtual ResourceType type() const; + virtual Resource * clone() const; + }; + + class VideoResource: public Resource + { + public: + VideoResource(); + VideoResource(const VideoResource &other); + virtual ~VideoResource(); + + virtual ResourceType type() const; + virtual Resource * clone() const; + }; + + class SystemButtonResource: public Resource + { + public: + SystemButtonResource(); + SystemButtonResource(const SystemButtonResource &other); + virtual ~SystemButtonResource(); + + virtual ResourceType type() const; + virtual Resource * clone() const; + }; + + class LockButtonResource: public Resource + { + public: + LockButtonResource(); + LockButtonResource(const LockButtonResource &other); + virtual ~LockButtonResource(); + + virtual ResourceType type() const; + virtual Resource * clone() const; + }; + + class ScaleButtonResource: public Resource + { + public: + ScaleButtonResource(); + ScaleButtonResource(const ScaleButtonResource &other); + virtual ~ScaleButtonResource(); + + virtual ResourceType type() const; + virtual Resource * clone() const; + }; + + class SnapButtonResource: public Resource + { + public: + SnapButtonResource(); + SnapButtonResource(const SnapButtonResource &other); + virtual ~SnapButtonResource(); + + virtual ResourceType type() const; + virtual Resource * clone() const; + }; + + class LensCoverResource: public Resource + { + public: + LensCoverResource(); + LensCoverResource(const LensCoverResource &other); + virtual ~LensCoverResource(); + + virtual ResourceType type() const; + virtual Resource * clone() const; + }; +} +#endif + diff --git a/libresourceqt.pro b/libresourceqt.pro index e76299d..bf4f4dc 100644 --- a/libresourceqt.pro +++ b/libresourceqt.pro @@ -8,11 +8,10 @@ INCLUDEPATH += src include ../libresource/src # Input PUBLIC_HEADERS = include/resource.h include/resource-set.h include/resources.h -HEADERS += $$PUBLIC_HEADERS src/resource-engine.h +HEADERS += $$PUBLIC_HEADERS SOURCES += src/resource.cpp \ src/resource-set.cpp \ - src/resource-engine.cpp \ src/resources.cpp OBJECTS_DIR = build diff --git a/src/resource-engine.cpp b/src/resource-engine.cpp new file mode 100644 index 0000000..cd34c08 --- /dev/null +++ b/src/resource-engine.cpp @@ -0,0 +1,197 @@ +#include "resource-engine.h" +#include +#include + +using namespace ResourcePolicy; + +static void connectionIsUp(resconn_t *connection); +static inline quint32 allResourcesToBitmask(const ResourceSet *resourceSet); +static inline quint32 optionalResourcesToBitmask(const ResourceSet *resourceSet); +static inline quint32 sharedResourcesToBitmask(const ResourceSet *resourceSet); + +ResourceEngine::ResourceEngine(ResourceSet *resourceSet) + : QObject(resourceSet), resourceSet(resourceSet), requestId(0) +{ + identifier = (quint32)this; +} + +ResourceEngine::~ResourceEngine() +{ +} + +bool ResourceEngine::initialize() +{ + DBusError dbusError; + DBusConnection *dbusConnection; + + dbus_error_init(&dbusError); + dbusConnection = dbus_bus_get(DBUS_BUS_SYSTEM, &dbusError); + if(dbus_error_is_set(&dbusError)) { + qDebug("Error while connection to the system bus: %s", dbusError.message); + dbus_error_free(&dbusError); + return false; + } + dbus_error_free(&dbusError); + libresourceConnection = resproto_init(RESPROTO_ROLE_CLIENT, RESPROTO_TRANSPORT_DBUS, + connectionIsUp, dbusConnection); + if(libresourceConnection == NULL) { + return NULL; + } + +/* resproto_set_handler(libresourceConnection, RESMSG_UNREGISTER, handleUnregisterMessage); + resproto_set_handler(libresourceConnection, RESMSG_GRANT, handleGrantMessage); + resproto_set_handler(libresourceConnection, RESMSG_ADVICE, handleAdviceMessage);*/ + return true; +} + +bool ResourceEngine::connect() +{ + resmsg_t resourceMessage; + resourceMessage.record.type = RESMSG_REGISTER; + resourceMessage.record.id = identifier; + resourceMessage.record.reqno = ++reqestId; + + requestMap.insert(requestId, RESMSG_REGISTER); + + uint32_t allResources, optionalResources, sharedResources; + allResources = allResourcesToBitmask(resourceSet); + allResources = optionalResourcesToBitmask(resourceSet); + allResources = 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 + + resourceMessage.record.klass = resourceSet->applicationClass(); + resourceMessage.record.mode = 0; //No auto release + + libresourceSet = resconn_connect(libresourceConnection, &resourceMessage, handleConnect); + + libresourceSet->userdata = this; //save our context + index = REQHASH_INDEX(reqno); + reqtyp[index] = RESMSG_REGISTER; + return true; +} + +static inline quint32 allResourcesToBitmask(const ResourceSet *resourceSet) +{ + QList resourceList = resourceSet->resources(); + quint32 bitmask=0; + for(int i=0; i < resourceList.size(); i++) { + switch(resourceList[i].type()) { + case AudioPlaybackResource: + bitmask += RESMSG_AUDIO_PLAYBACK; + break; + case VideoPlaybackResource: + bitmask += RESMSG_VIDEO_PLAYBACK; + break; + case AudioRecorderResource: + bitmask += RESMSG_AUDIO_RECORDING; + break; + case VideoRecorderResource: + bitmask += RESMSG_VIDEO_RECORDING; + break; + case VibraResource: + bitmask += RESMSG_VIBRA; + break; + case + default: + break; + } + } + return bitmask; +} + +static inline quint32 optionalResourcesToBitmask(const ResourceSet *resourceSet) +{ + QList resourceList = resourceSet->resources(); + quint32 bitmask=0; + for(int i=0; i < resourceList.size(); i++) { + if(resourceList[i].isOptional()) { + switch(resourceList[i].type()) { + case AudioPlaybackResource: + bitmask += RESMSG_AUDIO_PLAYBACK; + break; + case VideoPlaybackResource: + bitmask += RESMSG_VIDEO_PLAYBACK; + break; + case AudioRecorderResource: + bitmask += RESMSG_AUDIO_RECORDING; + break; + case VideoRecorderResource: + bitmask += RESMSG_VIDEO_RECORDING; + break; + default: + break; + } + } + } + return bitmask; +} + +static inline quint32 sharedResourcesToBitmask(const ResourceSet *resourceSet) +{ + QList resourceList = resourceSet->resources(); + quint32 bitmask=0; + for(int i=0; i < resourceList.size(); i++) { + if(resourceList[i].isShared()) { + switch(resourceList[i].type()) { + case AudioPlaybackResource: + bitmask += RESMSG_AUDIO_PLAYBACK; + break; + case VideoPlaybackResource: + bitmask += RESMSG_VIDEO_PLAYBACK; + break; + case AudioRecorderResource: + bitmask += RESMSG_AUDIO_RECORDING; + break; + case VideoRecorderResource: + bitmask += RESMSG_VIDEO_RECORDING; + break; + default: + break; + } + } + } + return bitmask; +} + +bool ResourceEngine::isConnected() +{ + return false; +} + +bool ResourceEngine::acquireResources() +{ + return false; +} + +bool ResourceEngine::releaseResources() +{ + return false; +} + +bool ResourceEngine::updateResources() +{ + return false; +} + +bool ResourceEngine::registerAudioProperties(quint32 pid, QString streamName) +{ + return false; +} + +static void connectionIsUp(resconn_t *connection) +{ + ResourceEngine *resourceEngine; + + resourceEngine = (ResourceEngine *)(connection->dbus.rsets->userdata); + + resourceEngine->handleConnectionIsUp(); +} + +void ResourceEngine::handleConnectionIsUp() +{ + emit connectedToManager(); +} diff --git a/src/resource-engine.h b/src/resource-engine.h new file mode 100644 index 0000000..9dd5fe5 --- /dev/null +++ b/src/resource-engine.h @@ -0,0 +1,55 @@ +#ifndef RESOURCE_ENGINE_H +#define RESOURCE_ENGINE_H + +#include +#include +#include +#include +#include "resource-set.h" + +namespace ResourcePolicy { + +class ResourceEngineData; + +class ResourceEngine: public QObject +{ + Q_OBJECT + Q_DISABLE_COPY( ResourceEngine ) +public: + ResourceEngine(ResourceSet *resourceSet=NULL); + ~ResourceEngine(); + + bool initialize(); + + bool connect(); + bool disconnect(); + bool isConnected(); + + bool acquireResources(); + bool releaseResources(); + bool updateResources(); + + bool registerAudioProperties(quint32 pid, QString streamName); + + void handleConnectionIsUp(); + +signals: + void resourcesBecameAvailable(QList availableResources); + void resourcesAcquired(QList grantedResources); + void resourcesDenied(); + void lostResources(); + void connectedToManager(); + void disconnectedFromManager(); + +private: + bool connected; + ResourceSet *resourceSet; + DBusConnection *dbusConnection; + resconn_t *libresourceConnection; + resset_t *libresourceSet; + quint32 requestId; + QMap messageMap; +}; +} + +#endif diff --git a/src/resource-set.cpp b/src/resource-set.cpp index 73a4bc4..c7862ef 100644 --- a/src/resource-set.cpp +++ b/src/resource-set.cpp @@ -28,6 +28,14 @@ void ResourceSet::addResources(const QListresources) } } +void ResourceSet::delResource(ResourceType type) +{ + if(contains(type)) { + delete resourceSet[type]; + resourceSet[type] = NULL; + } +} + bool ResourceSet::contains(ResourceType type) const { if((type < NumberOfTypes) && (resourceSet[type] != NULL)) diff --git a/src/resources.cpp b/src/resources.cpp new file mode 100644 index 0000000..9858bd3 --- /dev/null +++ b/src/resources.cpp @@ -0,0 +1,347 @@ +#include "resources.h" + +using namespace ResourcePolicy; + +AudioResource::AudioResource(const QString &audioGroup) + : Resource(), group(audioGroup), pid(0), stream(QString()) +{ +} + +AudioResource::AudioResource(const AudioResource &other) + : Resource(other), group(other.group), pid(other.pid), stream(other.stream) +{ +} + +Resource * AudioResource::clone() const +{ + return new AudioResource(*this); +} + +AudioResource::~AudioResource() +{ +} + +QString AudioResource::audioGroup() const +{ + return group; +} + +void AudioResource::setAudioGroup(const QString &newGroup) +{ + group = newGroup; +} + +quint32 AudioResource::processID() const +{ + return pid; +} + +void AudioResource::setProcessID(quint32 newPID) +{ + pid = newPID; +} + +QString AudioResource::streamTag() const +{ + return stream; +} + +void AudioResource::setStreamTag(const QString & newStreamTag) +{ + stream = newStreamTag; +} + +ResourceType AudioResource::type() const +{ + return AudioPlaybackType; +} + +AudioRecorderResource::AudioRecorderResource(const QString & audioGroup) + : Resource(), group(audioGroup), pid(0), stream(QString()) +{ +} + +AudioRecorderResource::AudioRecorderResource(const AudioRecorderResource &other) + : Resource(other), group(other.group), pid(other.pid), stream(other.stream) +{ +} + +Resource * AudioRecorderResource::clone() const +{ + return new AudioRecorderResource(*this); +} + +AudioRecorderResource::~AudioRecorderResource() +{ +} + +void AudioRecorderResource::setAudioGroup(const QString & newGroup) +{ + group = newGroup; +} + +quint32 AudioRecorderResource::processID() const +{ + return pid; +} + +void AudioRecorderResource::setProcessID(quint32 newPID) +{ + pid = newPID; +} + +QString AudioRecorderResource::streamTag() const +{ + return stream; +} + +void AudioRecorderResource::setStreamTag(const QString & newStreamTag) +{ + stream = newStreamTag; +} + +ResourceType AudioRecorderResource::type() const +{ + return AudioRecorderType; +} + +VideoResource::VideoResource() + : Resource() +{ +} + +VideoResource::VideoResource(const VideoResource &other) + : Resource(other) +{ +} + +Resource * VideoResource::clone() const +{ + return new VideoResource(*this); +} + +VideoResource::~VideoResource() +{ +} + +ResourceType VideoResource::type() const +{ + return VideoPlaybackType; +} + +VideoRecorderResource::VideoRecorderResource() + : Resource() +{ +} + +VideoRecorderResource::VideoRecorderResource(const VideoRecorderResource &other) + : Resource(other) +{ +} + +Resource * VideoRecorderResource::clone() const +{ + return new VideoRecorderResource(*this); +} + +VideoRecorderResource::~VideoRecorderResource() +{ +} + +ResourceType VideoRecorderResource::type() const +{ + return VideoRecorderType; +} + +VibraResource::VibraResource() + : Resource() +{ +} + +VibraResource::VibraResource(const VibraResource &other) + : Resource(other) +{ +} + +Resource * VibraResource::clone() const +{ + return new VibraResource(*this); +} + +VibraResource::~VibraResource() +{ +} + +ResourceType VibraResource::type() const +{ + return VibraType; +} + +LedsResource::LedsResource() + : Resource() +{ +} + +LedsResource::LedsResource(const LedsResource &other) + : Resource(other) +{ +} + +Resource * LedsResource::clone() const +{ + return new LedsResource(*this); +} + +LedsResource::~LedsResource() +{ +} + +ResourceType LedsResource::type() const +{ + return LedsType; +} + +BacklightResource::BacklightResource() + : Resource() +{ +} + +BacklightResource::BacklightResource(const BacklightResource &other) + : Resource(other) +{ +} + +Resource * BacklightResource::clone() const +{ + return new BacklightResource(*this); +} + +BacklightResource::~BacklightResource() +{ +} + +ResourceType BacklightResource::type() const +{ + return BacklightType; +} + +SystemButtonResource::SystemButtonResource() + : Resource() +{ +} + +SystemButtonResource::SystemButtonResource(const SystemButtonResource &other) + : Resource(other) +{ +} + +Resource * SystemButtonResource::clone() const +{ + return new SystemButtonResource(*this); +} + +SystemButtonResource::~SystemButtonResource() +{ +} + +ResourceType SystemButtonResource::type() const +{ + return SystemButtonType; +} + +LockButtonResource::LockButtonResource() + : Resource() +{ +} + +LockButtonResource::LockButtonResource(const LockButtonResource &other) + : Resource(other) +{ +} + +Resource * LockButtonResource::clone() const +{ + return new LockButtonResource(*this); +} + +LockButtonResource::~LockButtonResource() +{ +} + +ResourceType LockButtonResource::type() const +{ + return LockButtonType; +} + +ScaleButtonResource::ScaleButtonResource() + : Resource() +{ +} + +ScaleButtonResource::ScaleButtonResource(const ScaleButtonResource &other) + : Resource(other) +{ +} + +Resource * ScaleButtonResource::clone() const +{ + return new ScaleButtonResource(*this); +} + +ScaleButtonResource::~ScaleButtonResource() +{ +} + +ResourceType ScaleButtonResource::type() const +{ + return ScaleButtonType; +} + +SnapButtonResource::SnapButtonResource() + : Resource() +{ +} + +SnapButtonResource::SnapButtonResource(const SnapButtonResource &other) + : Resource(other) +{ +} + +Resource * SnapButtonResource::clone() const +{ + return new SnapButtonResource(*this); +} + +SnapButtonResource::~SnapButtonResource() +{ +} + +ResourceType SnapButtonResource::type() const +{ + return SnapButtonType; +} + +LensCoverResource::LensCoverResource() + : Resource() +{ +} + +LensCoverResource::LensCoverResource(const LensCoverResource &other) + : Resource(other) +{ +} + +Resource * LensCoverResource::clone() const +{ + return new LensCoverResource(*this); +} + +LensCoverResource::~LensCoverResource() +{ +} + +ResourceType LensCoverResource::type() const +{ + return LensCoverType; +} + diff --git a/tests/test-resource-set.pro b/tests/test-resource-set.pro index e9e24ee..ad6d90d 100644 --- a/tests/test-resource-set.pro +++ b/tests/test-resource-set.pro @@ -6,8 +6,8 @@ DEPENDPATH += $${BASE}/include $${BASE}/src . INCLUDEPATH += $${BASE}/src $${BASE}/include # Input -HEADERS += $${BASE}/include/resource.h $${BASE}/include/resource-set.h test-resource-set.h -SOURCES += $${BASE}/src/resource.cpp $${BASE}/src/resource-set.cpp test-resource-set.cpp +HEADERS += $${BASE}/include/resources.h $${BASE}/include/resource-set.h test-resource-set.h +SOURCES += $${BASE}/src/resource.cpp $${BASE}/src/resources.cpp $${BASE}/src/resource-set.cpp test-resource-set.cpp OBJECTS_DIR = build MOC_DIR = build -- cgit v1.2.3