--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/mpengine/src/mpengine.cpp Tue Aug 31 15:12:29 2010 +0300
@@ -0,0 +1,1193 @@
+/*
+* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description: Wrapper for mpx framework utilities.
+*
+*/
+
+#include <xqsharablefile.h>
+#include <EqualizerConstants.h>
+
+#include "mpengine.h"
+#include "mpmpxharvesterframeworkwrapper.h"
+#include "mpmpxcollectionframeworkwrapper.h"
+#include "mpmpxplaybackframeworkwrapper.h"
+#include "mpaudioeffectsframeworkwrapper.h"
+#include "mpequalizerframeworkwrapper.h"
+#include "mptrace.h"
+#include "mpsettingsmanager.h"
+#include "mpsongscanner.h"
+#include "mpsongdata.h"
+
+/*!
+ \class MpEngine
+ \brief Engine for musicplayer - mpx framework utilities.
+
+ MP Engine provides Qt style interface to the MPX framework
+ utilities. Its implementation is hidden using private class data pattern.
+*/
+
+/*!
+-------------------------------------------------------------------------------
+ Harvesting related signals
+-------------------------------------------------------------------------------
+*/
+
+/*!
+ \fn void libraryAboutToUpdate()
+
+ This signal is emitted when a scan operation has been requested or
+ when MTP synchronization starts.
+
+ */
+
+/*!
+ \fn void libraryUpdated()
+
+ This signal is emitted when library has changed.
+
+ \sa handleScanEnded()
+ \sa handleDiskEvent()
+ \sa handleUsbMtpEndEvent()
+
+ */
+
+/*!
+ \fn void usbBlocked( bool blocked )
+
+ This signal is emitted to update the usb blocking state
+ due a previous usb event received.
+
+ \sa handleUsbEvent()
+
+ */
+
+/*!
+ \fn void unableToCotinueDueUSB()
+
+ This signal is emitted if usb blocking verification returns true.
+
+ \sa verifyUsbBlocking()
+
+ */
+
+/*!
+ \fn void usbSynchronizationStarted()
+
+ This signal is emitted when usb is connected in MassStorage mode or MTP mode and synchronizing.
+
+ */
+
+/*!
+ \fn void usbSynchronizationFinished()
+
+ This signal is emitted when usb in synchronizing state is disconnected.
+
+ */
+
+
+/*!
+-------------------------------------------------------------------------------
+ Collection related signals
+-------------------------------------------------------------------------------
+*/
+
+/*!
+ \fn void collectionPlaylistOpened()
+
+ This signal is emitted when A new collection playlist is opened and
+ playback is initialized.
+
+ */
+
+/*!
+ \fn void playlistSaved( bool success )
+
+ This signal is emitted when playlist save operation is completed, it
+ indicates the operation \a success .
+
+ */
+
+/*!
+ \fn void aboutToAddSongs( int count )
+
+ Signal emitted up on a notification from MPX Collection wrapper,
+ when play list is prepared and about to be added.
+ \a count Indicates number of songs to be added.
+
+ */
+
+/*!
+ \fn void deleteStarted(TCollectionContext context, int Count)
+
+ This signal is emitted when song delete operation has started.
+ \a context The context where delete operation is taking place.
+ \a Count Number of items to delete.
+
+ */
+
+/*!
+ \fn void songsDeleted( bool success )
+
+ This signal is emitted when song delete operation is completed, it
+ indicates the operation \a success .
+
+ */
+
+/*!
+ \fn void playlistsRenamed( bool success )
+
+ This signal is emitted when playlist rename operation is completed, it
+ indicates the operation \a success .
+
+ */
+
+/*!
+ \fn void isolatedCollectionOpened( MpMpxCollectionData* collectionData )
+
+ This signal is emitted when an isolated collection is opened on \a context
+
+ */
+
+/*!
+ \fn void restorePathFailed()
+
+ This signal is emitted when an the previous path cannot be restored
+ (i.e. no music in collection).
+
+ */
+
+/*!
+ \fn void containerContentsChanged()
+
+ This signal is emitted when items are removed or inserted on the current
+ container.
+
+ */
+
+/*!
+-------------------------------------------------------------------------------
+ Playback related signals
+-------------------------------------------------------------------------------
+*/
+
+/*!
+ \fn void volumePropertyChanged( MpCommon::MpVolumeProperty, int value );
+
+ This signal is emitted when framework receives a volume related property notification,
+ such as EPbPropertyVolume, EPbPropertyMaxVolume, EPbPropertyMute.
+ */
+
+/*!
+ \fn void corruptedStop();
+
+ This signal is emitted when framework determines the corrupted song is the last
+ song of the playlist.
+*/
+
+/*!
+ Constructs music player engine.
+ */
+MpEngine::MpEngine()
+ : mMpxHarvesterWrapper(0),
+ mSongScanner(0),
+ mMpxCollectionWrapper(0),
+ mMpxPlaybackWrapper(0),
+ mAudioEffectsWrapper(0),
+ mEqualizerWrapper(0),
+ mCurrentPresetIndex(0),
+ mSongData(0),
+ mUsbBlockingState(USB_NotConnected),
+ mPreviousUsbState(USB_NotConnected),
+ mHandleMediaCommands(true)
+{
+ TX_LOG
+}
+
+/*!
+ Destructs music player engine.
+ */
+MpEngine::~MpEngine()
+{
+ TX_ENTRY
+ delete mMpxPlaybackWrapper;
+ delete mMpxHarvesterWrapper;
+ delete mMpxCollectionWrapper;
+ delete mAudioEffectsWrapper;
+ delete mEqualizerWrapper;
+ delete mSongScanner;
+ delete mSongData;
+ TX_EXIT
+}
+
+/*!
+ Initialize engine
+ */
+void MpEngine::initialize( TUid hostUid, EngineMode mode )
+{
+ TX_ENTRY_ARGS("hostUid=" << hostUid.iUid << ", mode=" << mode);
+ mHostUid = hostUid;
+
+ if ( StandAlone == mode ) {
+ mSongData = new MpSongData();
+
+ // Harvesting Wrapper
+ mMpxHarvesterWrapper = new MpMpxHarvesterFrameworkWrapper( mHostUid );
+ connect( mMpxHarvesterWrapper, SIGNAL( scanStarted() ),
+ this, SLOT( handleScanStarted() ),
+ Qt::QueuedConnection );
+ connect( mMpxHarvesterWrapper, SIGNAL( scanEnded(int, int) ),
+ this, SLOT( handleScanEnded(int, int) ),
+ Qt::QueuedConnection );
+ qRegisterMetaType<MpxDiskEvents>("MpxDiskEvents");
+ connect( mMpxHarvesterWrapper, SIGNAL( diskEvent(MpxDiskEvents) ),
+ this, SLOT( handleDiskEvent(MpxDiskEvents) ),
+ Qt::QueuedConnection );
+ qRegisterMetaType<MpxUsbEvents>("MpxUsbEvents");
+ connect( mMpxHarvesterWrapper, SIGNAL( usbEvent(MpxUsbEvents) ),
+ this, SLOT( handleUsbEvent(MpxUsbEvents) ),
+ Qt::QueuedConnection );
+
+ // Collection Wrapper
+ mMpxCollectionWrapper = new MpMpxCollectionFrameworkWrapper( mHostUid, mSongData );
+ connect( mMpxCollectionWrapper, SIGNAL( collectionPlaylistOpened() ),
+ this, SIGNAL( collectionPlaylistOpened() ),
+ Qt::QueuedConnection );
+ connect( mMpxCollectionWrapper, SIGNAL( aboutToAddSongs(int) ),
+ this, SIGNAL( aboutToAddSongs(int) ) );
+ connect( mMpxCollectionWrapper, SIGNAL( playlistSaved(bool) ),
+ this, SIGNAL( playlistSaved(bool) ),
+ Qt::QueuedConnection );
+ connect( mMpxCollectionWrapper, SIGNAL( playlistsRenamed(bool) ),
+ this, SIGNAL( playlistsRenamed(bool) ),
+ Qt::QueuedConnection );
+ connect( mMpxCollectionWrapper, SIGNAL( isolatedCollectionOpened(MpMpxCollectionData*) ),
+ this, SIGNAL( isolatedCollectionOpened(MpMpxCollectionData*) ),
+ Qt::QueuedConnection );
+ connect( mMpxCollectionWrapper, SIGNAL( containerContentsChanged() ),
+ this, SIGNAL( containerContentsChanged() ),
+ Qt::QueuedConnection );
+ connect( mMpxCollectionWrapper, SIGNAL( deleteStarted(TCollectionContext, int) ),
+ this, SLOT( handleDeleteStarted(TCollectionContext, int) ) );
+ connect( mMpxCollectionWrapper, SIGNAL( songsDeleted(bool) ),
+ this, SLOT( handleDeleteEnded(bool) ),
+ Qt::QueuedConnection );
+ connect( mMpxCollectionWrapper, SIGNAL( restorePathFailed() ),
+ this, SIGNAL( restorePathFailed() ),
+ Qt::QueuedConnection );
+ // Equalizer wrapper; this needs to be created before playback wrapper.
+ mEqualizerWrapper = new MpEqualizerFrameworkWrapper();
+ connect( mEqualizerWrapper, SIGNAL( equalizerReady() ),
+ this, SLOT( handleEqualizerReady() ),
+ Qt::QueuedConnection );
+
+ // Playback Wrapper
+ mMpxPlaybackWrapper = new MpMpxPlaybackFrameworkWrapper( mHostUid, mSongData );
+ connect( this, SIGNAL( libraryUpdated() ),
+ mMpxPlaybackWrapper, SLOT( closeCurrentPlayback() ) );
+ connect( mMpxPlaybackWrapper, SIGNAL ( corruptedStop() ),
+ this, SIGNAL( corruptedStop() ));
+ connect( mMpxPlaybackWrapper, SIGNAL( volumePropertyChanged( MpCommon::MpVolumeProperty, int ) ),
+ this, SIGNAL( volumePropertyChanged( MpCommon::MpVolumeProperty, int ) ) );
+
+ // AudioEffects wrapper
+ mAudioEffectsWrapper = new MpAudioEffectsFrameworkWrapper();
+ }
+ else if ( Fetch == mode ) {
+ // Harvesting Wrapper
+ mMpxHarvesterWrapper = new MpMpxHarvesterFrameworkWrapper( mHostUid );
+ connect( mMpxHarvesterWrapper, SIGNAL( scanStarted() ),
+ this, SLOT( handleScanStarted() ),
+ Qt::QueuedConnection );
+ connect( mMpxHarvesterWrapper, SIGNAL( scanEnded(int, int) ),
+ this, SLOT( handleScanEnded(int, int) ),
+ Qt::QueuedConnection );
+ qRegisterMetaType<MpxDiskEvents>("MpxDiskEvents");
+ connect( mMpxHarvesterWrapper, SIGNAL( diskEvent(MpxDiskEvents) ),
+ this, SLOT( handleDiskEvent(MpxDiskEvents) ),
+ Qt::QueuedConnection );
+ qRegisterMetaType<MpxUsbEvents>("MpxUsbEvents");
+ connect( mMpxHarvesterWrapper, SIGNAL( usbEvent(MpxUsbEvents) ),
+ this, SLOT( handleUsbEvent(MpxUsbEvents) ),
+ Qt::QueuedConnection );
+
+ // Collection Wrapper
+ mMpxCollectionWrapper = new MpMpxCollectionFrameworkWrapper( mHostUid, 0 );
+ connect( mMpxCollectionWrapper, SIGNAL( collectionPlaylistOpened() ),
+ this, SIGNAL( collectionPlaylistOpened() ),
+ Qt::QueuedConnection );
+ // Disabling these since fetch mode plays only one song at a time.
+ mMpxCollectionWrapper->setRepeatFeatureEnabled( false );
+ mMpxCollectionWrapper->setShuffleFeatureEnabled( false );
+
+ // Playback Wrapper
+ mMpxPlaybackWrapper = new MpMpxPlaybackFrameworkWrapper( mHostUid, 0 );
+ connect( this, SIGNAL( libraryUpdated() ),
+ mMpxPlaybackWrapper, SLOT( closeCurrentPlayback() ) );
+ connect( mMpxPlaybackWrapper, SIGNAL ( corruptedStop() ),
+ this, SIGNAL( corruptedStop() ));
+ connect( mMpxPlaybackWrapper, SIGNAL( volumePropertyChanged( MpCommon::MpVolumeProperty, int ) ),
+ this, SIGNAL( volumePropertyChanged( MpCommon::MpVolumeProperty, int ) ) );
+
+ }
+ else if ( MediaBrowsing == mode ) {
+ // Collection Wrapper
+ mMpxCollectionWrapper = new MpMpxCollectionFrameworkWrapper( mHostUid, 0 );
+ connect( mMpxCollectionWrapper, SIGNAL( collectionPlaylistOpened() ),
+ this, SIGNAL( collectionPlaylistOpened() ),
+ Qt::QueuedConnection );
+ connect( mMpxCollectionWrapper, SIGNAL( containerContentsChanged() ),
+ this, SIGNAL( containerContentsChanged() ),
+ Qt::QueuedConnection );
+ }
+ else if ( Embedded == mode ) {
+ mSongData = new MpSongData();
+ // Playback Wrapper
+ mMpxPlaybackWrapper = new MpMpxPlaybackFrameworkWrapper( mHostUid, mSongData );
+ connect( mMpxPlaybackWrapper, SIGNAL( volumePropertyChanged( MpCommon::MpVolumeProperty, int ) ),
+ this, SIGNAL( volumePropertyChanged( MpCommon::MpVolumeProperty, int ) ) );
+
+ }
+ TX_EXIT
+}
+
+/*!
+-------------------------------------------------------------------------------
+ Harvesting related
+-------------------------------------------------------------------------------
+*/
+
+/*!
+ \
+ Used to verify if an action can be executed depending on USB blocking state.
+ If not, a notification note might be displayed.
+ */
+bool MpEngine::verifyUsbBlocking( bool notify )
+{
+ TX_ENTRY
+ bool result( false );
+ if ( mUsbBlockingState == USB_Connected ) {
+ result = true;
+ if ( notify ) {
+ emit unableToCotinueDueUSB();
+ }
+ }
+ TX_EXIT
+ return result;
+}
+
+/*!
+ \
+ Request Harvester to check if there are any system events active.
+ */
+void MpEngine::checkForSystemEvents()
+{
+ TX_ENTRY
+ mMpxHarvesterWrapper->checkForSystemEvents();
+ TX_EXIT
+}
+
+/*!
+ \
+ Returs the current songScanner instance
+ */
+MpSongScanner *MpEngine::songScanner()
+{
+ return mSongScanner;
+}
+/*!
+ Slot to be called to start Refresh library process.
+ If scanning is already ongoing, this request is ignored.
+ */
+void MpEngine::refreshLibrary( bool automaticRequest )
+{
+ TX_ENTRY
+ if ( !verifyUsbBlocking( true ) ) {
+ if ( !mSongScanner ) {
+ mSongScanner = new MpSongScanner( mMpxHarvesterWrapper );
+ }
+ emit libraryAboutToUpdate();
+ mSongScanner->scan( automaticRequest );
+ }
+ TX_EXIT
+}
+
+/*!
+ Slot to be called when song scanning starts.
+ */
+void MpEngine::handleScanStarted() {
+ TX_ENTRY
+ mHandleMediaCommands = false;
+ TX_EXIT
+}
+
+/*!
+ Slot to be called when song scanning ends.
+ */
+void MpEngine::handleScanEnded( int count, int error ) {
+ TX_ENTRY
+ Q_UNUSED( count );
+ Q_UNUSED( error );
+ mHandleMediaCommands = true;
+ emit libraryUpdated();
+ TX_EXIT
+}
+
+/*!
+ Slot to be called when disk event is received from MPX framework.
+ */
+void MpEngine::handleDiskEvent( MpxDiskEvents event )
+{
+ TX_ENTRY_ARGS("event=" << event);
+ switch ( event ) {
+ case DiskFormatStarted:
+ mHandleMediaCommands = false;
+ break;
+ case DiskFormatEnded:
+ mHandleMediaCommands = true;
+ break;
+ case DiskRemoved:
+ if ( mUsbBlockingState != USB_Synchronizing ) {
+ emit libraryUpdated();
+ }
+ break;
+ case DiskInserted:
+ if ( mUsbBlockingState == USB_NotConnected ) {
+ refreshLibrary( true );
+ }
+ else if ( mUsbBlockingState == USB_Connected ) {
+ emit libraryUpdated();
+ }
+ break;
+ default:
+ break;
+ }
+ TX_EXIT
+}
+
+/*!
+ Slot to be called when USB event is received from MPX framework.
+ */
+void MpEngine::handleUsbEvent( MpxUsbEvents event )
+{
+ TX_ENTRY_ARGS("event=" << event);
+ switch ( event ) {
+ case UsbMassStorageStarted:
+ handleUsbMassStorageStartEvent();
+ break;
+ case UsbMassStorageEnded:
+ handleUsbMassStorageEndEvent();
+ break;
+ case UsbMtpStarted:
+ handleUsbMtpStartEvent();
+ break;
+ case UsbMtpEnded:
+ handleUsbMtpEndEvent();
+ break;
+ case UsbMtpNotActive:
+ handleUsbMtpNotActive();
+ default:
+ break;
+ }
+ TX_EXIT
+}
+
+/*!
+ To be called when EMcMsgUSBMassStorageStart event is received.
+ */
+void MpEngine::handleUsbMassStorageStartEvent()
+{
+ TX_ENTRY
+ mHandleMediaCommands = false;
+
+ changeUsbBlockingState( USB_Synchronizing );
+ emit usbBlocked(true);
+ emit usbSynchronizationStarted();
+
+ TX_EXIT
+}
+
+/*!
+ To be called when EMcMsgUSBMassStorageEnd event is received.
+ */
+void MpEngine::handleUsbMassStorageEndEvent()
+{
+ TX_ENTRY
+ mHandleMediaCommands = true;
+
+ changeUsbBlockingState( USB_NotConnected );
+ emit usbBlocked(false);
+ emit usbSynchronizationFinished();
+ refreshLibrary();
+
+ TX_EXIT
+}
+
+/*!
+ To be called when EMcMsgUSBMTPStart event is received.
+ */
+void MpEngine::handleUsbMtpStartEvent()
+{
+ TX_ENTRY
+ mHandleMediaCommands = false;
+
+ changeUsbBlockingState( USB_Synchronizing );
+ emit usbBlocked(true);
+
+ //Cancel any ongoing operation.
+ emit libraryAboutToUpdate();
+
+ emit usbSynchronizationStarted();
+
+ TX_EXIT
+}
+
+/*!
+ To be called when EMcMsgUSBMTPEnd event is received.
+ */
+void MpEngine::handleUsbMtpEndEvent()
+{
+ TX_ENTRY
+ mHandleMediaCommands = true;
+
+ changeUsbBlockingState( USB_NotConnected );
+ emit usbBlocked(false);
+
+ if ( mPreviousUsbState == USB_Synchronizing ) {
+ emit usbSynchronizationFinished();
+ emit libraryUpdated();
+ }
+ TX_EXIT
+}
+
+/*!
+ To be called when EMcMsgUSBMTPNotActive event is received.
+ */
+void MpEngine::handleUsbMtpNotActive()
+{
+ TX_ENTRY
+ changeUsbBlockingState( USB_Connected );
+ emit usbBlocked(true);
+ TX_EXIT
+}
+
+/*!
+ Internal
+ Update the new and previous usb blocking state
+ */
+void MpEngine::changeUsbBlockingState( UsbBlockingState state )
+{
+ TX_ENTRY
+ mPreviousUsbState = mUsbBlockingState;
+ mUsbBlockingState = state;
+ TX_EXIT
+}
+
+/*!
+-------------------------------------------------------------------------------
+ Collection related
+-------------------------------------------------------------------------------
+*/
+
+/*!
+ Opens the collection for the given \a context.
+
+ \sa collectionOpened()
+ */
+void MpEngine::openCollection( TCollectionContext context )
+{
+ mMpxCollectionWrapper->openCollection( context );
+}
+
+/*!
+ Opens the collection at a specific \a index.
+
+ \sa collectionOpened(), playlistOpened()
+ */
+void MpEngine::openCollectionItem( int index )
+{
+ mMpxCollectionWrapper->openCollectionItem( index );
+}
+
+/*!
+ Navigates back to the container of the current items.
+
+ \sa collectionOpened()
+ */
+void MpEngine::back()
+{
+ mMpxCollectionWrapper->back();
+}
+
+/*!
+ Loads the user created \a playLists.
+
+ */
+void MpEngine::findPlaylists( QStringList &playlists )
+{
+ mMpxCollectionWrapper->findPlaylists( playlists );
+}
+
+/*!
+ Creates a new playlist with name \a playlistName and adds \a selection and optionally uses \a collectionData.
+ */
+void MpEngine::createPlaylist( QString &playlistName, QList<int> &selection, MpMpxCollectionData* collectionData )
+{
+ if ( !verifyUsbBlocking( true ) ) {
+ mMpxCollectionWrapper->createPlaylist( playlistName, selection, collectionData );
+ }
+}
+
+/*!
+ Adds \a selection to the playlist specified in \a playlistIndex.
+ */
+void MpEngine::saveToPlaylist( int playlistIndex, QList<int> &selection )
+{
+ if ( !verifyUsbBlocking( true ) ) {
+ mMpxCollectionWrapper->saveToPlaylist( playlistIndex, selection );
+ }
+}
+
+/*!
+ Rename a playlist by \a index with \a name.
+ */
+void MpEngine::renamePlaylist( QString &newName, int index )
+{
+ if ( !verifyUsbBlocking( true ) ) {
+ mMpxCollectionWrapper->renamePlaylist( newName, index );
+ }
+}
+
+/*!
+ Adds \a selection to the current playlist from the specified \a collectionData.
+ */
+void MpEngine::saveToCurrentPlaylist( QList<int> &selection, MpMpxCollectionData *collectionData )
+{
+ if ( !verifyUsbBlocking( true ) ) {
+ mMpxCollectionWrapper->saveToCurrentPlaylist( selection, collectionData );
+ }
+}
+
+/*!
+ Rename a playlist with \a name.
+ */
+void MpEngine::renamePlaylist( QString &newName )
+{
+ if ( !verifyUsbBlocking( true ) ) {
+ mMpxCollectionWrapper->renamePlaylist( newName );
+ }
+}
+
+/*!
+ Deletes \a selection from the collection.
+ */
+void MpEngine::deleteSongs( QList<int> &selection )
+{
+ if ( !verifyUsbBlocking( true ) ) {
+ mMpxCollectionWrapper->deleteSongs( selection );
+ }
+}
+
+
+
+/*!
+ Initiate a playback preview for the selected item.
+ */
+void MpEngine::previewItem( int index )
+{
+ mMpxCollectionWrapper->previewItem( index );
+}
+
+
+/*!
+ Opens the an isolated collection with \a context.
+ \sa isolatedCollectionOpened()
+ */
+void MpEngine::openIsolatedCollection( TCollectionContext context )
+{
+ if ( !verifyUsbBlocking( true ) ) {
+ mMpxCollectionWrapper->openIsolatedCollection( context );
+ }
+}
+
+/*!
+ Releases the resources used for the isolated collection.
+ */
+void MpEngine::releaseIsolatedCollection()
+{
+ mMpxCollectionWrapper->releaseIsolatedCollection();
+}
+
+/*!
+ Finds all songs beloging to the album specified by the \a index.
+ */
+void MpEngine::findAlbumSongs( int index )
+{
+ mMpxCollectionWrapper->findAlbumSongs(index);
+}
+
+/*!
+ Plays album with \a albumIndex starting with the songs with \a songIndex.
+ */
+void MpEngine::playAlbumSongs( int albumIndex, int songIndex, MpMpxCollectionData* collectionData )
+{
+ mMpxCollectionWrapper->playAlbumSongs(albumIndex, songIndex, collectionData);
+}
+
+/*!
+ Returns pointer to MpMpxCollectionData, which is the collection data.
+ */
+MpMpxCollectionData *MpEngine::collectionData()
+{
+ return mMpxCollectionWrapper->collectionData();
+}
+
+/*!
+ Slot to be called to reopen the collection in its current state.
+
+ \sa collectionOpened()
+ */
+void MpEngine::reopenCollection()
+{
+ mMpxCollectionWrapper->reopenCollection();
+}
+
+/*!
+ Slot to be called to request a reorder operation , indicates that
+ the item with \a playlistId , \a songId is to be moved from
+ \a originalOrdinal to \a newOrdinal.
+ */
+void MpEngine::reorderPlaylist( int playlistId, int songId, int originalOrdinal, int newOrdinal )
+{
+ mMpxCollectionWrapper->reorderPlaylist( playlistId, songId, originalOrdinal, newOrdinal );
+}
+
+/*!
+ Slot to be called when song deleting starts.
+ */
+void MpEngine::handleDeleteStarted( TCollectionContext context, int count )
+{
+ TX_ENTRY
+ mHandleMediaCommands = false;
+ emit deleteStarted( context, count );
+ TX_EXIT
+}
+
+/*!
+ Slot to be called when song deleting ends.
+ */
+void MpEngine::handleDeleteEnded( bool success )
+{
+ TX_ENTRY
+ mHandleMediaCommands = true;
+ emit songsDeleted( success );
+ TX_EXIT
+}
+
+/*!
+ Slot to be called when song deleting ends.
+ */
+void MpEngine::cancelCollectionRequest()
+{
+ TX_ENTRY
+ mMpxCollectionWrapper->cancelRequest();
+ TX_EXIT
+}
+
+/*!
+ Returns pointer to MpPlaybackData, which is the playback data.
+ */
+MpPlaybackData *MpEngine::playbackData()
+{
+ return mMpxPlaybackWrapper->playbackData();
+}
+
+/*!
+ Requests playback of all songs with shuffle enabled
+ */
+void MpEngine::shuffleAll()
+{
+ mMpxCollectionWrapper->openShuffleAllSongsPath();
+}
+
+/*!
+ Slot to be called to request embedded playback of item with Uri aFilename
+ */
+
+void MpEngine::playEmbedded( QString aFilename )
+{
+ mMpxPlaybackWrapper->play( aFilename );
+}
+
+/*!
+ Slot to be called to request embedded playback of item with file handle
+ */
+
+void MpEngine::playEmbedded(const XQSharableFile& file )
+{
+ mMpxPlaybackWrapper->play( file );
+}
+
+/*!
+ Slot to handle a play command
+ */
+
+void MpEngine::play()
+{
+ if ( mHandleMediaCommands ) {
+ mMpxPlaybackWrapper->play();
+ }
+}
+
+/*!
+ Slot to handle a pause command.
+ */
+void MpEngine::pause()
+{
+ if ( mHandleMediaCommands ) {
+ mMpxPlaybackWrapper->pause();
+ }
+}
+
+/*!
+ Slot to handle a play pause.
+ */
+void MpEngine::playPause()
+{
+ if ( mHandleMediaCommands ) {
+ mMpxPlaybackWrapper->playPause();
+ }
+}
+
+/*!
+ Slot to handle a stop.
+ */
+void MpEngine::stop()
+{
+ if ( mHandleMediaCommands ) {
+ mMpxPlaybackWrapper->stop();
+ }
+}
+
+/*!
+ Slot to handle a skip forward.
+ */
+void MpEngine::skipForward()
+{
+ if ( mHandleMediaCommands ) {
+ mMpxPlaybackWrapper->skipForward();
+ }
+}
+
+/*!
+ Slot to handle seek forward.
+ */
+void MpEngine::startSeekForward()
+{
+ if ( mHandleMediaCommands ) {
+ mMpxPlaybackWrapper->startSeekForward();
+ }
+}
+
+/*!
+ Slot to handle stop seeking.
+ */
+void MpEngine::stopSeeking()
+{
+ if ( mHandleMediaCommands ) {
+ mMpxPlaybackWrapper->stopSeeking();
+ }
+}
+
+/*!
+ Slot to handle a skip backwards.
+ */
+void MpEngine::skipBackward()
+{
+ if ( mHandleMediaCommands ) {
+ mMpxPlaybackWrapper->skipBackward();
+ }
+}
+
+/*!
+ Slot to handle seek backwards.
+ */
+void MpEngine::startSeekBackward()
+{
+ if ( mHandleMediaCommands ) {
+ mMpxPlaybackWrapper->startSeekBackward();
+ }
+}
+/*!
+ Slot to handle a request to change \a position.
+ */
+void MpEngine::setPosition( int position )
+{
+ mMpxPlaybackWrapper->setPosition( position );
+}
+
+/*!
+ Slot to handle a request to change shuffle \a mode.
+ */
+void MpEngine::setShuffle( bool mode )
+{
+ mMpxPlaybackWrapper->setShuffle( mode );
+}
+
+/*!
+ Slot to handle a request to change repeat \a mode.
+ */
+void MpEngine::setRepeat( bool mode )
+{
+ mMpxPlaybackWrapper->setRepeat( mode );
+}
+
+/*!
+ Slot to handle a request to get the volume level Max.
+ Response will be asynchronously sent through volumePropertyChanged() signal.
+ */
+void MpEngine::getMaxVolume( )
+{
+ mMpxPlaybackWrapper->getMaxVolume();
+}
+
+/*!
+ Slot to handle a request to get the current volume level.
+ Response will be asynchronously sent through volumePropertyChanged() signal.
+ */
+void MpEngine::getVolume( )
+{
+ mMpxPlaybackWrapper->getVolume();
+}
+
+/*!
+ Slot to handle a request to increase volume.
+ */
+void MpEngine::increaseVolume()
+{
+ if ( mHandleMediaCommands ) {
+ mMpxPlaybackWrapper->increaseVolume();
+ }
+}
+
+/*!
+ Slot to handle a request to decrease volume.
+ */
+void MpEngine::decreaseVolume()
+{
+ if ( mHandleMediaCommands ) {
+ mMpxPlaybackWrapper->decreaseVolume();
+ }
+}
+
+/*!
+ Slot to handle a request to set the volume level.
+ */
+void MpEngine::setVolume( int value )
+{
+ if ( mHandleMediaCommands ) {
+ mMpxPlaybackWrapper->setVolume( value );
+ }
+}
+
+/*!
+ Slot to handle a request to get the current mute state.
+ Response will be asynchronously sent through volumePropertyChanged() signal.
+ */
+void MpEngine::getMuteState( )
+{
+ mMpxPlaybackWrapper->getMuteState();
+}
+
+/*!
+ Slot to handle a request to mute.
+ */
+void MpEngine::mute()
+{
+ if ( mHandleMediaCommands ) {
+ mMpxPlaybackWrapper->mute();
+ }
+}
+
+/*!
+ Slot to handle a request to unmute.
+ */
+void MpEngine::unmute()
+{
+ if ( mHandleMediaCommands ) {
+ mMpxPlaybackWrapper->unmute();
+ }
+}
+
+/*!
+ Returns pointer to MpSongData, which is the song data for Details View.
+ */
+MpSongData *MpEngine::songData()
+{
+ return mSongData;
+}
+
+/*!
+ Retrieves song details for the specified \a index.
+ */
+void MpEngine::retrieveSongDetails( int index )
+{
+ TX_ENTRY
+ if ( index == -1 ) {
+ // Retrieve song details of currently playing song
+ mMpxPlaybackWrapper->retrieveSongDetails();
+ }
+ else {
+ mMpxCollectionWrapper->retrieveSongDetails(index);
+ }
+ TX_EXIT
+}
+
+/*!
+ Retrieve balance informatioin from audio effects
+ */
+int MpEngine::balance()
+{
+ return mAudioEffectsWrapper->balance();
+}
+
+/*!
+ Retrieve loudness informatioin from audio effects
+ */
+bool MpEngine::loudness()
+{
+ return mAudioEffectsWrapper->loudness();
+}
+
+/*!
+ Slot to handle a request to change \a balance in audio effects.
+ */
+void MpEngine::setBalance( int balance )
+{
+ TX_ENTRY
+
+ if ( mAudioEffectsWrapper->balance() != balance ) {
+ mAudioEffectsWrapper->setBalance( balance );
+ mMpxPlaybackWrapper->setBalance( balance );
+ }
+
+ TX_EXIT
+}
+
+/*!
+ Slot to handle a request to change loudness \a mode in audio effects.
+ */
+void MpEngine::setLoudness( bool mode )
+{
+ TX_ENTRY
+
+ if( mAudioEffectsWrapper->loudness() != mode ) { //do not set same value twice
+ mAudioEffectsWrapper->setLoudness( mode );
+ mMpxPlaybackWrapper->applyAudioEffects();
+ }
+
+ TX_EXIT
+}
+
+/*!
+ Apply the preset by giving \a presetIndex. The index is subtracted by 1 because
+ index 0 represent "Off" at UI level.
+ */
+void MpEngine::applyPreset( int presetIndex )
+{
+ TX_ENTRY_ARGS( "presetIndex=" << presetIndex );
+
+ TInt presetKey = mEqualizerWrapper->getPresetNameKey( presetIndex - 1 );
+
+ if ( presetKey != KEqualizerPresetNone ) {
+ TX_LOG_ARGS( "Preset key in engine =" << presetKey );
+ // Store in CenRep file
+ MpSettingsManager::setPreset( presetKey );
+ // Notify playback framework of the change.
+ mMpxPlaybackWrapper->applyEqualizer();
+ mCurrentPresetIndex = presetIndex;
+ }
+ else {
+ TX_LOG_ARGS("getPresetNameKey Error = " << KEqualizerPresetNone);
+ }
+
+ TX_EXIT
+}
+
+/*!
+ Disabling equalizer by setting the preset to -1 and apply it to
+ disable current preset.
+ */
+void MpEngine::disableEqualizer()
+{
+ TX_ENTRY
+
+ mCurrentPresetIndex = 0;
+ // Store in CenRep file
+ MpSettingsManager::setPreset( KEqualizerPresetNone );
+ // Notify playback framework of the change.
+ mMpxPlaybackWrapper->applyEqualizer();
+
+ TX_EXIT
+}
+
+/*!
+ Return current preset index (UI)
+ */
+int MpEngine::activePreset()
+{
+ TX_LOG_ARGS("mCurrentPresetIndex = " << mCurrentPresetIndex );
+
+ return mCurrentPresetIndex;
+}
+
+/*!
+ Retrieve list of preset names from equalizer wrapper
+ */
+QStringList MpEngine::presetNames()
+{
+ return mEqualizerWrapper->presetNames();
+}
+
+/*!
+ Save data needed to later restore state (activity)
+ */
+void MpEngine::saveActivityData( QByteArray &data )
+{
+ mMpxCollectionWrapper->savePath( data );
+}
+
+/*!
+ Restore state from activity data
+ */
+void MpEngine::loadActivityData( const QByteArray &data )
+{
+ mMpxCollectionWrapper->restorePath( data );
+}
+
+/*!
+ Slot to handle equalizer ready signal from equalizer wrapper.
+ */
+void MpEngine::handleEqualizerReady()
+{
+ TX_ENTRY
+
+ // Get preset id from cenrep
+ TInt presetKey( MpSettingsManager::preset() );
+
+ mCurrentPresetIndex = mEqualizerWrapper->getPresetIndex( presetKey );
+ emit equalizerReady();
+
+ TX_EXIT
+}
+