/*

* Copyright (c) 2006 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:  Handles commands passed in by other appilcations

*

*/

// INCLUDE FILES

#include <bldvariant.hrh>

#include <apgtask.h>

#include <eikenv.h>

#include <mpxcollectionmessage.h>

#include <mpxcollectionutility.h>

#include <mpxcollectionplaylist.h>

#include <mpxcollectionpath.h>

#include <mpxcollectionopenutility.h>

#include <mpxplaybackutility.h>

#include <mpxplaybackmessage.h>

#include <mpxviewutility.h>

#include <mpxmusicplayerviewplugin.hrh>

#include <mpxmediacollectiondetaildefs.h>

#include <mpxcollectionhelperfactory.h>

#include <mpxcollectionuihelper.h>

#include <mpxparameter.h>

#include <mpxmessagegeneraldefs.h>

#include <mpxplaybackmessagedefs.h>

#include <mpxmediacontainerdefs.h>

#include <mpxmediaarray.h>

#include "mpxtlshelper.h"

#include <mpxconstants.h>

#include "mpxcommandhandler.h"

#include "mpxlog.h"

#include <mpxviewpluginmanager.h>

#include <mpxviewplugin.h>

const TInt KIncrementalFetchCount = 10; // all we need is the first song in all song

const TInt KWaitNoteImpUid = 0x101FFC6C; // refresh wait note UID

// ============================ MEMBER FUNCTIONS ==============================

// ----------------------------------------------------------------------------

// Two-phased constructor.

// ----------------------------------------------------------------------------

//

CMPXCommandHandler* CMPXCommandHandler::NewL(

    MMPXPlaybackUtility* aPlaybackUtility,

    TUid aCollectionMode,

    const TDesC8& aParameter )

    {

    CMPXCommandHandler* self = NewLC(

        aPlaybackUtility, aCollectionMode, aParameter );

    CleanupStack::Pop(self);

    return self;

    }

// ----------------------------------------------------------------------------

// Two-phased constructor.

// ----------------------------------------------------------------------------

//

CMPXCommandHandler* CMPXCommandHandler::NewLC(

    MMPXPlaybackUtility* aPlaybackUtility,

    TUid aCollectionMode,

    const TDesC8& aParameter )

    {

    CMPXCommandHandler* self = new ( ELeave )

        CMPXCommandHandler( aPlaybackUtility );

    CleanupStack::PushL(self);

    self->ConstructL( aCollectionMode, aParameter );

    return self;

    }

// ----------------------------------------------------------------------------

// C++ constructor can NOT contain any code that might leave.

// ----------------------------------------------------------------------------

//

CMPXCommandHandler::CMPXCommandHandler(

    MMPXPlaybackUtility* aPlaybackUtility ):

    iPlaybackUtility( aPlaybackUtility )

    ,iPathInited( EFalse )

    ,iLastPlayedAutostart(EFalse)

    {

    }

// ----------------------------------------------------------------------------

// Destructor.

// ----------------------------------------------------------------------------

//

CMPXCommandHandler::~CMPXCommandHandler()

    {

    if ( iPlaybackUtility )

        {

        TRAP_IGNORE( iPlaybackUtility->RemoveObserverL( *this ) );

        }

    if ( iMusicPlayerCollectionUtility )

        {

        iMusicPlayerCollectionUtility->Close();

        }

    if ( iViewUtility )

        {

        iViewUtility->Close();

        }

    delete iIsolatedIncOpenUtil;

    delete iParameter;

    }

// ----------------------------------------------------------------------------

// Symbian 2nd phase constructor can leave.

// ----------------------------------------------------------------------------

//

void CMPXCommandHandler::ConstructL(

    TUid aCollectionMode,

    const TDesC8& aParameter )

    {

    iIsolatedIncOpenUtil =

        CMPXCollectionOpenUtility::NewL( this, KMcModeIsolated );

    iMusicPlayerCollectionUtility = MMPXCollectionUtility::NewL(

        this, aCollectionMode );

    iPlaybackUtility->AddObserverL( *this );

    iViewUtility = MMPXViewUtility::UtilityL();

    ExtractMessageL( aParameter );

    }

// ---------------------------------------------------------------------------

// Start processing the command

// ---------------------------------------------------------------------------

//

