/*

* 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:  Implementation of Collection view

*

*/

// INCLUDE FILES

#include <bldvariant.hrh>

#include <f32file.h>

#include <eikmenub.h>

#include <coeutils.h>

#include <aknlists.h>

#include <aknViewAppUi.h>

#include <AknQueryDialog.h>

#include <StringLoader.h>

#include <aknnavilabel.h>

#include <aknnavide.h>

#include <akntitle.h>

#include <textresolver.h>

#include <aknnotewrappers.h>

#include <aknnavi.h>

#include <hlplch.h>

#include <avkon.hrh>

#include <avkon.rsg>

#include <avkon.mbg>

#include <sendui.h>

#include <CMessageData.h>

#include <centralrepository.h>

#include <MProfileEngine.h>

#include <AknDlgShut.h>

#ifdef RD_MULTIPLE_DRIVE

#include <driveinfo.h>

#endif //RD_MULTIPLE_DRIVE

#include <aknmessagequerydialog.h>

#include <gfxtranseffect/gfxtranseffect.h>    

#include <akntranseffect.h>

#include <upnpcopycommand.h>

#include <AiwServiceHandler.h>  //Copy to remote feature

#include <mediarecognizer.h>

#include <featmgr.h>

#include <AknMediatorFacade.h>

#include <MediatorCommandInitiator.h>

#include <MediatorDomainUIDs.h>

#include <mplayersecondarydisplayapi.h>

#include <data_caging_path_literals.hrh>

#include <layoutmetadata.cdl.h>

#include <mpxplaybackframeworkdefs.h>

#include <mpxcollectionmessage.h>

#include <mpxviewutility.h>

#include <mpxmusicplayerviewplugin.hrh>

#include <mpxcollectionviewhg.rsg>

#include <mpxcollectionviewhg.mbg>

#include <mpxcommonui.rsg>

#include <mpxcollectionutility.h>

#include <mpxplaybackutility.h>

#include <mpxplaybackmessage.h>

#include <mpxmedia.h>

#include <mpxcollectionhelperfactory.h>

#include <mpxcollectionplaylist.h>

#include <mpxmediacontainerdefs.h>

#include <mpxmediamusicdefs.h>

#include <mpxmediacollectiondetaildefs.h>

#include <mpxmediadrmdefs.h>

#include <mpxmediaarray.h>

#include <mpxcollectioncommanddefs.h>

#include <mpxcommandgeneraldefs.h>

#include <mpxmessagegeneraldefs.h>

#include <mpxcommandgeneraldefs.h>

#include <mpxcollectioncommanddefs.h>

#include <mpxviewpluginmanager.h>

#include <mpxviewplugin.h>

#ifdef BACKSTEPPING_INCLUDED

#include <mpxbacksteppingutility.h>

#endif // BACKSTEPPING_INCLUDED

#include <mpxcollectionopenutility.h>

#include <mpxfindinmusicshop.h>

#include <mpxfindinmusicshopcommon.h>  // KFindInMShopKeyInValid

// cenrep key need to be checked whether Mass Storage or MTP is connected

#include <UsbWatcherInternalPSKeys.h>

#include <usbpersonalityids.h>

#include <mtpprivatepskeys.h>

#include <mpxappui.hrh>

#include <mpxinternalcrkeys.h>

#include <mpxtlshelper.h>

#include <mpxuser.h>

#include "mpxcollectionviewhglistboxarray.h"

#include "mpxcommoncontainer.hrh"

#include "mpxcommonuihelper.h"

#include "mpxcollectionviewhgcontainer.h"

#include "mpxcollectionviewhg.hrh"

#include "mpxcollectionviewhg.hlp.hrh"

#include "mpxcollectionviewhgimp.h"

#include "mpxviewprivatepskeys.h"

#include "mpxlog.h"

// CONSTANTS

_LIT( KMPXCollectionRscPath, "mpxcollectionviewhg.rsc" );

const TInt KMilliSecondsToSeconds( 1000 );

const TInt KMPXReorderNaviPaneGranularity( 2 );

const TInt KMPXMaxBufferLength( 160 );

const TInt KMPXMaxTimeLength( 36 );

const TInt KMPXDurationDisplayResvLen( 10 );

const TInt KMPXPlaylistExportRetry( 10 );

const TInt KMPXDirectionUp( -1 );

const TInt KMPXDirectionDown( 1 );

const TInt KMPXErrDataNotReady( -8000 );

const TInt KMPXErrDataNotReadyCacheCommand( -8001 );

const TInt KMPXArrayGranularity( 100 );

const TInt KMusicCollectionMenuLevel( 2 );

_LIT( KMPXCollDetailsItemsFormat, "%S\t%S" );

_LIT( KCategoryEmpty, "" );

