/*

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

*

*/

// INCLUDE FILES

#include <e32cmn.h>

#include <e32math.h>

#include <s32file.h>

#include <gulicon.h>

#include <hlplch.h>

#include <StringLoader.h>

#include <aknview.h>

#include <aknappui.h>

#include <AknIconArray.h>

#include <aknlists.h>

#include <aknPopup.h>

#include <akncontext.h>

#include <AknsBasicBackgroundControlContext.h>

#include <data_caging_path_literals.hrh>

#include <mpxlog.h>

#include <mpxuser.h>

#include <mpxmedia.h>

#include <mpxmediaarray.h>

#include <mpxconstants.h>

#include <mpxmediageneraldefs.h>

#include <mpxplaybackframeworkdefs.h>

#include <mpxmediacontainerdefs.h>

#include <mpxmediageneraldefs.h>

#include <mpxmediamusicdefs.h>

#include <mpxmediacollectiondetaildefs.h>

#include <mpxcommandgeneraldefs.h>

#include <mpxpodcastdefs.h>

#include <mpxcommonuihelper.h>

#include <mpxcollectionplaylist.h>

#include <mpxcollectionuihelper.h>

#include <mpxcollectionhelperfactory.h>

#include <mpxcollectionutility.h>

#include <mpxcollectionpath.h>

#include <mpxplaybackutility.h>

#include <mpxcollectionviewhg.rsg>

#include <mpxcollectionviewhg.mbg>

#include <mpxappui.hrh>

#include <ganes/HgDoubleGraphicListFlat.h>

#include <ganes/HgSingleGraphicList.h>

#include <ganes/HgSingleTextListWithIcon.h>

#include <ganes/HgVgItem.h>

#include <ganes/HgItem.h>

#include <ganes/HgScrollerWithTitle.h>

#include <ganes/HgVgMediaWall.h>

#include <layoutmetadata.cdl.h>

#include "mpxcommoncontainer.hrh"

#include "mpxcollectionviewhg.hrh"

#include "mpxcollectionviewhglistboxarray.h"

#include "mpxcollectionviewhg.hlp.hrh"

#include "mpxcollectionviewhgcontainer.h"

#include "mpxcollectionviewhgplaylisthelper.h"

#include "mpxcollectionviewhgtnloader.h"

#include "mpxcbahandler.h"

// CONSTANTS

_LIT( KMPXCollectionViewRscPath, "mpxcollectionviewhg.rsc" );

_LIT( KMPXCollectionViewIconFile, "mpxcollectionviewhg.mbm" );

const TInt KMPXListSelectionCount = 5;

const TInt KMPXMinSecSeparatorIndex = 2;

const TInt KOneHourInSeconds = 3600;

const TInt KMPXTimeIndicatorLength = 16;

#ifdef __WINS__

const TInt KMPXListBufferSize = 20;

#else

const TInt KMPXListBufferSize = 400;

#endif

// Added by Harri. Buffer size has to be smaller with mediawall, otherwise IVE3 runs out of memory

#ifdef __WINS__

const TInt KMPXListBufferSizeWithMediaWall = 20;

#else

const TInt KMPXListBufferSizeWithMediaWall = 80;

#endif

const TInt KMPXMaxFileLength = 256;

const TReal KIconFactor = 0.7;

_LIT( KMPXDash, " - " );

#ifdef HG_MP_LOC_AVAILABLE

_LIT( KMPXSpace, " ");

#endif //HG_MP_LOC_AVAILABLE

_LIT( KMPXZeroDurationMark, "--");

_LIT( KSong, " song" );

_LIT( KSongs, " songs" );

_LIT( KEpisode, " episode" );

_LIT( KEpisodes, " episodes" );

_LIT( KAlbum, " album" );

_LIT( KAlbums, " albums" );

_LIT( KSongDash, " song - " );

_LIT( KSongsDash, " songs - " );

_LIT( KMPXDriveC, "c:" );

_LIT( KMPXSelectedAlbumItemFileName, "mpxalbumitem.dat");

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

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

// Two-phased constructor.

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

//