void CMPXCommandHandler::ProcessMessageL( TBool aIsUsbInUse, TBool aRefreshing, TBool aFormattingOnGoing )

    {

    MPX_FUNC( "CMPXCommandHandler::ProcessMessageL" );

    iPathInited = EFalse;

    iUsbInUse = aIsUsbInUse;

    iRefreshOngoing = aRefreshing;

    if ( iUsbInUse || iRefreshOngoing || aFormattingOnGoing )

        {

        MPX_DEBUG1( "CMPXCommandHandler::ProcessMessageL USB/Refresh/Formatting ongoing, bring app to foreground only" );

        // USB is in use, bring the app to foreground and ignore the message

        delete iParameter;

        iParameter = NULL;

        // have to use window group to activate, in case some other window

        // has higher priority than us (e.g. playback popup and volume popup)

        RWindowGroup myWin = CEikonEnv::Static()->RootWin();

        myWin.SetOrdinalPosition( 0, ECoeWinPriorityNormal );

        }

    else

        {

        if ( iParameter )

            {

            if ( CEikonEnv::Static()->StartedAsServerApp() )

                {

                // embedded mode, can't check if db exist

                // just process the message

                MPX_DEBUG1( "CMPXCommandHandler::ProcessMessageL embedded mode" );

                DoHandleMessageL();

                }

            else

                {

                // check if DB is created

                MPX_DEBUG1( "CMPXCommandHandler::ProcessMessageL check if db is created" );

                RArray<TMPXAttribute> atts;

                CleanupClosePushL( atts );

                atts.Append( KMPXMediaColDetailDBCreated );

                if ( iParameter->iCollectionPath )

                    {

                    iMusicPlayerCollectionUtility->Collection().MediaL(

                        *iParameter->iCollectionPath, atts.Array() );

                    }

                else

                    {

                    MMPXCollectionUiHelper* colUiHelper =

                        CMPXCollectionHelperFactory::NewCollectionUiHelperL();

                    CMPXCollectionPath* cpath = colUiHelper->MusicMenuPathL();

                    CleanupStack::PushL( cpath );

                    iMusicPlayerCollectionUtility->Collection().MediaL(

                        *cpath, atts.Array() );

                    colUiHelper->Close();

                    CleanupStack::PopAndDestroy( cpath );

                    }

                CleanupStack::PopAndDestroy( &atts );

                }

            }

        }

    }

// ---------------------------------------------------------------------------

// Returns if a path has been inited in playback engine

// ---------------------------------------------------------------------------

//

TBool CMPXCommandHandler::IsPathInited()

    {

    MPX_FUNC( "CMPXCommandHandler::IsPathInited" );

    return iPathInited;

    }

// ---------------------------------------------------------------------------

// Set usb status

// ---------------------------------------------------------------------------

//

void CMPXCommandHandler::SetUsbInUse( TBool aIsUsbInUse )

    {

    MPX_FUNC( "CMPXCommandHandler::SetUsbInUse" );

    iUsbInUse = aIsUsbInUse;

    }

// ---------------------------------------------------------------------------

// Set refresh status

// ---------------------------------------------------------------------------

//

void CMPXCommandHandler::SetRefreshState( TBool aRefreshing )

    {

    MPX_FUNC( "CMPXCommandHandler::aRefreshing" );

    iRefreshOngoing = aRefreshing;

    }

// ---------------------------------------------------------------------------

// Determines if the command should be handled by standalone mode.

// ---------------------------------------------------------------------------

//

TBool CMPXCommandHandler::ForwardCmdToStandAloneMode()

    {

    MPX_FUNC( "CMPXCommandHandler::ForwardCmdToStandAloneMode" );

    TBool ret( EFalse );

    if ( iParameter )

        {

        ret = ( iParameter->iCmdForward == EMPXCmdFwdStandAlone );

        }

    return ret;

    }

// ---------------------------------------------------------------------------

// Determines if the command should be handled by now playing instance

// ---------------------------------------------------------------------------

//

TBool CMPXCommandHandler::ForwardCmdToNowPlaying()

    {

    MPX_FUNC( "CMPXCommandHandler::ForwardCmdToNowPlaying" );

    TBool ret( EFalse );

    if ( iParameter )

        {

        ret = ( iParameter->iCmdForward == EMPXCmdFwdNowPlaying );

        }

    return ret;

    }

// ---------------------------------------------------------------------------

// Checks if initialize playback engine is needed for current command

// ---------------------------------------------------------------------------

//

TBool CMPXCommandHandler::IsInitPlaybackEngineNeeded()

    {

    MPX_FUNC( "CMPXCommandHandler::IsInitPlaybackEngineNeeded" );

    TBool ret( EFalse );

    if ( iParameter )

        {

        ret = ( iParameter->iPathType == EMPXTypeCollectionPlaylist );

        }

    return ret;

    }

// ---------------------------------------------------------------------------

// Extracts the activated view type from the command

// ---------------------------------------------------------------------------

//

TInt CMPXCommandHandler::ActivatedViewTypeId()

    {

    MPX_FUNC( "CMPXCommandHandler::ActivatedViewTypeId" );

    TInt id( 0 );

    if ( iParameter )

        {

        id = iParameter->iType.iUid;

        }

    return id;

    }

// ---------------------------------------------------------------------------

