/*

* 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:  Application UI class required by AVKON application architecture.

*

*/

// INCLUDE FILES

#include <barsread.h>

#include <StringLoader.h>

#include <AknIconArray.h>

#include <gulicon.h>

#include <featmgr.h>

#include <aknsfld.h>

#include <AknUtils.h>

#include <aknlists.h>

#include <aknconsts.h>

#include <avkon.mbg>

#include <eikclbd.h>

#include <eikcmobs.h>

#include <bautils.h>

#include <AknsBasicBackgroundControlContext.h>

#include <s32file.h>

#include <ganes/HgDoubleGraphicList.h>

#include <ganes/HgSingleGraphicList.h>

#include <ganes/HgItem.h>

#include <ganes/HgScrollerWithTitle.h>

#include <data_caging_path_literals.hrh>

#include <mpxlog.h>

#include <mpxuser.h>

#include <mpxmedia.h>

#include <mpxmediaarray.h>

#include <mpxmediageneraldefs.h>

#include <mpxmediamusicdefs.h>

#include <mpxcommonuihelper.h>

#include <mpxpodcastdefs.h>

#include <mpxcommoncontainer.rsg>

#include <mpxcollectionview.rsg>

#include "mpxcommonlistboxarraybase.h"

#include "mpxcommoncontainermediahelper.h"

#include "mpxcommoncontainertexturemanager2.h"

#include "mpxcommoncontainerhgimp.h"

#include "mpxcommoncontainer.hrh"

#include <thumbnaildata.h>

#include <thumbnailobjectsource.h>

#include <aknview.h>

// CONSTANTS

_LIT( KMPXCommonContainerRscPath, "mpxcommoncontainer.rsc" );

const TInt KMPXListSelectionCount = 5;

const TInt KMPXMinSecSeparatorIndex = 2;

const TInt KOneHourInSeconds = 3600;

const TInt KMPXTimeIndicatorLength = 16;

const TInt KMPXListBufferSize = 400;

const TInt KMPXMaxFileLength = 256;

const TReal KIconFactor = 0.7;

const int KMaxThumbnailReq = 100;

_LIT( KMPXDash, " - " );

#ifdef HG_MP_LOC_AVAILABLE

_LIT( KMPXSpace, " ");

#endif //HG_MP_LOC_AVAILABLE

_LIT( KMPXZeroDurationMark, "--");

//_LIT( KMPXAlbumMimeType, "image/jpeg" );

_LIT( KMPXAlbumMimeType, "audio/mpeg3" );

//#ifndef HG_MP_LOC_AVAILABLE

_LIT( KUnknown, "Unknown" );

_LIT( KSong, " song" );

_LIT( KSongs, " songs" );

_LIT( KEpisode, " episode" );

_LIT( KEpisodes, " episodes" );

_LIT( KAlbum, " album" );

_LIT( KAlbums, " albums" );

_LIT( KSongDash, " song - " );

_LIT( KSongsDash, " songs - " );

//#endif //HG_MP_LOC_AVAILABLE

_LIT( KMPXDriveC, "c:" );

_LIT( KMPXSelectedAlbumItemFileName, "mpxalbumitem.dat");

#define DSA_PARAM NULL

//#define DSA_PARAM &iEikonEnv->WsSession()

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

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

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

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

//

CMPXCommonContainerHgImp::CMPXCommonContainerHgImp() :

    iContext( EContextUnknown ),

    iTopIndex( 0 ),

    iBottomIndex( KErrNotFound ),

    iCurrentDefaultIcon( EMPXDefaultIconNotSet ),

    iRequestCount( 0 ),

    iAlbumArtRequest(NULL),

    iRequestQueue(_FOFF( TAlbumArtRequest, iLink )),

    iQueueCounter(0)

    {

    }

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

// Destructor

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

//

CMPXCommonContainerHgImp::~CMPXCommonContainerHgImp()

    {

    MPX_FUNC( "CMPXCommonContainerHgImp::~CMPXCommonContainerHgImp" );

    delete iEpisodeTitle;

    delete iSongTitle;

    delete iAlbumTitle;

    if ( iResourceOffset )

        {

        iEikonEnv->DeleteResourceFile( iResourceOffset );

        }

    delete iListSelections;

    delete iListBoxArray;

    delete iIconArray;

    if ( iScrollerWithTitle )

        {

//	    delete iListWidget;

        delete iScrollerWithTitle;

        if ( iPrevListWidget )

            {

	        delete iPrevListWidget;

            }

        }

    else

        {

	    delete iListWidget;

	    }

 ///   delete iTextureManager;

    delete iCommonUiHelper;

    CancelTNRequest();

    iThumbnailReqHashMap.Close();

    iThumbnailReqMap.Close();

    delete iThumbnailManager;

    delete iBgContext;

    delete iSelectedMediaInAlbumView;

    CleanAlbumArtReqQueue();

    }

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

// Return Coe Control

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

//

