/*

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

#include <QLocale>

#include <hbmessagebox.h>

#include <hbprogressdialog.h>

#include <hbaction.h>

#include <hbinstance.h>

#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 "mpprogressdialoghandler.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 scanStarted()

    This signal is emitted when scan operation is started.

 */

/*!

    \fn void scanEnded()

    This signal is emitted when scan operation ends.

 */

/*!

    \fn void scanCountChanged( int count )

    This signal is emitted when scan count is updated.

 */

/*!

    \fn void libraryUpdated()

    This signal is emitted when MpSongScannerHelper ends scanning,

    or USB-MTP Synchronization finishes.

 */

/*!

    \fn void formatStarted()

    This signal is emitted when EMcMsgFormatStart is received from MPXCollectionUtility.

 */

/*!

    \fn void formatEnded()

    This signal is emitted when EMcMsgFormatEnd is received from MPXCollectionUtility.

 */

/*!

    \fn void diskRemoved()

    This signal is emitted when EMcMsgDiskRemoved is received from MPXCollectionUtility.

 */

/*!

    \fn void diskInserted()

    This signal is emitted when EMcMsgDiskInserted is received from MPXCollectionUtility.

 */

/*!

    \fn void usbMassStorageStarted()

    This signal is emitted when EMcMsgUSBMassStorageStart is received from MPXCollectionUtility.

 */

/*!

    \fn void usbMassStorageEnded()

    This signal is emitted when EMcMsgUSBMassStorageEnd is received from MPXCollectionUtility.

 */

/*!

    \fn void usbMtpStarted()

    This signal is emitted when EMcMsgUSBMtpStart is received from MPXCollectionUtility.

 */

/*!

    \fn void usbMtpEnded()

    This signal is emitted when EMcMsgUSBMtpEnd is received from MPXCollectionUtility.

 */

/*!

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

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

      mUsbOutstandingNote(0),

      mMpxCollectionWrapper(0),

      mMpxPlaybackWrapper(0),

      mMpxDetailsWrapper(0),

      mAudioEffectsWrapper(0),

      mEqualizerWrapper(0),

      mCurrentPresetIndex(KEqualizerPresetNone),

      mMpTranslator(0),

      mUsbBlockingState(USB_NotConnected),

      mPreviousUsbState(USB_NotConnected),

      mProgressDialogHandler(0)

{

    TX_LOG

}

/*!

 Destructs music player engine.

 */

MpEngine::~MpEngine()

{

    TX_ENTRY

    delete mMpTranslator;

    delete mMediaKeyHandler;

    delete mUsbOutstandingNote;

    delete mMpxPlaybackWrapper;

    delete mMpxDetailsWrapper;

    delete mMpxHarvesterWrapper;

    delete mMpxCollectionWrapper;

    delete mAudioEffectsWrapper;

    delete mEqualizerWrapper;

	delete mProgressDialogHandler;

    TX_EXIT

}

/*!

 Initialize engine

 */

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

{

    TX_ENTRY

    mHostUid = hostUid;

    //Load musicplayer translator

    QString lang = QLocale::system().name();

    QString path = QString( "z:/resource/qt/translations/" );

    bool translatorLoaded = false;

    mMpTranslator = new QTranslator( this );

    translatorLoaded = mMpTranslator->load( path + "musicplayer_" + lang );

    TX_LOG_ARGS( "Loading translator ok=" << translatorLoaded );

    if ( translatorLoaded ) {

        qApp->installTranslator( mMpTranslator );

    }

    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( playlistSaved( bool ) ),

                this, SIGNAL( playlistSaved( bool ) ),

                Qt::QueuedConnection );

        connect( mMpxCollectionWrapper, SIGNAL( songsDeleted( bool ) ),

                this, SIGNAL( songsDeleted( 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( mProgressDialogHandler, SIGNAL( deleteStarted() ), 

               this, SLOT( handleDeleteStarted() ),

               Qt::QueuedConnection );

       connect( mProgressDialogHandler, 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();

    }

    if (mMpxHarvesterWrapper && mMpxCollectionWrapper){

        mProgressDialogHandler = new MpProgressDialogHandler(mMpxCollectionWrapper, mMpxHarvesterWrapper);

    }

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

{

    TX_ENTRY

    bool result( false );

    if ( mUsbBlockingState == USB_Connected ) {

        result = true;

        if ( showMessage ) {

            HbMessageBox *dialog = new HbMessageBox( HbMessageBox::MessageTypeInformation );

            dialog->setText( hbTrId( "txt_mus_info_usb_conn_in_progress" ) );

            dialog->setModal( true );

            setOutstandingPopup( dialog );

            mUsbOutstandingNote->show();;

        }

    }

    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.

 */

void MpEngine::refreshLibrary()

{

    TX_ENTRY

    if ( !verifyUsbBlocking( true ) ) {

        emit libraryAboutToUpdate();

        mProgressDialogHandler->scan();

    }

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

            }

            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

}

/*!

 Slot to be called when mUsbOutstandingNote is about to close.

 */

void MpEngine::handleOutstandingNoteClosing()

{

    TX_ENTRY

    mUsbOutstandingNote = 0;

    TX_EXIT

}

/*!

 To be called when EMcMsgUSBMassStorageStart event is received.

 */

void MpEngine::handleUsbMassStorageStartEvent()

{

    TX_ENTRY

    mMediaKeyHandler->setEnabled(false);

    changeUsbBlockingState( USB_Synchronizing );

    emit usbBlocked(true);

    launchBlockingNote();

    TX_EXIT

}

/*!

 To be called when EMcMsgUSBMassStorageEnd event is received.

 */

void MpEngine::handleUsbMassStorageEndEvent()

{

    TX_ENTRY

    mMediaKeyHandler->setEnabled(true);    

    changeUsbBlockingState( USB_NotConnected );

    emit usbBlocked(false);

    HbAction *action;

    HbMessageBox *promptRefresh = new HbMessageBox( HbMessageBox::MessageTypeQuestion );

    promptRefresh->setText( hbTrId( "txt_mus_info_music_may_need_to_be_refreshed" ) );

    promptRefresh->setTimeout( HbPopup::NoTimeout );

    promptRefresh->setModal( true );

    promptRefresh->clearActions();

    action = new HbAction( hbTrId( "txt_common_button_yes" ) );

    connect( action, SIGNAL( triggered() ), this, SLOT( refreshLibrary() ) );