const TInt KIncrementalDelayNone = 0;

const TInt KIncrementalDelayHalfSecond = 500000;

const TInt KIncrementalFetchBlockSize = 400;

const TInt KIncrementalDirectionCount = 8;

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

#ifdef __ENABLE_PODCAST_IN_MUSIC_MENU

const TInt KMusicMenuPodcastMenuItemIndex = 4; // podcast menu item index

#define KPodcastCollectionUid 0x101FFC3C

#endif

const TInt KMaxIntLen( 10 );

_LIT8( KMVPrefix, "MVviewID:" );

const TInt KMVPrefixLen( 9 );

// Music setting

const TUid KCRUidMPXMPSettings = {0x101FFCDC};

const TUint32 KMPXMusicStoreUID = 0x00000003;

const TUint32 KOperatorMusicStore = 0x00000004;

const TUint32 KOperatorMusicStoreType = 0x00000005;

const TUint32 KOperatorMusicStoreDisplayName = 0x00000006;

const TUint32 KOperatorMusicStoreNativeUid = 0x00000007;

const TUint32 KOperatorMusicStoreJavaName = 0x00000008;

const TUint32 KOperatorMusicStoreWebPage = 0x00000009;

const TUint32 KOperatorMusicStoreURI = 0x0000000A;

const TUint32 KEducatingUserURI = 0x0000000D;

const TUint32 KEducatingPopupState = 0x0000000E;

const TInt KJavaMusicShopType( 1 );

const TInt KUIDMaxLength = 8;

const TInt KMPXMaxHistoryLength( 255 );

#define KProgressDownloadUid  0x10207BCD

// Music collection browse type

const TInt KMPXCollectionArtistAlbum( 3 );

const TInt KMPXCollectionGenre( 5 );

_LIT(KEmptyTitle, " ");

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

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

// Two-phased constructor.

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

//

CMPXCollectionViewHgImp* CMPXCollectionViewHgImp::NewL()

    {

    MPX_FUNC( "CMPXCollectionViewHgImp::NewL" );

    CMPXCollectionViewHgImp* self = CMPXCollectionViewHgImp::NewLC();

    CleanupStack::Pop( self );

    return self;

    }

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

// Two-phased constructor.

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

//