CMPXCollectionViewHgContainer* CMPXCollectionViewHgContainer::NewL(

    MEikCommandObserver* aView,

    MEikListBoxObserver* aObserver,

    TBool aIsEmbedded)

    {

    MPX_FUNC( "CMPXCollectionViewHgContainer::NewL" );

    CMPXCollectionViewHgContainer* self =

        new ( ELeave ) CMPXCollectionViewHgContainer(aView, aObserver, aIsEmbedded);

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

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

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

//

CMPXCollectionViewHgContainer::CMPXCollectionViewHgContainer(

    MEikCommandObserver* aView,

    MEikListBoxObserver* aObserver,

    TBool aIsEmbedded) :

	iView( aView ),

	iListBoxObserver( aObserver ),

	iReady( EFalse ),

	iIsEmbedded(aIsEmbedded),

	iCurrentDefaultIcon( EMPXDefaultIconNotSet ),

	iContext( EContextUnknown ),

	iTopIndex( 0 ),

	iBottomIndex( KErrNotFound ),

	iAlbumIndex(KErrNotFound),

	iSelectedAlbumIndex(KErrNotFound),

	iRestoredAlbumIndex(KErrNotFound)

    {

    }

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

// Destructor

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

//

CMPXCollectionViewHgContainer::~CMPXCollectionViewHgContainer()

    {

    MPX_FUNC( "CMPXCollectionViewHgContainer::~CMPXCollectionViewHgContainer" );

    delete iSongTitle;

    delete iAlbumTitle;

    if ( iResourceOffset )

        {

        iEikonEnv->DeleteResourceFile( iResourceOffset );

        }

    delete iListSelections;

    delete iListBoxArray;

    delete iIconArray;

    delete iMediaWall;

    delete iMwListWidget;

    delete iListWidget;

    delete iOrigIcon;

    delete iCommonUiHelper;

    CancelTNRequest();

    iThumbnailReqMap.Close();

    delete iThumbnailManager;

    delete iBgContext;

    delete iSelectedMediaInAlbumView;

    if ( iCollectionUtility )

        {

        iCollectionUtility->Close();

        }

    if ( iCollectionUiHelper)

         {

         iCollectionUiHelper->Close();

         }

    if ( iPlaybackUtility )

        {

        iPlaybackUtility->Close();

        }

    delete iPlaylist;

    delete iPlaylistHelper;

    if( iAsyncCallBack )

        {

        iAsyncCallBack->Cancel();

        }

    delete iAsyncCallBack;

    iCoeEnv->RemoveForegroundObserver( *this );

    }

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

// Symbian 2nd phase constructor can leave.

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

//

void CMPXCollectionViewHgContainer::ConstructL()

    {

    MPX_FUNC( "CMPXCollectionViewHgContainer::ConstructL" );

    CCoeEnv* coeEnv( iEikonEnv );

    TParse parse;

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

    TFileName resourceFile( parse.FullName() );

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

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

    iResourceOffset = coeEnv->AddResourceFileL( resourceFile );

    iAlbumTitle = StringLoader::LoadL( R_MPX_COLLECTION_DETAILS_ONE_ALBUM );

    iSongTitle = StringLoader::LoadL( R_MPX_COLLECTION_DETAILS_ONE_SONG );

    if ( !iCollectionUiHelper )

        {

        iCollectionUiHelper = CMPXCollectionHelperFactory:: NewCollectionUiHelperL();

        }

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

    iPlaybackUtility = MMPXPlaybackUtility::UtilityL( KPbModeDefault );

    iPlaylistHelper = CMPXCollectionViewHgPlaylistHelper::NewL(iPlaybackUtility, iCollectionUiHelper);

    TRect mainPane( 0,0,0,0 );

    iBgContext = CAknsBasicBackgroundControlContext::NewL( KAknsIIDQsnBgScreen, mainPane, ETrue);

    iBgContext->SetRect(((CAknAppUi*)iCoeEnv->AppUi())->ApplicationRect());

    // Common methods used for 2-line list support

    iCommonUiHelper = CMPXCommonUiHelper::NewL();

    iListSelections = new (ELeave) CArrayFixFlat<TInt>( KMPXListSelectionCount );

    iThumbnailManager = CMpxTNLoader::NewL( *this, EAudioListThumbnailSize );

    iImageSize = CHgDoubleGraphicListFlat::PreferredImageSize();

    TFileName pathWithoutDrive;

    iEikonEnv->FsSession().PrivatePath( pathWithoutDrive );

    iSelectedAlbumItemFileName.Copy( KMPXDriveC );

    iSelectedAlbumItemFileName.Append( pathWithoutDrive );

    iSelectedAlbumItemFileName.Append( KMPXSelectedAlbumItemFileName );

    iListBoxArray = static_cast<CMPXCollectionViewListBoxArray*>(

        CreateListBoxArrayL() );

    CreateIconArrayL();

    iIsForeground = ETrue;

    iCoeEnv->AddForegroundObserverL( *this );

    TCallBack callback(CMPXCollectionViewHgContainer::AsyncCallback, this);

    iAsyncCallBack = new (ELeave) CAsyncCallBack( CActive::EPriorityStandard );

    iAsyncCallBack->Set(callback);

    CreateWindowL();

    ActivateL();

    }

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

// CMPXCollectionViewHgContainer::MopSupplyObject

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

//

TTypeUid::Ptr CMPXCollectionViewHgContainer::MopSupplyObject( TTypeUid aId )

	{

    MPX_FUNC( "CMPXCollectionViewHgContainer::MopSupplyObject" );

	return MAknsControlContext::SupplyMopObject(aId, iBgContext );

	}

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

// Sets playback status

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

//

void CMPXCollectionViewHgContainer::SetPlaybackStatusByIdL(

    TMPXItemId aId, TMPXPlaybackState aStatus, TInt aIndex)

    {

    MPX_FUNC( "CMPXCollectionViewHgContainer::SetPlaybackStatusByIdL" );

    if ( iListBoxArray )

        {

        TInt index( iListBoxArray->SetPlaybackStatusByIdL( aId, aStatus, aIndex ) );

        if ( index != KErrNotFound )

            {

            // Update the previous item as not playing anymore

            DrawLbxItemL( index );

            }

        index = iListBoxArray->GetPlaybackIndex();

        if ( index != KErrNotFound )

            {

            // Update new item as playing

            DrawLbxItemL( index );

            }

        }

    }

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

// Get playback index

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

//

TInt CMPXCollectionViewHgContainer::PlaybackIndex()

    {

    MPX_FUNC( "CMPXCollectionViewHgContainer::PlaybackIndex" );

    return ( iListBoxArray ? iListBoxArray->GetPlaybackIndex() : KErrNotFound );

    }

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

// Activate reorder mode

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

//

void CMPXCollectionViewHgContainer::ActivateReorderMode( TBool aEnable )

    {

    MPX_FUNC( "CMPXCollectionViewHgContainer::ActivateReorderMode" );

    if ( iListBoxArray )

        {

        iReorder = aEnable;

        iListBoxArray->ActivateReorderMode( iReorder );

        }

    }

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

// Set reorder mode

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

//

void CMPXCollectionViewHgContainer::SetReorderGrabbedMode(

    TBool aEnable, TInt aIndex )

    {

    MPX_FUNC( "CMPXCollectionViewHgContainer::SetReorderGrabbedMode" );

    if ( iListBoxArray )

        {

        iListBoxArray->SetReorderGrabbedMode( aEnable, aIndex );

        }

    }

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

// Determines if it's currently in reorder mode

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

//

TBool CMPXCollectionViewHgContainer::IsInReorderMode()

    {

    MPX_FUNC( "CMPXCollectionViewHgContainer::IsInReorderMode" );

    return iReorder;

    }

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

// Move current reorder index

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

//

void CMPXCollectionViewHgContainer::MoveReorderIndex( TInt aDirection )

    {

    MPX_FUNC( "CMPXCollectionViewHgContainer::MoveReorderIndex" );

    if ( iListBoxArray )

        {

        iListBoxArray->MoveReorderIndex( aDirection );

        }

    }

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

// set current reorder index

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

//

void CMPXCollectionViewHgContainer::SetReorderIndex( TInt aIndex )

    {

    MPX_FUNC( "CMPXCollectionViewHgContainer::SetReorderIndex" );

    if ( iListBoxArray )

        {

        iListBoxArray->SetReorderIndex( aIndex );

        }

    }

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

// Confirm reorder

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

//

void CMPXCollectionViewHgContainer::ConfirmReorderL()

    {

    MPX_FUNC( "CMPXCollectionViewHgContainer::ConfirmReorderL" );

    if ( iListBoxArray )

        {

        iListBoxArray->ConfirmReorderL();

        }

    }

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

// Cancel reorder

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

//

void CMPXCollectionViewHgContainer::CancelReorder()

    {

    MPX_FUNC( "CMPXCollectionViewHgContainer::CancelReorder" );

    TInt originalIndex( GetOriginalIndex() );

    if ( iListBoxArray )

        {

        iListBoxArray->CancelReorder();

        }

    SetLbxCurrentItemIndexAndDraw( originalIndex );

    }

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

// Gets original index of currently selected item

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

//

TInt CMPXCollectionViewHgContainer::GetOriginalIndex()

    {

    MPX_FUNC( "CMPXCollectionViewHgContainer::GetOriginalIndex" );

    TInt index( KErrNotFound );

    if ( iListBoxArray )

        {

        index = iListBoxArray->GetOriginalIndex();

        }

    return index;

    }

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

// Update Titlepane icon to reorder image

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

//

void CMPXCollectionViewHgContainer::UpdateReorderTitleIconL()

    {

    MPX_FUNC( "CMPXCollectionViewHgContainer::UpdateReorderTitleIconL" );

    // For status changes

    CEikStatusPane* sp = iAvkonAppUi->StatusPane();

    TParse parse;

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

    TFileName iconFile( parse.FullName() );

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

    MAknsSkinInstance* skin( AknsUtils::SkinInstance() );

    CFbsBitmap* bitmap( NULL );

    CFbsBitmap* mask( NULL );

    AknsUtils::CreateIconLC(

        skin,

        KAknsIIDNone,

        bitmap,

        mask,

        iconFile,

        EMbmMpxcollectionviewhgQgn_graf_mup_ctx_reordersong,

        EMbmMpxcollectionviewhgQgn_graf_mup_ctx_reordersong_mask );

    CEikImage* newIcon = new ( ELeave ) CEikImage();

    CleanupStack::PushL( newIcon );

    newIcon->SetPicture( bitmap, mask );

    newIcon->SetPictureOwnedExternally( EFalse );

    iContextPane = static_cast<CAknContextPane*>

        ( sp->ControlL( TUid::Uid( EEikStatusPaneUidContext ) ) );

    if ( iOrigIcon )

        {

        delete iOrigIcon;

        }

    iOrigIcon = iContextPane->SwapPicture( newIcon );

    CleanupStack::Pop( 3 ); // bitmap, mask, newIcon

    }

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

// Update Titlepane icon to use original image

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

//

void CMPXCollectionViewHgContainer::RestoreOriginalTitleIconL()

    {

    MPX_FUNC( "CMPXCollectionViewHgContainer::RestoreOriginalTitleIconL" );

    if ( iOrigIcon )

        {

        CEikImage* newIcon = iContextPane->SwapPicture( iOrigIcon );

        delete newIcon;

        iOrigIcon = NULL; 

        }

    }

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

// Creates listbox array

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

//

CMPXCommonListBoxArrayBase* CMPXCollectionViewHgContainer::CreateListBoxArrayL()

    {

    MPX_FUNC( "CMPXCollectionViewHgContainer::CreateListBoxArrayL" );

    CMPXCollectionViewListBoxArray* array = CMPXCollectionViewListBoxArray::NewL();

    array->ConstructListBoxArrayL();

    array->SetObserver( this );

    return array;

    }

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

// From CCoeControl

// Handles key events.

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

//

TKeyResponse CMPXCollectionViewHgContainer::OfferKeyEventL(

    const TKeyEvent& aKeyEvent,

    TEventCode aType )

    {

    MPX_DEBUG4( "CMPXCollectionViewHgContainer::HandleKeyEventL(iCode=%d, iScanCode=%d, aType=%d)",

        aKeyEvent.iCode, aKeyEvent.iScanCode, aType );

    if ( aKeyEvent.iCode == EKeyUpArrow ||

        aKeyEvent.iCode == EKeyPrevious )

        {

        iView->ProcessCommandL( EMPXCmdUpArrow );

        }

    else if ( aKeyEvent.iCode == EKeyDownArrow ||

            aKeyEvent.iCode == EKeyNext )

        {

        iView->ProcessCommandL( EMPXCmdDownArrow );

        }

    TKeyResponse response = EKeyWasNotConsumed;

    if( iReady )

        {

        const CMPXMedia& containerMedia(iListBoxArray->ContainerMedia() );

        TMPXGeneralType containerType(

            containerMedia.ValueTObjectL<TMPXGeneralType>(