diff -r 26a1709b9fec -r 14979e23cb5e mpengine/src/mpengine.cpp --- /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 +#include + +#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"); + connect( mMpxHarvesterWrapper, SIGNAL( diskEvent(MpxDiskEvents) ), + this, SLOT( handleDiskEvent(MpxDiskEvents) ), + Qt::QueuedConnection ); + qRegisterMetaType("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"); + connect( mMpxHarvesterWrapper, SIGNAL( diskEvent(MpxDiskEvents) ), + this, SLOT( handleDiskEvent(MpxDiskEvents) ), + Qt::QueuedConnection ); + qRegisterMetaType("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 &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 &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 &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 &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 +} +