// From MMPXCollectionObserver.

// Handle media properties.

// ---------------------------------------------------------------------------

//

void CMPXCommandHandler::HandleCollectionMediaL(

    const CMPXMedia& aMedia,

    TInt aError )

    {

    MPX_FUNC( "CMPXCommandHandler::HandleCollectionMediaL" );

    TBool bringToForeground( EFalse );

    TUid waitnoteId = TUid::Uid( KMPXPluginTypeWaitNoteDialogUid );

    TUid activeView = iViewUtility->ActiveViewType();

    if( activeView == waitnoteId && !iUsbInUse && !iRefreshOngoing )

        {

        CMPXViewPlugin* pi =

            iViewUtility->ViewPluginManager().PluginL( TUid::Uid(KWaitNoteImpUid) );

        pi->DeactivateView();

        }

    if ( aError == KErrNone )

        {

        if( aMedia.IsSupported( KMPXMediaColDetailDBCreated ) )

            {

            TBool dbCreated( aMedia.ValueTObjectL<TBool>( KMPXMediaColDetailDBCreated ) );

            if ( dbCreated )

                {

                MPX_DEBUG1( "CMPXCommandHandler::HandleCollectionMediaL DB status ok" );

                DoHandleMessageL();

                }

            else

                {

                MPX_DEBUG1( "CMPXCommandHandler::HandleCollectionMediaL DB not created" );

                if ( !iUsbInUse && !iRefreshOngoing )

                    {

                    iViewUtility->ActivateViewL( TUid::Uid( KMPXPluginTypeMainUid ) );

                    }

                else

                    {

                    MPX_DEBUG1( "CMPXCommandHandler::HandleCollectionMediaL USB in use/Refreshing, not activating view" );

                    }

                bringToForeground = ETrue;

                }

            }

        }

    else

        {

        MPX_DEBUG1( "CMPXCommandHandler::HandleCollectionMediaL error getting DB status" );

        if ( !iUsbInUse && !iRefreshOngoing )

            {

            iViewUtility->ActivateViewL( TUid::Uid( KMPXPluginTypeMainUid ) );

            }

        else

            {

            MPX_DEBUG1( "CMPXCommandHandler::HandleCollectionMediaL USB in use/Refreshing, not activating view" );

            }

        bringToForeground = ETrue;

        }

    if ( bringToForeground )

        {

        MPX_DEBUG1( "CMPXCommandHandler::HandleCollectionMediaL bringing app to foreground" );

        // have to use window group to activate, in case some other window

        // has higher priority than us (e.g. playback popup and volume popup)

        RWindowGroup myWin = CEikonEnv::Static()->RootWin();

        myWin.SetOrdinalPosition( 0, ECoeWinPriorityNormal );

        }

    }

// ---------------------------------------------------------------------------

// From MMPXCollectionObserver.

// Handle collection message.

// ---------------------------------------------------------------------------

//

void CMPXCommandHandler::HandleCollectionMessage(

    CMPXMessage* aMessage, TInt aError )

    {

    if ( aError == KErrNone && aMessage )

        {

        TRAP_IGNORE( DoHandleCollectionMessageL( *aMessage ) );

        }

    }

// ---------------------------------------------------------------------------

// From MMPXCollectionObserver.

// Handles the collection entries being opened.

// ---------------------------------------------------------------------------

//

void CMPXCommandHandler::HandleOpenL(

    const CMPXMedia& aEntries,

    TInt /* aIndex */,

    TBool /* aComplete */,

    TInt aError  )

    {

    MPX_FUNC( "CMPXCommandHandler::HandleOpenL 4" );

    if ( iCollectionPlaylistState ==

        TMPXCollectionPlaylistSetupStateOpenPath )

        {

        if ( !aError )

            {

            const CMPXMediaArray* mediaArray(

                aEntries.Value<CMPXMediaArray>( KMPXMediaArrayContents ) );

            User::LeaveIfNull( const_cast<CMPXMediaArray*>( mediaArray ));

            if ( mediaArray->Count() > 0 )

                {

                CMPXCollectionPath* cPath( iIsolatedIncOpenUtil->PathL() );

                CleanupStack::PushL( cPath );

                if ( cPath->Id( cPath->Levels() - 1 ) != KMPXInvalidItemId )

                    {

                    iIsolatedIncOpenUtil->Stop();

                    InitPlaybackEngineL( *cPath );

                    }

                CleanupStack::PopAndDestroy( cPath );

                }

            else

                {

                // if there's nothing to open, check if the parameter

                // contains a view to open

                DoHandleMessageL();

                }

            }

        else

            {

            iCollectionPlaylistState = TMPXCollectionPlaylistSetupStateIdle;

            }

        }

    }

// ---------------------------------------------------------------------------

// From MMPXCollectionObserver.