CMPXCollectionViewHgImp* CMPXCollectionViewHgImp::NewLC()

    {

    CMPXCollectionViewHgImp* self = new ( ELeave ) CMPXCollectionViewHgImp();

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// Destructor

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

//

CMPXCollectionViewHgImp::~CMPXCollectionViewHgImp()

    {

    MPX_FUNC( "CMPXCollectionViewHgImp::~CMPXCollectionViewHgImp" );

    if ( iCoverDisplay )

        {

        delete iCommandInitiator;

        }

    // Cleanup observer, does not panic if not found

    //

    AppUi()->RemoveViewDeactivationObserver( this );

    if ( iCollectionUtility )

        {

        iCollectionUtility->Close();

        }

    if ( iPlaybackUtility )

        {

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

        iPlaybackUtility->Close();

        }

    if ( iViewUtility )

        {

        iViewUtility->RemoveObserver( this );

        iViewUtility->Close();

        }

    if ( iCollectionUiHelper )

        {

        iCollectionUiHelper->Close();

        }

    if ( iCollectionHelper )

        {

        iCollectionHelper->Close();

        }

    if ( iProfileEngine )

        {

        iProfileEngine->Release();

        }

    if ( iUpnpFrameworkSupport )

        {

        MPX_DEBUG1(_L("CMPXCollectionViewHgImp::~CMPXCollectionViewHgImp Detaching 'Copy to external' menu service..."));

        if ( iServiceHandler )

            {

            iServiceHandler->DetachMenu( R_MPX_COLLECTION_VIEW_MENU_1,

                                     R_MPX_UPNP_COPY_TO_EXTERNAL_MENU_INTEREST );

        iServiceHandler->DetachMenu( R_MPX_USE_AS_CASCADE,

                                 R_MPX_AIW_ASSIGN_INTEREST );

            delete iServiceHandler;

            iServiceHandler = NULL;

            }

        iPlayersList.Close();

        delete iSubPlayerName;

        }

    if ( iUpnpCopyCommand )

        {

        delete iUpnpCopyCommand;

        }

    if ( iServiceHandler )

        {

        iServiceHandler->DetachMenu( R_MPX_USE_AS_CASCADE,

                                 R_MPX_AIW_ASSIGN_INTEREST );

        delete iServiceHandler;

        }

    if ( iMediaRecognizer )

        {

        delete iMediaRecognizer;

        }

#ifdef BACKSTEPPING_INCLUDED

    if( iBackSteppingUtility )

        {

        iBackSteppingUtility->Close();

        }

#endif // BACKSTEPPING_INCLUDED

    if ( iResourceOffset )

        {

        iEikonEnv->DeleteResourceFile( iResourceOffset );

        }

    if ( iContainer )

        {

        AppUi()->RemoveFromStack( iContainer );

        delete iContainer;

        }

    if( iTitleWait )

	    {

	    delete iTitleWait;

		}

    delete iUserPlaylists;

    delete iCommonUiHelper;

    delete iSendUi;

    delete iTitle;

    delete iDuration;

    delete iOriginalTitle;

    delete iOriginalDuration;

    delete iNewName;

    delete iBottomIndex;

    delete iCurrentCba;

    delete iIncrementalOpenUtil;

    delete iCachedSelectionIndex;

    FeatureManager::UnInitializeLib();

    delete iOperatorMusicStoreName ;

    if ( iOperatorMusicStoreURI )

        {

        delete iOperatorMusicStoreURI;

        }

    if ( iEducateUserURI )

        {

        delete iEducateUserURI;

        }

    if (iRepository)

        {

        delete iRepository;

        }

    if (iStoredAlbum)

        delete iStoredAlbum;

    }

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

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CMPXCollectionViewHgImp::CMPXCollectionViewHgImp() :

    iLastDepth( 1 ),

    iPlayIndex( KErrNotFound ),

    iSetMediaLCount( KErrNotFound ),

    iCurrentHighlightedIndex( KErrNotFound ),

    iCachedCommand( KErrNotFound ),

    iNoteType( EMPXNoteNotDefined ),

	iFirstIncrementalBatch( ETrue ),

	iDialogDismissed( EFalse ),

	iTitleWait( NULL )

	{

    MPX_FUNC( "CMPXCollectionViewHgImp::CMPXCollectionViewHgImp" );

    iUsingNokiaService = EFalse;

#ifdef __ENABLE_MSK

    iCurrentMskId = KErrNotFound;

    iShowContextMenu = EFalse;

    iCollectionCacheReady = ETrue;

#endif // __ENABLE_MSK

#ifdef __ENABLE_PODCAST_IN_MUSIC_MENU

    iPodcast = EFalse;

#endif // __ENABLE_PODCAST_IN_MUSIC_MENU

    iInAlbumArtDialog = EFalse;

    iMarkedAll = EFalse;

    // grab the current process priority

    RProcess proc;

    iPriority = proc.Priority();

    iGoToNowPlaying = EFalse; 

    }

void CMPXCollectionViewHgImp::HandleStatusPaneSizeChange()

    {

	MPX_FUNC( "CMPXCollectionViewHgImp::HandleStatusPaneSizeChange" );

	CMPXCollectionViewHg::HandleStatusPaneSizeChange();

	if ( iContainer )

        {

		iContainer->SetRect( ClientRect() );

		UpdateTitlePaneL();

        }

    }

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

// Symbian 2nd phase constructor can leave.

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

//

void CMPXCollectionViewHgImp::ConstructL()

    {

    MPX_FUNC( "CMPXCollectionViewHgImp::ConstructL" );

// initialize FeatureManager

    FeatureManager::InitializeLibL();

    if ( FeatureManager::FeatureSupported( KFeatureIdCoverDisplay ) )

        {

        iCoverDisplay = ETrue;

        iCommandInitiator = CMediatorCommandInitiator::NewL( NULL );

        }

    else

        {

        iCoverDisplay = EFalse;

        }

    CCoeEnv* coeEnv( iEikonEnv );

    TParse parse;

    parse.Set( KMPXCollectionRscPath, &KDC_APP_RESOURCE_DIR, NULL );

    TFileName resourceFile( parse.FullName() );

    User::LeaveIfError( MPXUser::CompleteWithDllPath( resourceFile ) );

    BaflUtils::NearestLanguageFile( coeEnv->FsSession(), resourceFile );

    iResourceOffset = coeEnv->AddResourceFileL( resourceFile );

    BaseConstructL( R_MPX_COLLECTION_VIEW );

    iIsEmbedded = iEikonEnv->StartedAsServerApp();

    // create a new collection utility bound to the default context.

    iCollectionUtility = MMPXCollectionUtility::NewL( this, KMcModeDefault );

    iPlaybackUtility = MMPXPlaybackUtility::UtilityL( KPbModeDefault );

    iPlaybackUtility->AddObserverL( *this );

    iViewUtility = MMPXViewUtility::UtilityL();

    iViewUtility->AddObserverL( this );

    iBottomIndex = new (ELeave) CArrayFixFlat<TInt>( 1 );

    iCommonUiHelper = CMPXCommonUiHelper::NewL( iCollectionUtility );

    iCollectionUiHelper = CMPXCollectionHelperFactory::NewCollectionUiHelperL();

    // Monitor for view activation

    AppUi()->AddViewActivationObserverL( this );

    if (!iUpnpCopyCommand )

        {

        MPX_TRAPD ( error, iUpnpCopyCommand = CUpnpCopyCommand::NewL() );

		    if ( error == KErrNone )

            {

            iUpnpFrameworkSupport = ETrue;

            iServiceHandler = CAiwServiceHandler::NewL();

            MPX_DEBUG1("CMPXCollectionViewHgImp::ConstructL() Attaching 'Copy to external' menu service...");

            MPX_TRAP( iErrorAttachCopyMenu, iServiceHandler->AttachMenuL( R_MPX_COLLECTION_VIEW_MENU_1,

                                                   R_MPX_UPNP_COPY_TO_EXTERNAL_MENU_INTEREST ) );

            if ( iErrorAttachCopyMenu == KErrNotSupported )

                {

                // when CCoeEnv is not available

                User::Leave( iErrorAttachCopyMenu );

                }

            MPX_DEBUG2( "CMPXCollectionViewHgImp::ConstructL(): attach Copy menu error: %d", iErrorAttachCopyMenu );

            }

        else

            {

            iUpnpFrameworkSupport = EFalse;

            iUpnpCopyCommand = NULL;

            }

        }

    iMediaRecognizer = CMediaRecognizer::NewL();

    if ( iServiceHandler == NULL)

        {

        iServiceHandler = CAiwServiceHandler::NewL();

        }

    MPX_DEBUG1("CMPXCollectionViewHgImp::ConstructL() Attaching 'use tone as' menu service...");

    MPX_TRAP( iErrorAttachAssignMenu, iServiceHandler->AttachMenuL( R_MPX_USE_AS_CASCADE,

                                               R_MPX_AIW_ASSIGN_INTEREST ) );

    TInt flags( 0 );

    CRepository* repository = CRepository::NewL( KCRUidMPXMPFeatures );

    repository->Get( KMPXMPLocalVariation, flags );

    delete repository;

    iGoToMusicShopOptionHidden =

        !static_cast<TBool>( flags & KMPXEnableGoToMusicShopOption );

    iUsingNokiaService =

        static_cast<TBool>( flags & KMPXEnableFindInMusicShopOption );

    MPX_DEBUG2( "CMPXCollectionViewHgImp::ConstructL(): iUsingNokiaService: %d", iUsingNokiaService );

    iDisablePodcasting = flags&KMPXDisablePodcastingOption ? ETrue : EFalse;

#ifdef _DEBUG

    iExitOptionHidden = EFalse;

#else // _DEBUG

    iExitOptionHidden = iCommonUiHelper->ExitOptionHiddenL() && !iIsEmbedded;

#endif // _DEBUG

    iBottomIndex->AppendL( 0 );

    iProfileEngine = CreateProfileEngineL();

    _LIT_SECURITY_POLICY_C1(KMPlayerRemoteReadPolicy, ECapabilityReadUserData);

    _LIT_SECURITY_POLICY_C1(KMPlayerRemoteWritePolicy, ECapabilityWriteUserData);

    if (iGoToMusicShopOptionHidden)

        {

        iMusicStoreUID = 0;

        }

    else

        {

        // Get music store uid from cenrep

        //

        TBuf8< KUIDMaxLength > musicStoreUID;

        TRAP_IGNORE(

            {

            CRepository* repository = CRepository::NewL( KCRUidMPXMPSettings );

            repository->Get( KMPXMusicStoreUID, musicStoreUID );

            delete repository;

            repository = NULL;

            } );

        GetUint32Presentation( iMusicStoreUID, musicStoreUID, 0 );

        if (iMusicStoreUID == 0)

            {

            iGoToMusicShopOptionHidden = ETrue;

            }

        }

    MPX_DEBUG2("CMPXCollectionViewHgImp::ConstructL musicStoreUID = %x", iMusicStoreUID);

    TInt retval(KErrNone);

    // P/S key for music shop

    retval = RProperty::Define( TUid::Uid(iMusicStoreUID),

                                KMShopCategoryId,

                                RProperty::EInt,

                                KMPlayerRemoteReadPolicy,

                                KMPlayerRemoteWritePolicy );

    if( retval != KErrAlreadyExists)

        {

        RProperty::Set( TUid::Uid(iMusicStoreUID),

                        KMShopCategoryId,

                        KFindInMShopKeyInValid );  // initialize Find In Musicshop was not called

        RProperty::Define(  TUid::Uid(iMusicStoreUID),

                            KMShopCategoryName,

                            RProperty::ELargeText,

                            KMPlayerRemoteReadPolicy,

                            KMPlayerRemoteWritePolicy );