CCoeControl* CMPXCommonContainerHgImp::CoeControl()

    {

    MPX_FUNC( "CMPXCommonContainerHgImp::CoeControl" );

    return this;

    }

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

// Set View Container

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

//

void CMPXCommonContainerHgImp::SetViewContainer(

    MMPXViewContainer* aViewContainer )

    {

    MPX_FUNC( "CMPXCommonContainerHgImp::SetViewContainer" );

    iViewContainer = aViewContainer;

    }

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

// Set command observer for the container

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

//

void CMPXCommonContainerHgImp::SetCommandObserver(

    MEikCommandObserver* aCommandObserver )

    {

    MPX_FUNC( "CMPXCommonContainerHgImp::SetCommandObserver" );

    iView = aCommandObserver;

    }

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

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

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

//

void CMPXCommonContainerHgImp::SetListBoxObserver(

    MEikListBoxObserver* aListBoxObserver )

    {

    MPX_FUNC( "CMPXCommonContainerHgImp::SetListBoxObserver" );

    iListBoxObserver = aListBoxObserver;

    }

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

// Set layout for all elements and set sizes for icons.

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

//

void CMPXCommonContainerHgImp::UpdateLayout()

    {

    MPX_FUNC( "CMPXCommonContainerHgImp::UpdateLayout" );

    }

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

// Returns a pointer to the listboxarray

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

//

CMPXCommonListBoxArrayBase* CMPXCommonContainerHgImp::ListBoxArray() const

    {

    return iListBoxArray;

    }

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

// Sets listbox array

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

//

void CMPXCommonContainerHgImp::SetListBoxArrayL(

    CMPXCommonListBoxArrayBase* aListBoxArray )

    {

    MPX_FUNC( "CMPXCommonContainerHgImp::SetListBoxArrayL" );

    iListBoxArray = aListBoxArray;

    }

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

// Return number of listbox items shown in the current listbox.

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

//

TInt CMPXCommonContainerHgImp::CurrentListItemCount() const

    {

    MPX_FUNC( "CMPXCommonContainerHgImp::CurrentListItemCount" );

    TInt count = 0;

    if ( iListWidget )

        {

        count = iListWidget->ItemCount();

        }

    return count;

    }

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

// Return total number of listbox items in the listbox.

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

//

TInt CMPXCommonContainerHgImp::TotalListItemCount() const

    {

    MPX_FUNC( "CMPXCommonContainerHgImp::TotalListItemCount" );

    TInt count = 0;

    if ( iListBoxArray )

        {

        count = iListBoxArray->MediaArray().Count();

        }

    return count;

    }

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

// Gets top listbox item index (relative to the original listbox).

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

//

TInt CMPXCommonContainerHgImp::TopLbxItemIndex() const

    {

    MPX_FUNC( "CMPXCommonContainerHgImp::TopLbxItemIndex" );

    return iTopIndex;

    }

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

// Gets bottom listbox item index (relative to the original listbox).

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

//

TInt CMPXCommonContainerHgImp::BottomLbxItemIndex() const

    {

    MPX_FUNC( "CMPXCommonContainerHgImp::BottomLbxItemIndex" );

    return iBottomIndex;

    }

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

// Gets current listbox item index (relative to the original listbox).

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

//

TInt CMPXCommonContainerHgImp::CurrentLbxItemIndex() const

    {

    MPX_FUNC( "CMPXCommonContainerHgImp::CurrentLbxItemIndex" );

	TInt index( KErrNotFound );

    if ( iListWidget )

		{

		const TInt count = CurrentListItemCount();

		if ( count > 0 )

			{

			index = iListWidget->SelectedIndex();

			}

		}

    return index;

    }

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

// Get current selected listbox items indices (relative to the original listbox)

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

//

const CArrayFix<TInt>* CMPXCommonContainerHgImp::CurrentSelectionIndicesL() const

    {

    MPX_FUNC( "CMPXCommonContainerHgImp::CurrentSelectionIndicesL" );

    if ( iListWidget )

		{

		iListSelections->Reset();

		RArray<TInt> selectionArray;

        CleanupClosePushL( selectionArray );

		iListWidget->GetMarkedItemsL(selectionArray);

		int count = selectionArray.Count();

		for( int i = 0; i < count; i++ )

			{

			iListSelections->AppendL( selectionArray[i] );

			}

        CleanupStack::PopAndDestroy( &selectionArray );

		}

    return iListSelections;

    }

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

// Set current selected listbox items indices (relative to the original listbox)

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

//

void CMPXCommonContainerHgImp::SetCurrentSelectionIndicesL(

    CArrayFix<TInt>* aIndices ) const

    {

    MPX_FUNC( "CMPXCommonContainerHgImp::SetCurrentSelectionIndicesL" );

    TInt count = aIndices->Count();

    if ( count > 0 && iListWidget )

        {

        for( TInt i = 0; i < count; i++ )

            {

            iListWidget->Mark( (*aIndices)[i] );

            }

        iListWidget->RefreshScreen( (*aIndices)[0] );

        }

    }

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

