/*

* 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 <hbinstance.h>

#include <xqsharablefile.h>

#include "mpengine.h"

#include "mpmpxharvesterframeworkwrapper.h"

#include "mpmpxcollectionframeworkwrapper.h"

#include "mpmpxplaybackframeworkwrapper.h"

#include "mpsongscanner.h"

#include "mpmediakeyhandler.h"

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

 */

/*!

    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

 */

/*!

 Constructs music player engine.

 */

MpEngine::MpEngine()

    : mMpxHarvesterWrapper(0),

      mSongScanner(0),

      mMediaKeyHandler(0),

      mMpxCollectionWrapper(0),

      mMpxPlaybackWrapper(0),

      mMpTranslator(0),

      mUsbBlockingState(USB_NotConnected),

      mPreviousUsbState(USB_NotConnected),

      mViewMode(MpCommon::DefaultView)

{

    TX_LOG

}

/*!

 Destructs music player engine.

 */

MpEngine::~MpEngine()

{

    TX_ENTRY

    TX_EXIT

}

/*!

 Returns the singleton instance of music player engine.

 */

MpEngine * MpEngine::instance()

{

    static MpEngine instance;

    return &instance;

}

/*!

 Initialize engine

 */

void MpEngine::initialize( MpCommon::MpViewMode viewMode, TUid hostUid )

{

    TX_ENTRY

    mViewMode = viewMode;

    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( mViewMode == MpCommon::DefaultView || mViewMode == MpCommon::FetchView ){

        // Harvesting Wrapper

        mMpxHarvesterWrapper = new MpMpxHarvesterFrameworkWrapper( mViewMode, 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 );

        mSongScanner = new MpSongScanner( mMpxHarvesterWrapper );

        mMediaKeyHandler = new MpMediaKeyHandler();

        // Collection Wrapper

        mMpxCollectionWrapper = new MpMpxCollectionFrameworkWrapper( mViewMode, mHostUid );

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

    }

    // Playback Wrapper 

    mMpxPlaybackWrapper = new MpMpxPlaybackFrameworkWrapper( mViewMode, mHostUid );

    TX_EXIT

}

/*!

  Deinitialize wrappers

 */

void MpEngine::close( )

{

    delete mMpTranslator;

    mMpTranslator = 0;

    delete mSongScanner;

    mSongScanner = 0;

    delete mMediaKeyHandler;

    mMediaKeyHandler = 0;   

    delete mMpxPlaybackWrapper;

    mMpxPlaybackWrapper = 0;

    delete mMpxHarvesterWrapper;

    mMpxHarvesterWrapper = 0;

    delete mMpxCollectionWrapper;

    mMpxCollectionWrapper = 0;

}

/*!

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

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

        }

    }

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

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

            }

            break;

        case DiskInserted:

            if ( mUsbBlockingState == USB_NotConnected ) {

                refreshLibrary();

            }

            else if ( mUsbBlockingState == USB_Connected ) {

            }

            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

}

/*!

 */

{

    TX_ENTRY

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

    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.

    launchBlockingNote();

    TX_EXIT

}

/*!

 To be called when EMcMsgUSBMTPEnd event is received.

 */

void MpEngine::handleUsbMtpEndEvent()

{

    TX_ENTRY

    mMediaKeyHandler->setEnabled(true);