diff options
author | Wolf Bergenheim <ext-wolf.2.bergenheim@nokia.com> | 2010-02-02 15:51:41 +0200 |
---|---|---|
committer | Wolf Bergenheim <ext-wolf.2.bergenheim@nokia.com> | 2010-02-02 15:51:41 +0200 |
commit | 8bff62c335842b4c850cc09716e79c2f556247c7 (patch) | |
tree | 281dd5c4a92087f6308e3fb540aba62d7fd272c2 /libresourceqt/src | |
parent | b7d622788b55d30d51ce30bd58634763fddf66fc (diff) |
directory structure changes
Diffstat (limited to 'libresourceqt/src')
-rw-r--r-- | libresourceqt/src/resource-engine.cpp | 197 | ||||
-rw-r--r-- | libresourceqt/src/resource-engine.h | 55 | ||||
-rw-r--r-- | libresourceqt/src/resource-factory.cpp | 31 | ||||
-rw-r--r-- | libresourceqt/src/resource-set.cpp | 111 | ||||
-rw-r--r-- | libresourceqt/src/resource.cpp | 57 | ||||
-rw-r--r-- | libresourceqt/src/resources.cpp | 347 |
6 files changed, 798 insertions, 0 deletions
diff --git a/libresourceqt/src/resource-engine.cpp b/libresourceqt/src/resource-engine.cpp new file mode 100644 index 0000000..cd34c08 --- /dev/null +++ b/libresourceqt/src/resource-engine.cpp @@ -0,0 +1,197 @@ +#include "resource-engine.h" +#include <dbus/dbus.h> +#include <Resource> + +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<Resource> 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<Resource> 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<Resource> 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/libresourceqt/src/resource-engine.h b/libresourceqt/src/resource-engine.h new file mode 100644 index 0000000..9dd5fe5 --- /dev/null +++ b/libresourceqt/src/resource-engine.h @@ -0,0 +1,55 @@ +#ifndef RESOURCE_ENGINE_H +#define RESOURCE_ENGINE_H + +#include <QObject> +#include <QMap> +#include <dbus/dbus.h> +#include <res-conn.h> +#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<Resource> availableResources); + void resourcesAcquired(QList<Resource> 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<quint32, resmsg_type_t> messageMap; +}; +} + +#endif diff --git a/libresourceqt/src/resource-factory.cpp b/libresourceqt/src/resource-factory.cpp new file mode 100644 index 0000000..f500792 --- /dev/null +++ b/libresourceqt/src/resource-factory.cpp @@ -0,0 +1,31 @@ +#include "resource-factory.h" +#include "libplayback-wrapper.h" + +using namespace ResourceTypes; + +ResourceFactory::ResourceFactory(QObject *parent) + : QObject(parent), sessionBusConnection(QDBusConnection::sessionBus()) +{ +} + +ResourceFactory::~ResourceFactory() +{ +} + +Resource * ResourceFactory::createResource(enum ResourceClass applicationClass, + quint16 requestedResources) +{ + qDebug("We %s connected to DBus",sessionBusConnection.isConnected()?"are":"are not"); + Resource *resource = new Resource(applicationClass, requestedResources, this); + ResourceLibrary *libPlayback = new LibPlaybackWrapper(resource); + + bool resourceProperlyInitialized = resource->initialize(libPlayback); + if(resourceProperlyInitialized) { + return resource; + } + else { + qDebug("Failed to initialize Resource. Returning NULL!"); + delete resource; + return NULL; + } +} diff --git a/libresourceqt/src/resource-set.cpp b/libresourceqt/src/resource-set.cpp new file mode 100644 index 0000000..c7862ef --- /dev/null +++ b/libresourceqt/src/resource-set.cpp @@ -0,0 +1,111 @@ +#include "resource-set.h" +using namespace ResourcePolicy; + + +ResourceSet::ResourceSet(const QString &applicationClass, QObject * parent) + : 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[resource->type()] = resource->clone(); +} + +void ResourceSet::addResources(const QList<Resource *>resources) +{ + for(int i=0; i < resources.size(); i++) { + addResource(resources.at(i)); + } +} + +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)) + return true; + else + return false; +} + +bool ResourceSet::contains(const QList<ResourceType> &types) const +{ + bool containsAll=true; + int i=0; + do { + containsAll = contains(types.at(i)); + i++; + } while((i < NumberOfTypes) && containsAll); + return containsAll; +} + +quint32 ResourceSet::id() const +{ + return identifier; +} + +QList<Resource *> ResourceSet::resources() +{ + 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; +} + +void ResourceSet::disconnectFromManager() +{ +} + +bool ResourceSet::isConnectedToManager() +{ + return false; +} + +bool ResourceSet::acquire() +{ + return false; +} + +bool ResourceSet::release() +{ + return false; +} + +bool ResourceSet::update() +{ + return false; +} + diff --git a/libresourceqt/src/resource.cpp b/libresourceqt/src/resource.cpp new file mode 100644 index 0000000..8207b66 --- /dev/null +++ b/libresourceqt/src/resource.cpp @@ -0,0 +1,57 @@ +#include "resource.h" + +using namespace ResourcePolicy; + +Resource::Resource() + : optional(false), shared(false), + identifier(0), granted(false) +{ + identifier = (quint32)this; +} + +Resource::Resource(const Resource &other) + : optional(other.optional), shared(other.shared), + identifier(other.identifier), granted(other.granted) +{ +} + +Resource::~Resource() +{ +} + +bool Resource::isOptional() const +{ + return optional; +} + +void Resource::setOptional(bool resourceIsOptional) +{ + optional = resourceIsOptional; +} + +bool Resource::isShared() const +{ + return shared; +} + +void Resource::setShared(bool shared) +{ + this->shared = shared; +} + +bool Resource::isGranted() const +{ + return granted; +} + +void Resource::setGranted() +{ + granted = true; +} + +void Resource::unsetGranted() +{ + granted = false; +} + + diff --git a/libresourceqt/src/resources.cpp b/libresourceqt/src/resources.cpp new file mode 100644 index 0000000..9858bd3 --- /dev/null +++ b/libresourceqt/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; +} + |