// Set top listbox item index.

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

//

void CMPXCommonContainerHgImp::SetLbxTopItemIndex( TInt /*aIndex*/ )

    {

    MPX_FUNC( "CMPXCommonContainerHgImp::SetLbxTopItemIndex" );

    }

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

// Set current listbox item index.

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

//

void CMPXCommonContainerHgImp::SetLbxCurrentItemIndex( TInt aIndex )

    {

    MPX_FUNC( "CMPXCommonContainerHgImp::SetLbxCurrentItemIndex" );

    if ( iListWidget )

        {

        iListWidget->SetSelectedIndex( aIndex );

        }

    }

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

// Set current listbox item index and highlight it.

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

//

void CMPXCommonContainerHgImp::SetLbxCurrentItemIndexAndDraw(

    TInt aIndex )

    {

    MPX_FUNC( "CMPXCommonContainerHgImp::SetLbxCurrentItemIndexAndDraw" );

	SetLbxCurrentItemIndex(aIndex);

    }

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

// Clear listbox selection.

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

//

void CMPXCommonContainerHgImp::ClearLbxSelection()

    {

    MPX_FUNC( "CMPXCommonContainerHgImp::ClearLbxSelection" );

    if ( iListWidget )

        {

        iListWidget->UnMarkAll();

        }

    }

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

// Sets the text for an empty list box

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

//

void CMPXCommonContainerHgImp::SetLbxEmptyTextL( const TDesC& aText )

    {

    MPX_FUNC( "CMPXCommonContainerHgImp::SetLbxEmptyTextL" );

    if ( iListWidget && aText != KNullDesC )

        {

        iListWidget->SetEmptyTextL( aText );

        }

    }

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

// Draws a list box item

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

//

void CMPXCommonContainerHgImp::DrawLbxItemL( TInt aIndex )

    {

    MPX_DEBUG2( "CMPXCommonContainerHgImp::DrawLbxItemL (aIndex=%d)", aIndex );

    if ( iListWidget && iBottomIndex > 0 )

        {

        CHgItem* item = &iListWidget->ItemL(aIndex);

        SetDetailIndicatorL(item, aIndex);

        iListWidget->RefreshScreen(aIndex);

        }

    }

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

// Set Find box's focus.

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

//

void CMPXCommonContainerHgImp::SetFindBoxFocus( TBool /*aFocus*/ )

    {

    MPX_FUNC( "CMPXCommonContainerHgImp::SetFindBoxFocus" );

    }

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

// Handle listbox item addition.

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

//

void CMPXCommonContainerHgImp::HandleLbxItemAdditionL()

    {

    MPX_FUNC( "CMPXCommonContainerHgImp::HandleLbxItemAdditionL" );

    SetCollectionContextL();

    iLastValidMediaItemIndex = 0;

    if ( iListWidget )

        {

        const CMPXMediaArray& mediaArray = iListBoxArray->MediaArray();

        const TInt count( mediaArray.Count() );

        MPX_DEBUG2( "CMPXCommonContainerHgImp::HandleLbxItemAdditionL count=%d", count);

        HandleLbxItemRemovalL();

		iThumbnailReqMap.Reset();

		for ( TInt i = 0; i < count; i++ )

			{

    		iThumbnailReqMap.Append( EFalse );

			}

        if ( iContext == EContextItemAlbum && iContext != iPrevContext )

            {

            // Save previous list so won't cause flickering when back.

            // If album view comes back again, we don't want to delete

            // title_list so skip this block for the same album track view.

            //iListWidget->SetFlags( CHgScroller::EHgScrollerScreenFreeze );

            iListWidget->Reset();

            iListWidget->SetFocus(EFalse);

            // this is needed to make list passive when we switch to list with title

            iListWidget->DisableScrollBuffer();

            iPrevListWidget = iListWidget;

            iListWidget = NULL;

            CreateListBoxWithTitleL( count );

            ProvideDataWithoutThumbnailsL(mediaArray);

            iListWidget->SetFocus(ETrue);

            }

        else

            {

            if ( iScrollerWithTitle && iContext != EContextItemAlbum )

                {

                // Delete title_list when you are not in album_track view

                delete iScrollerWithTitle;

                iScrollerWithTitle = NULL;

                iListWidget = iPrevListWidget;

                // this is needed to make list active when we switch from list with title

                iListWidget->EnableScrollBufferL(*this, KMPXListBufferSize, KMPXListBufferSize/4);

                iListWidget->Reset();

                iListWidget->SetFocus(ETrue);

           	    iListWidget->ResizeL( count );

                ProvideDataWithoutThumbnailsL(mediaArray);

                }

            else

                {

				TInt index = iListWidget->SelectedIndex();

        	    iListWidget->Reset();

            	if ( count )

            	    {

            	    iListWidget->ResizeL( count );

            	    ProvideDataWithoutThumbnailsL(mediaArray);

                    iListWidget->SetSelectedIndex( index );

            	    }