Qt Mobility Reference Documentation

player.cpp Example File

player/player.cpp
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the Qt Mobility Components.
 **
 ** $QT_BEGIN_LICENSE:BSD$
 ** You may use this file under the terms of the BSD license as follows:
 **
 ** "Redistribution and use in source and binary forms, with or without
 ** modification, are permitted provided that the following conditions are
 ** met:
 **   * Redistributions of source code must retain the above copyright
 **     notice, this list of conditions and the following disclaimer.
 **   * Redistributions in binary form must reproduce the above copyright
 **     notice, this list of conditions and the following disclaimer in
 **     the documentation and/or other materials provided with the
 **     distribution.
 **   * Neither the name of Nokia Corporation and its Subsidiary(-ies) nor
 **     the names of its contributors may be used to endorse or promote
 **     products derived from this software without specific prior written
 **     permission.
 **
 ** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 ** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 ** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 ** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 ** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 ** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 ** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 ** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 ** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 ** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 ** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
 ** $QT_END_LICENSE$
 **
 ****************************************************************************/

 #include "player.h"

 #include "playercontrols.h"
 #include "playlistmodel.h"
 #include "videowidget.h"

 #include <qmediaservice.h>
 #include <qmediaplaylist.h>
 #include <qaudioendpointselector.h>

 #include <QtGui>

 #ifdef Q_OS_SYMBIAN
 #include <QtGui/QDialog>
 #include <QtGui/QLineEdit>
 #include <QtGui/QListWidget>
 #include <QtNetwork/QHttp>
 #include <QDomDocument>

 #include "mediakeysobserver.h"
 #endif

 Player::Player(QWidget *parent)
     : QWidget(parent)
     , videoWidget(0)
     , coverLabel(0)
     , slider(0)
     , audioEndpointSelector(0)
 #ifdef Q_OS_SYMBIAN
     , mediaKeysObserver(0)
     , playlistDialog(0)
     , toggleAspectRatio(0)
     , showYoutubeDialog(0)
     , youtubeDialog(0)
 #else
     , colorDialog(0)
 #endif
 {
     player = new QMediaPlayer(this);
     // owned by PlaylistModel
     playlist = new QMediaPlaylist();
     player->setPlaylist(playlist);

     connect(player, SIGNAL(durationChanged(qint64)), SLOT(durationChanged(qint64)));
     connect(player, SIGNAL(positionChanged(qint64)), SLOT(positionChanged(qint64)));
     connect(player, SIGNAL(metaDataChanged()), SLOT(metaDataChanged()));
     connect(playlist, SIGNAL(currentIndexChanged(int)), SLOT(playlistPositionChanged(int)));
     connect(player, SIGNAL(mediaStatusChanged(QMediaPlayer::MediaStatus)),
             this, SLOT(statusChanged(QMediaPlayer::MediaStatus)));
     connect(player, SIGNAL(bufferStatusChanged(int)), this, SLOT(bufferingProgress(int)));
     connect(player, SIGNAL(error(QMediaPlayer::Error)), this, SLOT(displayErrorMessage()));

     videoWidget = new VideoWidget(this);
     player->setVideoOutput(videoWidget);

     playlistModel = new PlaylistModel(this);
     playlistModel->setPlaylist(playlist);

     playlistView = new QListView(this);
     playlistView->setModel(playlistModel);
     playlistView->setCurrentIndex(playlistModel->index(playlist->currentIndex(), 0));

     connect(playlistView, SIGNAL(activated(QModelIndex)), this, SLOT(jump(QModelIndex)));

     slider = new QSlider(Qt::Horizontal, this);
     slider->setRange(0, player->duration() / 1000);

     connect(slider, SIGNAL(sliderMoved(int)), this, SLOT(seek(int)));

     QMediaService *service = player->service();
     if (service) {
         QMediaControl *control = service->requestControl(QAudioEndpointSelector_iid);
         if (control) {
             audioEndpointSelector = qobject_cast<QAudioEndpointSelector*>(control);
             if (audioEndpointSelector) {
                 connect(audioEndpointSelector, SIGNAL(activeEndpointChanged(const QString&)),
                         this, SLOT(handleAudioOutputChangedSignal(const QString&)));
             } else {
                 service->releaseControl(control);
             }
         }
     }

 #ifndef Q_OS_SYMBIAN
     QPushButton *openButton = new QPushButton(tr("Open"), this);

     connect(openButton, SIGNAL(clicked()), this, SLOT(open()));
 #endif

     PlayerControls *controls = new PlayerControls(this);
     controls->setState(player->state());
     controls->setVolume(player->volume());
     controls->setMuted(controls->isMuted());

     connect(controls, SIGNAL(play()), player, SLOT(play()));
     connect(controls, SIGNAL(pause()), player, SLOT(pause()));
     connect(controls, SIGNAL(stop()), player, SLOT(stop()));
     connect(controls, SIGNAL(next()), playlist, SLOT(next()));
     connect(controls, SIGNAL(previous()), this, SLOT(previousClicked()));
     connect(controls, SIGNAL(changeVolume(int)), player, SLOT(setVolume(int)));
     connect(controls, SIGNAL(changeMuting(bool)), player, SLOT(setMuted(bool)));
     connect(controls, SIGNAL(changeRate(qreal)), player, SLOT(setPlaybackRate(qreal)));

     connect(controls, SIGNAL(stop()), videoWidget, SLOT(update()));

     connect(player, SIGNAL(stateChanged(QMediaPlayer::State)),
             controls, SLOT(setState(QMediaPlayer::State)));
     connect(player, SIGNAL(volumeChanged(int)), controls, SLOT(setVolume(int)));
     connect(player, SIGNAL(mutedChanged(bool)), controls, SLOT(setMuted(bool)));

 #ifndef Q_OS_SYMBIAN
     QPushButton *fullScreenButton = new QPushButton(tr("FullScreen"), this);
     fullScreenButton->setCheckable(true);

     if (videoWidget != 0) {
         connect(fullScreenButton, SIGNAL(clicked(bool)), videoWidget, SLOT(setFullScreen(bool)));
         connect(videoWidget, SIGNAL(fullScreenChanged(bool)),
                 fullScreenButton, SLOT(setChecked(bool)));
     } else {
         fullScreenButton->setEnabled(false);
     }

     QPushButton *colorButton = new QPushButton(tr("Color Options..."), this);
     if (videoWidget)
         connect(colorButton, SIGNAL(clicked()), this, SLOT(showColorDialog()));
     else
         colorButton->setEnabled(false);

 #endif

 #ifdef Q_OS_SYMBIAN
     // Set some sensible default volume.
     player->setVolume(50);

     QLabel *label = new QLabel(tr("Playlist"), this);
     QVBoxLayout *playlistDialogLayout = new QVBoxLayout;
     playlistDialogLayout->addWidget(label);
     playlistDialogLayout->addWidget(playlistView);
     playlistDialog = new QDialog(this);
     playlistDialog->setWindowTitle(tr("Playlist"));
     playlistDialog->setLayout(playlistDialogLayout);
     playlistDialog->setContextMenuPolicy(Qt::NoContextMenu);

     QAction *close = new QAction(tr("Close"), this);
     close->setSoftKeyRole(QAction::NegativeSoftKey);
     playlistDialog->addAction(close);

     mediaKeysObserver = new MediaKeysObserver(this);

     coverLabel = new QLabel(this);
     coverLabel->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Minimum);
     coverLabel->setMinimumSize(1, 1);
     coverLabel->hide();

     slider->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Maximum);
     slider->setMinimumSize(1, 1);

     connect(controls, SIGNAL(open()), this, SLOT(open()));
     connect(controls, SIGNAL(fullScreen(bool)), this, SLOT(handleFullScreen(bool)));
     connect(controls, SIGNAL(openPlayList()), this, SLOT(showPlayList()));
     connect(player, SIGNAL(stateChanged(QMediaPlayer::State)), this, SLOT(handleStateChange(QMediaPlayer::State)));
     connect(mediaKeysObserver, SIGNAL(mediaKeyPressed(MediaKeysObserver::MediaKeys)), this, SLOT(handleMediaKeyEvent(MediaKeysObserver::MediaKeys)));
     connect(close, SIGNAL(triggered()), playlistDialog, SLOT(reject()));

     QBoxLayout *layout = new QVBoxLayout;
     layout->setMargin(0);
     layout->addWidget(videoWidget, 7);
     layout->addWidget(coverLabel, 7);
     layout->addWidget(slider, 1);
     layout->addWidget(controls, 2);

     createMenus();
 #else
     QBoxLayout *displayLayout = new QHBoxLayout;
     if (videoWidget)
         displayLayout->addWidget(videoWidget, 2);
     else
         displayLayout->addWidget(coverLabel, 2);
     displayLayout->addWidget(playlistView);

     QBoxLayout *controlLayout = new QHBoxLayout;
     controlLayout->setMargin(0);
     controlLayout->addWidget(openButton);
     controlLayout->addStretch(1);
     controlLayout->addWidget(controls);
     controlLayout->addStretch(1);
     controlLayout->addWidget(fullScreenButton);
     controlLayout->addWidget(colorButton);

     QBoxLayout *layout = new QVBoxLayout;
     layout->addLayout(displayLayout);
     layout->addWidget(slider);
     layout->addLayout(controlLayout);
 #endif

     setLayout(layout);

     metaDataChanged();

     QStringList arguments = qApp->arguments();
     arguments.removeAt(0);
     foreach (QString const &argument, arguments) {
         QFileInfo fileInfo(argument);
         if (fileInfo.exists()) {
             QUrl url = QUrl::fromLocalFile(fileInfo.absoluteFilePath());
             if (fileInfo.suffix().toLower() == QLatin1String("m3u")) {
                 playlist->load(url);
             } else
                 playlist->addMedia(url);
         } else {
             QUrl url(argument);
             if (url.isValid()) {
                 playlist->addMedia(url);
             }
         }
     }
 }

 Player::~Player()
 {
 }

 void Player::open()
 {
 #ifdef Q_WS_MAEMO_5
     QStringList fileNames;
     QString fileName = QFileDialog::getOpenFileName(this, tr("Open Files"), "/");
     if (!fileName.isEmpty())
         fileNames << fileName;
 #else
     QStringList fileNames = QFileDialog::getOpenFileNames(this, tr("Open Files"));
 #endif

     foreach (QString const &fileName, fileNames)
         playlist->addMedia(QUrl::fromLocalFile(fileName));
 }

 void Player::durationChanged(qint64 duration)
 {
     slider->setMaximum(duration / 1000);
 }

 void Player::positionChanged(qint64 progress)
 {
     if (!slider->isSliderDown()) {
         slider->setValue(progress / 1000);
     }
 }

 void Player::metaDataChanged()
 {
 #ifdef Q_OS_SYMBIAN
     if (player->isMetaDataAvailable()) {
         setTrackInfo(QString("(%1/%2) %3 - %4")
                 .arg(playlist->currentIndex()+1)
                 .arg(playlist->mediaCount())
                 .arg(player->metaData(QtMultimediaKit::AlbumArtist).toString())
                 .arg(player->metaData(QtMultimediaKit::Title).toString()));

         if (!player->isVideoAvailable()) {
             QUrl uri = player->metaData(QtMultimediaKit::CoverArtUrlLarge).value<QUrl>();
             QPixmap pixmap = NULL;

             if (uri.isEmpty()) {
                 QVariant picture = player->metaData(QtMultimediaKit::CoverArtImage);
                 // Load picture from metadata
                 if (!picture.isNull() && picture.canConvert<QByteArray>())
                     pixmap.loadFromData(picture.value<QByteArray>());

                 // Load some jpg from same dir as media
                 else {
                     QUrl url = player->media().canonicalUrl();
                     QString path = url.path();
                     path = path.mid(1,path.lastIndexOf("/"));
                     QRegExp rx("*.jpg");
                     rx.setCaseSensitivity(Qt::CaseInsensitive);
                     rx.setPatternSyntax(QRegExp::Wildcard);
                     QDir directory(path);
                     QStringList allFiles = directory.entryList(QDir::Files | QDir::NoSymLinks);

                     foreach (QString file, allFiles)
                         if (rx.exactMatch(file)) {
                             path.append(file);
                             break;
                         }
                    pixmap.load(path);
                 }
                 // Load picture from file pointed by uri
             } else
                 pixmap.load(uri.toString());

             coverLabel->setPixmap((!pixmap.isNull())?pixmap:QPixmap());
             coverLabel->setAlignment(Qt::AlignCenter);
             coverLabel->setScaledContents(true);
             }
     hideOrShowCoverArt();
     }
 #else
     //qDebug() << "update metadata" << player->metaData(QtMultimediaKit::Title).toString();
     if (player->isMetaDataAvailable()) {
         setTrackInfo(QString("%1 - %2")
                 .arg(player->metaData(QtMultimediaKit::AlbumArtist).toString())
                 .arg(player->metaData(QtMultimediaKit::Title).toString()));

         if (coverLabel) {
             QUrl url = player->metaData(QtMultimediaKit::CoverArtUrlLarge).value<QUrl>();

             coverLabel->setPixmap(!url.isEmpty()
                     ? QPixmap(url.toString())
                     : QPixmap());
         }
     }
 #endif
 }

 void Player::previousClicked()
 {
     // Go to previous track if we are within the first 5 seconds of playback
     // Otherwise, seek to the beginning.
     if(player->position() <= 5000)
         playlist->previous();
     else
         player->setPosition(0);
 }

 void Player::jump(const QModelIndex &index)
 {
 #ifdef Q_OS_SYMBIAN
     if (playlistDialog->isVisible())
         playlistDialog->accept();
 #endif
     if (index.isValid()) {
         playlist->setCurrentIndex(index.row());
         player->play();
     }
 }

 void Player::playlistPositionChanged(int currentItem)
 {
     playlistView->setCurrentIndex(playlistModel->index(currentItem, 0));
 }

 void Player::seek(int seconds)
 {
     player->setPosition(seconds * 1000);
 }

 void Player::statusChanged(QMediaPlayer::MediaStatus status)
 {
     handleCursor(status);

     // handle status message
     switch (status) {
     case QMediaPlayer::UnknownMediaStatus:
     case QMediaPlayer::NoMedia:
     case QMediaPlayer::LoadedMedia:
     case QMediaPlayer::BufferingMedia:
     case QMediaPlayer::BufferedMedia:
         setStatusInfo(QString());
         break;
     case QMediaPlayer::LoadingMedia:
         setStatusInfo(tr("Loading..."));
         break;
     case QMediaPlayer::StalledMedia:
         setStatusInfo(tr("Media Stalled"));
         break;
     case QMediaPlayer::EndOfMedia:
         QApplication::alert(this);
         break;
     case QMediaPlayer::InvalidMedia:
         displayErrorMessage();
         break;
     }
 }

 void Player::handleCursor(QMediaPlayer::MediaStatus status)
 {
 #ifndef QT_NO_CURSOR
     if( status == QMediaPlayer::LoadingMedia ||
         status == QMediaPlayer::BufferingMedia ||
         status == QMediaPlayer::StalledMedia)
         setCursor(QCursor(Qt::BusyCursor));
     else
         unsetCursor();
 #endif
 }

 void Player::bufferingProgress(int progress)
 {
     setStatusInfo(tr("Buffering %4%").arg(progress));
 }

 void Player::setTrackInfo(const QString &info)
 {
     trackInfo = info;
 #ifdef Q_OS_SYMBIAN
     QMainWindow *main = qobject_cast<QMainWindow *>(this->parent());
     if (!statusInfo.isEmpty())
         main->setWindowTitle(QString("%1 | %2").arg(trackInfo).arg(statusInfo));
     else
         main->setWindowTitle(trackInfo);
 #else
     if (!statusInfo.isEmpty())
         setWindowTitle(QString("%1 | %2").arg(trackInfo).arg(statusInfo));
     else
         setWindowTitle(trackInfo);
 #endif
 }

 void Player::setStatusInfo(const QString &info)
 {
     statusInfo = info;
 #ifdef Q_OS_SYMBIAN
     QMainWindow *main = qobject_cast<QMainWindow *>(this->parent());
     if (!statusInfo.isEmpty())
         main->setWindowTitle(QString("%1 | %2").arg(trackInfo).arg(statusInfo));
     else
         main->setWindowTitle(trackInfo);
 #else
     if (!statusInfo.isEmpty())
         setWindowTitle(QString("%1 | %2").arg(trackInfo).arg(statusInfo));
     else
         setWindowTitle(trackInfo);
 #endif
 }

 void Player::displayErrorMessage()
 {
 #ifdef Q_OS_SYMBIAN
     if(player->error()!=QMediaPlayer::NoError)
         QMessageBox::critical(NULL, tr("Error"), player->errorString(), QMessageBox::Ok);
 #else
     setStatusInfo(player->errorString());
 #endif

 }

 #ifndef Q_OS_SYMBIAN
 void Player::showColorDialog()
 {
     if (!colorDialog) {
         QSlider *brightnessSlider = new QSlider(Qt::Horizontal);
         brightnessSlider->setRange(-100, 100);
         brightnessSlider->setValue(videoWidget->brightness());
         connect(brightnessSlider, SIGNAL(sliderMoved(int)), videoWidget, SLOT(setBrightness(int)));
         connect(videoWidget, SIGNAL(brightnessChanged(int)), brightnessSlider, SLOT(setValue(int)));

         QSlider *contrastSlider = new QSlider(Qt::Horizontal);
         contrastSlider->setRange(-100, 100);
         contrastSlider->setValue(videoWidget->contrast());
         connect(contrastSlider, SIGNAL(sliderMoved(int)), videoWidget, SLOT(setContrast(int)));
         connect(videoWidget, SIGNAL(contrastChanged(int)), contrastSlider, SLOT(setValue(int)));

         QSlider *hueSlider = new QSlider(Qt::Horizontal);
         hueSlider->setRange(-100, 100);
         hueSlider->setValue(videoWidget->hue());
         connect(hueSlider, SIGNAL(sliderMoved(int)), videoWidget, SLOT(setHue(int)));
         connect(videoWidget, SIGNAL(hueChanged(int)), hueSlider, SLOT(setValue(int)));

         QSlider *saturationSlider = new QSlider(Qt::Horizontal);
         saturationSlider->setRange(-100, 100);
         saturationSlider->setValue(videoWidget->saturation());
         connect(saturationSlider, SIGNAL(sliderMoved(int)), videoWidget, SLOT(setSaturation(int)));
         connect(videoWidget, SIGNAL(saturationChanged(int)), saturationSlider, SLOT(setValue(int)));

         QFormLayout *layout = new QFormLayout;
         layout->addRow(tr("Brightness"), brightnessSlider);
         layout->addRow(tr("Contrast"), contrastSlider);
         layout->addRow(tr("Hue"), hueSlider);
         layout->addRow(tr("Saturation"), saturationSlider);

         colorDialog = new QDialog(this);
         colorDialog->setWindowTitle(tr("Color Options"));
         colorDialog->setLayout(layout);
     }
     colorDialog->show();
 }
 #endif
 #ifdef Q_OS_SYMBIAN
 void Player::createMenus()
 {
     toggleAspectRatio = new QAction(tr("Ignore Aspect Ratio"), this);
     toggleAspectRatio->setCheckable(true);
     qobject_cast<QMainWindow *>(this->parent())->menuBar()->addAction(toggleAspectRatio);
     connect(toggleAspectRatio, SIGNAL(toggled(bool)), this, SLOT(handleAspectRatio(bool)));

     showYoutubeDialog = new QAction(tr("Youtube Search"), this);
     qobject_cast<QMainWindow *>(this->parent())->menuBar()->addAction(showYoutubeDialog);
     connect(showYoutubeDialog, SIGNAL(triggered()), this, SLOT(launchYoutubeDialog()));

     setAudioOutputDefault = new QAction(tr("Default output"), this);
     connect(setAudioOutputDefault, SIGNAL(triggered()), this, SLOT(handleAudioOutputDefault()));

     setAudioOutputAll = new QAction(tr("All outputs"), this);
     connect(setAudioOutputAll, SIGNAL(triggered()), this, SLOT(handleAudioOutputAll()));

     setAudioOutputNone = new QAction(tr("No output"), this);
     connect(setAudioOutputNone, SIGNAL(triggered()), this, SLOT(handleAudioOutputNone()));

     setAudioOutputEarphone = new QAction(tr("Earphone output"), this);
     connect(setAudioOutputEarphone, SIGNAL(triggered()), this, SLOT(handleAudioOutputEarphone()));

     setAudioOutputSpeaker = new QAction(tr("Speaker output"), this);
     connect(setAudioOutputSpeaker, SIGNAL(triggered()), this, SLOT(handleAudioOutputSpeaker()));

     audioOutputMenu = new QMenu(tr("Set Audio Output"), this);
     audioOutputMenu->addAction(setAudioOutputDefault);
     audioOutputMenu->addAction(setAudioOutputAll);
     audioOutputMenu->addAction(setAudioOutputNone);
     audioOutputMenu->addAction(setAudioOutputEarphone);
     audioOutputMenu->addAction(setAudioOutputSpeaker);

     qobject_cast<QMainWindow *>(this->parent())->menuBar()->addMenu(audioOutputMenu);
 }

 void Player::handleFullScreen(bool isFullscreen)
 {
     QMainWindow* mainWindow = qobject_cast<QMainWindow *>(this->parent());
     if(isFullscreen) {
         if(player->state()==QMediaPlayer::StoppedState)
             videoWidget->setFullScreen(false);
         else
             videoWidget->setFullScreen(true);

         qobject_cast<QMainWindow *>(this->parent())->showFullScreen();
     } else
         qobject_cast<QMainWindow *>(this->parent())->showMaximized();
 }

 void Player::handleAspectRatio(bool aspectRatio)
 {
     if(aspectRatio) {
         toggleAspectRatio->setText(tr("Keep Aspect Ratio"));
         videoWidget->setAspectRatioMode(Qt::IgnoreAspectRatio);

     } else {
         toggleAspectRatio->setText(tr("Ignore Aspect Ratio"));
         videoWidget->setAspectRatioMode(Qt::KeepAspectRatio);
     }
 }

 void Player::handleAudioOutputDefault()
 {
     audioEndpointSelector->setActiveEndpoint("Default");
 }

 void Player::handleAudioOutputAll()
 {
     audioEndpointSelector->setActiveEndpoint("All");
 }

 void Player::handleAudioOutputNone()
 {
     audioEndpointSelector->setActiveEndpoint("None");
 }

 void Player::handleAudioOutputEarphone()
 {
     audioEndpointSelector->setActiveEndpoint("Earphone");
 }

 void Player::handleAudioOutputSpeaker()
 {
     audioEndpointSelector->setActiveEndpoint("Speaker");
 }

 void Player::handleAudioOutputChangedSignal(const QString&)
 {
     QMessageBox msgBox;
     msgBox.setText("Output changed: " + audioEndpointSelector->activeEndpoint());
     msgBox.exec();
 }

 void Player::hideOrShowCoverArt()
 {
     if(player->isVideoAvailable()) {
         coverLabel->hide();
         videoWidget->show();
         videoWidget->repaint();
     } else {
         videoWidget->hide();
         QApplication::setActiveWindow(this);
         coverLabel->show();
     }
 }

 void Player::handleStateChange(QMediaPlayer::State state)
 {
     if (state == QMediaPlayer::PausedState)
         return;

     handleFullScreen(qobject_cast<QMainWindow *>(this->parent())->isFullScreen());
 }

 void Player::handleMediaKeyEvent(MediaKeysObserver::MediaKeys key)
 {
     switch (key) {
         case MediaKeysObserver::EVolIncKey:
             player->setVolume(player->volume() + 10);
             break;
         case MediaKeysObserver::EVolDecKey:
             player->setVolume(player->volume() - 10);
             break;
         default:
         break;
     }
 }
 void Player::showPlayList()
 {
     if (!playlistDialog)
         return;

     playlistDialog->exec();
 }

 void Player::launchYoutubeDialog()
 {
     if(!youtubeDialog)  {
         youtubeDialog = new QDialog(this);

         QLineEdit *input= new QLineEdit(youtubeDialog);
         QPushButton *searchButton = new QPushButton("Search", youtubeDialog);
         QListWidget *resultList = new QListWidget(youtubeDialog);
         QAction *add = new QAction(tr("Add"), youtubeDialog);
         QAction *close = new QAction(tr("Close"), youtubeDialog);

         add->setSoftKeyRole(QAction::PositiveSoftKey);
         close->setSoftKeyRole(QAction::NegativeSoftKey);
         youtubeDialog->addAction(add);
         youtubeDialog->addAction(close);

         connect(searchButton, SIGNAL(clicked()), this, SLOT(searchYoutubeVideo()));
         connect(add, SIGNAL(triggered()), this, SLOT(addYoutubeVideo()));
         connect(close, SIGNAL(triggered()), youtubeDialog, SLOT(close()));
         connect(&http, SIGNAL(requestFinished(int, bool)), this, SLOT(youtubeHttpRequestFinished(int, bool)));
         connect(&http, SIGNAL(responseHeaderReceived(const QHttpResponseHeader&)), this, SLOT(youtubeReadResponseHeader(const QHttpResponseHeader&)));

         QHBoxLayout *topLayout = new QHBoxLayout;
         topLayout->addWidget(input);
         topLayout->addWidget(searchButton);

         QVBoxLayout *mainLayout = new QVBoxLayout;
         mainLayout->addLayout(topLayout);
         mainLayout->addWidget(resultList);
         youtubeDialog->setLayout(mainLayout);
     }
     youtubeDialog->showMaximized();
 }

 void Player::youtubeReadResponseHeader(const QHttpResponseHeader& responseHeader)
 {
     switch (responseHeader.statusCode())
     {
         case 200:   // Ok
         case 301:   // Moved Permanently
         case 302:   // Found
         case 303:   // See Other
         case 307:   // Temporary Redirect
             // these are not error conditions
             break;
         default: {
             http.abort();
             QMessageBox::critical(NULL, tr("Error"), tr("Download failed: %1.").arg(responseHeader.reasonPhrase()));
             break;
         }
     }
 }

 void Player::addYoutubeVideo()
 {
     if(!youtubeDialog)
         return;

     QListWidget *resultList = youtubeDialog->findChild<QListWidget *>();
     if(!resultList || resultList->count() == 0)
         return;

     playlist->addMedia(resultList->currentItem()->data(Qt::UserRole).toUrl());
 }

 void Player::searchYoutubeVideo()
 {
     if(!youtubeDialog)
         return;

     QLineEdit *input = youtubeDialog->findChild<QLineEdit *>();
     QListWidget *resultList = youtubeDialog->findChild<QListWidget *>();
     QString urlstring = QString("http://gdata.youtube.com/feeds/api/videos?q=%1&max-results=25&v=2&format=6").arg(input->text().replace(' ', '+'));
     QUrl url(urlstring);
     http.setHost(url.host(), QHttp::ConnectionModeHttp, url.port() == -1 ? 0 : url.port());
     resultList->clear();
     httpGetId = http.get(urlstring);
 }

 void Player::youtubeHttpRequestFinished(int requestId, bool error)
 {
     if(!youtubeDialog || requestId != httpGetId)
         return;

     if (error) {
         QMessageBox::critical(NULL, tr("Error"), tr("Download failed: %1.").arg(http.errorString()));
         return;
     }

     QTemporaryFile file;
     if (!file.open()) {
         QMessageBox::critical(NULL, tr("Error"), tr("Could not open temporary file"));
         return;
     }

     QString data = http.readAll();
     QTextStream out(&file);
     out << data;
     file.close();

     QDomDocument domDocument;
     QString errorMessage;
     if (!domDocument.setContent(&file, true, &errorMessage)) {
         QMessageBox::critical(NULL, tr("Error"), errorMessage);
         return;
     }

     QDomElement root = domDocument.documentElement();
     if (root.tagName() != "feed")
         return;

     QListWidget *resultList = youtubeDialog->findChild<QListWidget *>();
     QDomElement entryElement = root.firstChildElement("entry");
     while(!entryElement.isNull())
     {
         QString title = entryElement.firstChildElement("title").text();
         QDomElement groupElement = entryElement.firstChildElement("group");
         QDomElement incidentElement2 = groupElement.firstChildElement("content");
         while(!incidentElement2.isNull())
         {
             // "6" = MPEG-4 SP video (up to 176x144) and AAC audio.
             if (incidentElement2.attribute("format") == "6") {
                 QListWidgetItem* item = new QListWidgetItem(title, resultList);
                 item->setData(Qt::UserRole, incidentElement2.attribute("url"));
                 break;
             }
             incidentElement2 = incidentElement2.nextSiblingElement("content");
         }
         entryElement = entryElement.nextSiblingElement("entry");
     }
 }
 #endif


Copyright © 2009-2010 Nokia Corporation and/or its subsidiary(-ies) Trademarks
Qt Mobility Project 1.1.0