// Handles the item being opened.

// ---------------------------------------------------------------------------

//

void CMPXCommandHandler::HandleOpenL(

    const CMPXCollectionPlaylist& /*aPlaylist*/,

    TInt /*aError*/ )

    {

    MPX_FUNC("CMPXCommandHandler::HandleOpenL 2");

    // Not used

    }

// ---------------------------------------------------------------------------

// Handle playback message.

// ---------------------------------------------------------------------------

//

void CMPXCommandHandler::HandlePlaybackMessage(

    CMPXMessage* aMessage, TInt aError )

    {

    if ( aError == KErrNone && aMessage )

        {

        TRAP_IGNORE( DoHandlePlaybackMessageL( *aMessage ) );

        }

    }

// ---------------------------------------------------------------------------

// Initialize the playback engine with a collection path

// ---------------------------------------------------------------------------

//

void CMPXCommandHandler::InitPlaybackEngineL( CMPXCollectionPath& aPath )

    {

    MPX_FUNC( "CMPXCommandHandler::InitPlaybackEngineL" );

    CMPXCollectionPlaylist* playlist = CMPXCollectionPlaylist::NewL( aPath );

    CleanupStack::PushL( playlist );

    if ( iCollectionPlaylistState ==

        TMPXCollectionPlaylistSetupStateOpenPath )

        {

        playlist->SetToIndex(KErrNotFound);

        }

    iCollectionPlaylistState =

        TMPXCollectionPlaylistSetupStateInitPlaybackEngine;

    iPlaybackUtility->InitL( *playlist, ETrue );

    iPathInited = ETrue;

    CleanupStack::PopAndDestroy( playlist );

    }

// -----------------------------------------------------------------------------

// DoHandleMessageL

// -----------------------------------------------------------------------------

//

void CMPXCommandHandler::DoHandleMessageL()

    {

    MPX_FUNC( "CMPXCommandHandler::DoHandleMessageL" );

    TBool isNeedSetWindowGroup = ETrue;

    TBool pathOpened( EFalse );

    iUnhandledMessage = EFalse;

    TUid appToActivate( KAppUidMusicPlayerX );

    if ( CEikonEnv::Static()->StartedAsServerApp() )

        {

        // if it's embedded mode

        appToActivate = MPXTlsHelper::HostUid();

        }

    MPX_DEBUG3( "CMPXCommandHandler::DoHandleMessageL iUsbInUse = %d, iRefreshOngoing = %d", iUsbInUse, iRefreshOngoing );

    if ( iParameter && !iUsbInUse && !iRefreshOngoing )

        {

        if ( iParameter->iCollectionPath )

            {

            if ( iParameter->iPathType != EMPXTypeCollectionPlaylist )

                {

                // if it's a collection path, use music player collection

                // utility to open it.  Collection server understands collection path

                // with indexes but not ids.

                MPX_DEBUG1( "CMPXCommandHandler::DoHandleMessageL iCollectionPath defined, path" );

                iMusicPlayerCollectionUtility->Collection().OpenL(

                    *iParameter->iCollectionPath );

                }

            else

                {

                MPX_DEBUG1( "CMPXCommandHandler::DoHandleMessageL iCollectionPath defined, playlist" );

                // if it's collection playlist path, need to use isolated

                // collection utility to translate it to real uids

                iCollectionPlaylistState =

                    TMPXCollectionPlaylistSetupStateOpenPath;

                RArray<TMPXAttribute> attrs;

                CleanupClosePushL( attrs );

                TArray<TMPXAttribute> ary = attrs.Array();

                iIsolatedIncOpenUtil->Stop();

                iIsolatedIncOpenUtil->SetDelay( 0 );

                iIsolatedIncOpenUtil->StartL( *iParameter->iCollectionPath, ary, KIncrementalFetchCount,

                                      0, CMPXCollectionOpenUtility::EFetchNormal );

                CleanupStack::PopAndDestroy( &attrs );

                }

            pathOpened = ETrue;

            }

        if ( iParameter->iType != KNullUid )

            {

            if ( pathOpened )

                {

                MPX_DEBUG1( "CMPXCommandHandler::DoHandleMessageL path opened, view activation deffered" );

                // path opened, need to wait for callback before handling

                // view switching

                iUnhandledMessage = ETrue;

                delete iParameter->iCollectionPath;

                iParameter->iCollectionPath = NULL;

                }

            else

                {

                MPX_DEBUG2( "CMPXCommandHandler::DoHandleMessageL activate view 0x%x", iParameter->iType.iUid );

                if ( iParameter->iType.iUid == KMPXPluginTypePlaybackUid && appToActivate == KAppUidMusicPlayerX )

                    {

                    // push default view history in case for view jumps

                    iViewUtility->PushDefaultHistoryL();