/*

* 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"

/*!

    \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 libraryUpdated()

 */

/*!

 */

/*!

 */

/*!

 */

/*!

 */

/*!

 */

/*!

-------------------------------------------------------------------------------

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

      mMediaKeyHandler(0),

      mMpxCollectionWrapper(0),

      mMpxPlaybackWrapper(0),

      mMpxDetailsWrapper(0),

      mAudioEffectsWrapper(0),

      mEqualizerWrapper(0),

      mCurrentPresetIndex(KEqualizerPresetNone),

      mUsbBlockingState(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;

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

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

    }

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

    }

}

/*!

-------------------------------------------------------------------------------

    Harvesting related

-------------------------------------------------------------------------------

*/

/*!

 \

 Used to verify if an action can be executed depending on USB blocking state.

 If not, a notification note might be displayed.

 */

{

    TX_ENTRY

    bool result( false );

    if ( mUsbBlockingState == USB_Connected ) {

        result = true;

        }

    }

    TX_EXIT

    return result;

}

/*!

 \

 Request Harvester to check if there are any system events active.

 */

void MpEngine::checkForSystemEvents()

{

    TX_ENTRY

    mMpxHarvesterWrapper->checkForSystemEvents();

    TX_EXIT

}

/*!

 Slot to be called to start Refresh library process.

 If scanning is already ongoing, this request is ignored.

 */

{

    TX_ENTRY

    if ( !verifyUsbBlocking( true ) ) {

        emit libraryAboutToUpdate();

    }

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

            }

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

    TX_EXIT

}

/*!

 To be called when EMcMsgUSBMassStorageEnd event is received.

 */

void MpEngine::handleUsbMassStorageEndEvent()

{

    TX_ENTRY

    changeUsbBlockingState( USB_NotConnected );

    emit usbBlocked(false);

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

    TX_EXIT

}

/*!

 To be called when EMcMsgUSBMTPEnd event is received.

 */

void MpEngine::handleUsbMtpEndEvent()

{

    TX_ENTRY

    changeUsbBlockingState( USB_NotConnected );

    emit usbBlocked(false);

    if ( mPreviousUsbState == USB_Synchronizing ) {

        emit libraryUpdated();

    }

    TX_EXIT

}