From b026f0ad41985234416fa9ca1a2d054e8825961d Mon Sep 17 00:00:00 2001 From: Vsevolod Buzinov Date: Mon, 21 Jun 2010 17:23:09 +0300 Subject: Added initial version of the demo player Updated documentation for the demo Added video resource acquisition --- demo/player/playerwidget.cpp | 244 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 244 insertions(+) create mode 100644 demo/player/playerwidget.cpp (limited to 'demo/player/playerwidget.cpp') diff --git a/demo/player/playerwidget.cpp b/demo/player/playerwidget.cpp new file mode 100644 index 0000000..8d65b3b --- /dev/null +++ b/demo/player/playerwidget.cpp @@ -0,0 +1,244 @@ +#include "playerwidget.h" + +using namespace ResourcePolicy; + +/** + * Creates a resource set in the "player" application class, this application class + * best suites our application description. The application class is used to determine the priority + * order of the application. + * We create one AudioResource object and add it to the set. For that audio resource we + * have to set the pid of the audio renderer, which in our case is the same as the pid of the application, + * and stream tag, which we simply set to an all-allowing "*". + * + * Also, we connect to three signals: + * - resourcesGranted, which is triggered whenever the resource we asked for is granted to us; + * - lostResources, which is triggered whenever another application has been granted with our resource + * and we are no longer able to use it; + * - resourcesReleased, which is triggered whenever a call to release() is done and the resource + * has been successfully released. + * + * At last, we add a timer which fires every 100 milliseconds in order to update the current playback position. + * This is done because MVideoWidget currently only updates said position for video files, and not for audio. + * It might not be as precise, but will serve our needs for the demo. + * + * \see PlayerWidget::resourceAcquiredHandler + * \see PlayerWidget::resourceLostHandler + * \see PlayerWidget::resourceReleasedHandler + */ +PlayerWidget::PlayerWidget(QGraphicsItem *parent) + : MVideoWidget(parent) { + + qDebug("PlayerWidget::PlayerWidget"); + resourceSet = new ResourceSet("player", this); + resourceSet->setAlwaysReply(); + + audioResource = new ResourcePolicy::AudioResource(); + audioResource->setProcessID(QCoreApplication::applicationPid()); + audioResource->setStreamTag("media.name", "*"); + resourceSet->addResourceObject(audioResource); + + connect(resourceSet, SIGNAL(resourcesGranted(const QList&)), + this, SLOT(resourceAcquiredHandler(const QList&))); + connect(resourceSet, SIGNAL(lostResources()), this, SLOT(resourceLostHandler())); + connect(resourceSet, SIGNAL(resourcesReleased()), this, SLOT(resourceReleasedHandler())); + + // playback timer + startTimer(100); +} + +/** + * Calls acquire() on the resource set. Shortly after we should receive a notification + * when resources are granted, which means we can begin using audio output. + * + * \see PlayerWidget::resourceAcquiredHandler + * + */ +void PlayerWidget::acquire() { + if (filetype == VIDEO) { + resourceSet->addResource(ResourcePolicy::VideoPlaybackType); + } else { + resourceSet->deleteResource(ResourcePolicy::VideoPlaybackType); + } + + resourceSet->acquire(); +} + +/** + * Calls release() on the resource set. Called whenever we are not using the resource. + * We can acquire the same resource set again if required. We release resource every time + * a pause button is pressed or audio playback is finished, so that other applications can + * make use of it. + * Call to release() yields resourceReleased() signal shortly after to inform us that resource + * has indeed been released. + * + * \see PlayerWidget::resourceReleasedHandler + * + */ +void PlayerWidget::release() { + resourceSet->release(); +} + +/** + * Overrides parent play() method to add wrapping with resource policy handling. + * If we are in resource policy aware mode, asks to acquire the resource, + * otherwise begins playback immediately. + * + * \see MVideoWidget::play(). + */ +void PlayerWidget::play() { + qDebug("PlayerWidget::play()"); + if (policyAware()) + acquire(); + else + beginPlayback(); +} + +/** + * Calls parent play() method to begin playback and emits the playing() signal. + * This function is used in place of play(), which only prepares the playback + * prior to actually starting it. + * + */ +void PlayerWidget::beginPlayback() { + MVideoWidget::play(); + emit playing(); +} + + +/** + * Overrides parent pause() method. Releases the audio resource on pause so + * that another application can start using it immediately. Emits paused() signal. + * An optional parameter releaseResources is added to opt out of releasing the + * resource in PlayerWidget::resourceLostHandler() handler. + * + * \see MVideoWidget::pause(). + */ +void PlayerWidget::pause(bool releaseResources) { + MVideoWidget::pause(); + if (releaseResources && policyAware()) release(); + emit paused(); +} + +/** + * The most interesting kind of event in resource policy. This event + * arrives to notify us that the resources we asked for are available for us to use. + * Note that not all resources of the resource set might be granted, but we have + * only one resource in total (audio). If the granted resources list is not empty, + * we begin the playback. + * + * \see signal ResourcePolicy::ResourceSet::resourcesGranted(). + */ +void PlayerWidget::resourceAcquiredHandler(const QList& grantedResList) { + + qDebug("PlayerWidget::resourceAcquiredHandler()"); + QList list = resourceSet->resources(); + if (list.empty()) { + qDebug("Granted resource set is empty"); + } + else { + for (int i = 0; i < list.count(); i++) { + qDebug("Granted resource %d", (int)list[i]); + } + if (filetype == AUDIO || (filetype == VIDEO && grantedResList.size() > 1)) + beginPlayback(); + } +} + +/** + * This notification arrives to acknowledge that we no longer own the resources from + * our resource set. The handler is a no-op in our case. + * + * \see signal ResourcePolicy::ResourceSet::resourcesReleased(). + */ +void PlayerWidget::resourceReleasedHandler() { + qDebug("PlayerWidget::resourceReleasedHandler()"); +} + +/** + * Handles the event of a resource being taken by another application. + * Our application is forced to stop using audio resource by muting the sound output. + * We will pause the audio, but will not release the resource yet, + * so that we receive the acquire notification as soon as the audio resource + * is available again. + * + * \see signal ResourcePolicy::ResourceSet::lostResources(). + */ +void PlayerWidget::resourceLostHandler() { + qDebug("PlayerWidget::resourceLostHandler()"); + if (state() == MVideo::Playing) { + pause(false); + } +} + +/** + * Timer event is used to update current playback position, since MVideoWidget updates it + * only for video files and not audio files. Our own instance variable, d.pos, is used. + * It also handles the Stopped state, in which case paused() signal will be issued. + * Every time we emit playerPositionChanged() for the subscribed widget to do its own + * processing as well. + * + */ +void PlayerWidget::timerEvent(QTimerEvent */*event*/) { + // MVideoWidget doesn't update position on audio files, so we'll keep our own count + // /* position = videoWidget->position(); */ + + if (state() == MVideo::Playing) { + d.pos += 100; + } + + if (state() == MVideo::Stopped) { + d.pos = 0; + pause(); + } + + emit playerPositionChanged(); +} + +/** + * Getter for policyAware property, which can be set to true to make the demo behave + * like policy-aware and to false for otherwise. + */ +bool PlayerWidget::policyAware() { + return d.policyAware; +} + +/** + * Setter for policyAware property, which can be set to true to make the demo behave + * like policy-aware and to false for otherwise. + */ +void PlayerWidget::setPolicyAware(bool aware) { + d.policyAware = aware; + + if (policyAware()) { + if (state() == MVideo::Playing) acquire(); + } else { + release(); + } +} + +/** + * Getter for position property, our own current playback position counter. Note that + * this overrides parent method, but we could call it with full qualification if needed. + */ +quint64 PlayerWidget::position() { + return d.pos; +} + +/** + * Setter for position property, our own current playback position counter. Note that + * this overrides parent method, but we could call it with full qualification if needed. + */ +void PlayerWidget::setPosition(quint64 pos) { + d.pos = pos; +} + +/** + * Overrides parent seek() method, which prior to seek() also updates our own playback position + * counter. + * + * \see PlayerWidget::position() + */ +void PlayerWidget::seek(quint64 pos) { + setPosition(pos); + MVideoWidget::seek(pos); +} -- cgit v1.2.3