/*

* 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 "mpmpxdetailsframeworkwrapper.h"

#include "mpaudioeffectsframeworkwrapper.h"

#include "mpequalizerframeworkwrapper.h"

#include "mpmediakeyhandler.h"

#include "mptrace.h"

#include "mpsettingsmanager.h"

#include "mpsongscanner.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.

 */

/*!

    \fn void libraryRefreshNeeded()

    This signal is emitted when usb in MassStorage mode 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 containerContentsChanged()

    This signal is emitted when items are removed or inserted on the current 

    container.

 */

/*!

 Constructs music player engine.

 */

MpEngine::MpEngine()

    : mMpxHarvesterWrapper(0),

      mSongScanner(0),

      mMediaKeyHandler(0),

      mMpxCollectionWrapper(0),

      mMpxPlaybackWrapper(0),

      mMpxDetailsWrapper(0),

      mAudioEffectsWrapper(0),

      mEqualizerWrapper(0),

      mCurrentPresetIndex(KEqualizerPresetNone),

      mUsbBlockingState(USB_NotConnected),

      mPreviousUsbState(USB_NotConnected)

{

    TX_LOG

}

/*!

 Destructs music player engine.

 */

MpEngine::~MpEngine()

{

    TX_ENTRY

    delete mMediaKeyHandler;

    delete mMpxPlaybackWrapper;

    delete mMpxDetailsWrapper;

    delete mMpxHarvesterWrapper;

    delete mMpxCollectionWrapper;

    delete mAudioEffectsWrapper;

    delete mEqualizerWrapper;

    delete mSongScanner;

    TX_EXIT

}

/*!

 Initialize engine

 */

void MpEngine::initialize( TUid hostUid, EngineMode mode )

{

    TX_ENTRY

    mHostUid = hostUid;

    if( mode == StandAlone || mode == Fetch ){

        // 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 );

        mMediaKeyHandler = new MpMediaKeyHandler();

    }

    if ( mode == StandAlone || mode == Fetch || mode == MediaBrowsing) {

        // Collection Wrapper

        mMpxCollectionWrapper = new MpMpxCollectionFrameworkWrapper( mHostUid );

        //disabling these since fetch mode plays only one song at a time.

        mMpxCollectionWrapper->setRepeatFeatureEnabled( mode != Fetch );

        mMpxCollectionWrapper->setShuffleFeatureEnabled( mode != Fetch );

        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 );

    }

    if( mode == StandAlone ){

        // Equalizer wrapper , this needs to be created before playback wrapper.

        mEqualizerWrapper = new MpEqualizerFrameworkWrapper();

        connect( mEqualizerWrapper, SIGNAL( equalizerReady() ), 

                 this, SLOT( handleEqualizerReady() ), Qt::QueuedConnection );

    }

    if ( mode == StandAlone || mode == Fetch || mode == Embedded ) {

        // Playback Wrapper 

        mMpxPlaybackWrapper = new MpMpxPlaybackFrameworkWrapper( mHostUid );

        // Details Wrapper

        mMpxDetailsWrapper = new MpMpxDetailsFrameworkWrapper( mHostUid );

    }

    if( mode == StandAlone ){

        // AudioEffects wrapper

        mAudioEffectsWrapper = new MpAudioEffectsFrameworkWrapper();

    }

    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

    mMediaKeyHandler->setEnabled(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 );

    mMediaKeyHandler->setEnabled(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:

            mMediaKeyHandler->setEnabled(false);

            break;

        case DiskFormatEnded:

            mMediaKeyHandler->setEnabled(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

    mMediaKeyHandler->setEnabled(false);

    changeUsbBlockingState( USB_Synchronizing );

    emit usbBlocked(true);

    emit usbSynchronizationStarted();

    TX_EXIT

}

/*!

 To be called when EMcMsgUSBMassStorageEnd event is received.

 */

void MpEngine::handleUsbMassStorageEndEvent()

{

    TX_ENTRY

    mMediaKeyHandler->setEnabled(true);

    changeUsbBlockingState( USB_NotConnected );

    emit usbBlocked(false);

    emit usbSynchronizationFinished();

    emit libraryRefreshNeeded();

    TX_EXIT

}

/*!

 To be called when EMcMsgUSBMTPStart event is received.

 */

void MpEngine::handleUsbMtpStartEvent()

{

    TX_ENTRY

    mMediaKeyHandler->setEnabled(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

    mMediaKeyHandler->setEnabled(true);