/*

* Copyright (c) 2002-2004 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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:  Associate list box text array with array of downloads.

*

*/

// INCLUDE FILES

#include    "CDownloadsListArray.h"

#include    "ProgressInfoCreator.h"

#include    "DMgrUiLibPanic.h"

#include    "UiLibLogger.h"

#include    <DownloadMgrUiLib.rsg>

#include    <DownloadMgrUiLib.mbg>

#include    <gulicon.h>

#include    <coemain.h>

#include    <apgcli.h>

#include    <apgicnfl.h>

#include    <data_caging_path_literals.hrh>

#include    <f32file.h>

#include    <AknsUtils.h>

#include    <DocumentHandler.h>

#include    <MediaGalleryUid.h>

#include    "CDownloadUtils.h"

#include    <HttpDownloadMgrCommon.h>

#include    "CUserInteractionsUtils.h"

// LOCAL CONSTANTS AND MACROS

LOCAL_D const TInt KArrayGranularity = 16;

_LIT( KCharTab, "\t" );

_LIT( KDownloadMgrUiLibMbmFileNameAndDriveZ, "Z:DownloadMgrUiLib.mbm");

_LIT( KIndexString, "%d/%d  " );

const TInt KMaxIndexStringLength = 16;

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

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

// TDownloadUiData::TDownloadUiData

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

//

TDownloadUiData::TDownloadUiData()

:   iName( KNullDesC ),

	iDestFileName( KNullDesC ),

    iContentType( KNullDesC8 ),

    iDownloadState( KErrNotFound ),

    iFullSize( KErrNotFound ),

    iDownloadedSize( KErrNotFound ),

    iIconIndex( KErrNotFound ),

    iPausable( EFalse ),

    iIsOnExternalMemory( EFalse ),

    iProgressState( KErrNotFound ),

    iNumMediaObjects( KErrNotFound )

    {

    }

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

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

// CDownloadsListArray::CDownloadsListArray

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

//

CDownloadsListArray::CDownloadsListArray()

:   iCoeEnv( *CCoeEnv::Static() ),

    {

    }

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

// CDownloadsListArray::ConstructL

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

//

void CDownloadsListArray::ConstructL()

    {

    CLOG_ENTERFN("CDownloadsListArray::ConstructL");

    iDownloadArray = new (ELeave) CDownloadArray( KArrayGranularity );

    CLOG_WRITE(" iDownloadArray OK");

    iUiDataArray = new (ELeave) CDownloadUiDataArray( KArrayGranularity );

    CLOG_WRITE(" iUiDataArray OK");

    iListBoxTextArray = new (ELeave) CDesCArrayFlat( KArrayGranularity );

    CLOG_WRITE(" iListBoxTextArray OK");

    iListBoxIconArray = new (ELeave) CArrayPtrFlat<CGulIcon>( KArrayGranularity );

    CLOG_WRITE(" iListBoxIconArray OK");

    iProgressInfoCreator = CProgressInfoCreator::NewL();

    CLOG_WRITE(" iProgressInfoCreator OK");

    iCompletedString = iCoeEnv.AllocReadResourceL( R_DMUL_DOWNLOAD_COMPLETE );

    CLOG_WRITE(" iCompletedString OK");

    iSavedToGalleryString = iCoeEnv.AllocReadResourceL( R_DMUL_DOWNLOAD_CONTENT_SAVED_TO_GALLERY );

    CLOG_WRITE(" iSavedToGalleryString OK");

	iSavedToDownloadsFolderString=  iCoeEnv.AllocReadResourceL( R_DMUL_DOWNLOAD_CONTENT_SAVED_TO_DOWNLOADS_FOLDER);

	CLOG_WRITE(" iSavedToGalleryDownload OK");

    iNullDesC = KNullDesC().AllocL();

    CLOG_WRITE(" iNullDesC OK");

    User::LeaveIfError( iApaLsSess.Connect() );

    CLOG_WRITE(" iApaLsSess OK");

    // Initialize the UiLib' mbm file name:

    TParse* fileParser = new (ELeave) TParse;

    CleanupStack::PushL( fileParser );

    fileParser->Set( KDownloadMgrUiLibMbmFileNameAndDriveZ, &KDC_APP_BITMAP_DIR, NULL ); 

    TUint attValue(0);

    TInt fileErr = iCoeEnv.FsSession().Att( fileParser->FullName(), attValue );

    CLOG_WRITE_FORMAT(" fileErr Z: %d",fileErr);

    User::LeaveIfError( fileErr );

    iMbmResourceFileName = HBufC::NewMaxL( fileParser->FullName().Length() );

    iMbmResourceFileName->Des().Copy( fileParser->FullName() );

    CLOG_WRITE_FORMAT(" iMbmResourceFileName: %S",iMbmResourceFileName);

    CleanupStack::PopAndDestroy( fileParser ); // fileParser 

    fileParser = NULL;

    AddDefaultIconsL();

    CLOG_LEAVEFN("CDownloadsListArray::ConstructL");

    }

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

// CDownloadsListArray::NewL

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

//

CDownloadsListArray* CDownloadsListArray::NewL()

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

// Destructor

CDownloadsListArray::~CDownloadsListArray()

    {

    CLOG_ENTERFN("CDownloadsListArray::~CDownloadsListArray");

    delete iApaMaskedBitmap;

    iApaMaskedBitmap = 0;

    delete iProgressInfoCreator;

    iProgressInfoCreator = 0;

    delete iListBoxTextArray;

    iListBoxTextArray = 0;

    if ( (iOwnedExt == EFalse ) && (iListBoxIconArray != NULL) )

    {

        iListBoxIconArray->ResetAndDestroy();

        delete iListBoxIconArray;

        iListBoxIconArray = 0;

    }

    delete iUiDataArray;

    iUiDataArray = 0;

    delete iDownloadArray;

    iDownloadArray = 0;

    delete iCompletedString;

    iCompletedString = 0;

	delete iSavedToGalleryString;

	iSavedToGalleryString = 0;

	delete iSavedToDownloadsFolderString;

	iSavedToDownloadsFolderString=0;

    delete iNullDesC;

    iNullDesC = 0;

    iApaLsSess.Close();

    CLOG_WRITE(" iApaLsSess.Close");

    delete iMbmResourceFileName;

    iMbmResourceFileName = 0;

    CLOG_LEAVEFN("CDownloadsListArray::~CDownloadsListArray");

    }

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

// CDownloadsListArray::AppendL

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

//

TInt CDownloadsListArray::AppendL( CGulIcon* aIcon )

    {

    // TODO Performance: append only if it does not exist in list already.

    iListBoxIconArray->AppendL( aIcon );

    return (iListBoxIconArray->Count()-1);//todo

    }

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

// CDownloadsListArray::AppendL

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

//

TInt CDownloadsListArray::AppendL

    ( const TDownloadUiData& aDownloadUiData, const RHttpDownload& aDownload )

    {

    TInt itemIndex( KErrNotFound );

    __ASSERT_DEBUG( Find( aDownload, itemIndex ) == KErrNotFound, 

                    Panic( EUiLibPanAlreadyExistWhenAppend ) );

    #ifdef _DEBUG

    TInt findErr = Find( aDownload, itemIndex ) ;

    CLOG_WRITE_FORMAT(" findErr: %d",findErr);

    CLOG_WRITE_FORMAT(" itemIndex: %d",itemIndex);

    #endif // _DEBUG

    // Append at the end:

    // Reserve space in order that appending to all the arrays be atomic.

    // Use iListBoxTextArray->Count() for SetReserveL, because thus we can 

    // eliminate that subsequent SetReserveL reserve unnecessary 

    // place if iListBoxTextArray->AppendL() LEAVEs.

    iDownloadArray->SetReserveL( iListBoxTextArray->Count() + 1 );

    iUiDataArray->SetReserveL( iListBoxTextArray->Count() + 1 );

    iListBoxTextArray->AppendL( LBTextFromUiData( aDownloadUiData ) );

    // iListBoxTextArray->AppendL did not leave and the following 

    // will not leave, because of SetReserveL()'s:

    iDownloadArray->AppendL( (RHttpDownload*)&aDownload );

    iUiDataArray->AppendL( aDownloadUiData );

    itemIndex = Count() - 1;

    return itemIndex;

    }

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

// CDownloadsListArray::UpdateL

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

//

void CDownloadsListArray::UpdateL( TInt aIndex, const TDownloadUiData& aDownloadUiData )

    {

    // Two steps: update UI data and the list item text.

    // Because updating the list text array can leave and the two 

    // array must be consistent, this operation must be atomic, this is 

    // why we apply the operations in the following order:

    // Insert the new text, and when it succeeds, remove the old (which is shifted).

    // No need to modify iDownloadArray, because that does not change.

    iListBoxTextArray->InsertL( aIndex, LBTextFromUiData( aDownloadUiData ) );

    iListBoxTextArray->Delete( (aIndex+1) ); // Old item was shifted.

    // Yes, update the UI data, which cannot leave.

    // No index boundary check - using operator []!

    (*iUiDataArray)[aIndex] = aDownloadUiData;

    }

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

// CDownloadsListArray::UpdateIfNeededL

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

//

void CDownloadsListArray::UpdateIfNeededL

    ( TInt aIndex, const TDownloadUiData& aDownloadUiData, TBool& aUpdated )

    {

    // Regenerate item text

    TPtrC regenerated = LBTextFromUiData( aDownloadUiData );

    if ( regenerated.Compare( Text( aIndex ) ) != KErrNone )

        {

        // The are different - update needed

        UpdateL( aIndex, aDownloadUiData );

        aUpdated = ETrue;

        }

    }

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

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

// CDownloadsListArray::Delete

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

//

void CDownloadsListArray::Delete( TInt aIndex )

    {

    // Delete the indicated record from all arrays:

    iDownloadArray->Delete( aIndex );

    iUiDataArray->Delete( aIndex );

    iListBoxTextArray->Delete( aIndex );

    iDownloadArray->Compress();

    iUiDataArray->Compress();

    iListBoxTextArray->Compress();

    }

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

// CDownloadsListArray::SetIconArrayOwnedExternally

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

//

void CDownloadsListArray::SetIconArrayOwnedExternally( TBool aOwnedExt )

    {

    iOwnedExt = aOwnedExt;

    }

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

// CDownloadsListArray::DownloadsCount

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

//

TInt CDownloadsListArray::DownloadsCount( TUint16 aDownloadStates )

    {

    TInt retCount( 0 );

    TInt count = Count();

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

        {

        TDownloadUiData& dlData = DlUiData(i);

        TInt32 state( dlData.iDownloadState );

        if ( aDownloadStates & MASKED_DL_STATE( state ) )

            {

            ++retCount;

            }

        }

    return retCount;

    }

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

// CDownloadsListArray::LBTextFromUiData

// Be careful when modifying this as it is not leavable!

// This function must be consistent with LBTextLength()!

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

//

TPtrC CDownloadsListArray::LBTextFromUiData( const TDownloadUiData& aDownloadUiData )

    {

    // Compute the space required for the current progress string:

    TInt spaceNeeded = LBTextLength( aDownloadUiData );

    // Realloc a bigger buffer if needed

    if ( iNewItemText && ( spaceNeeded <= iNewItemText->Length() ) )

        {

        // No need to reallocate a bigger buffer. 

        // The existing iNewItemText will be good. 

        }

    else

        {

        // Allocate a new (bigger) buffer (delete the old)

        delete iNewItemText;

        iNewItemText = 0;

        iNewItemText = HBufC::New( spaceNeeded );

        }

    // Non-leaving function - couldn't call NewL!

    if ( iNewItemText )

        {

        TPtr newItemTextPtr = iNewItemText->Des();

        newItemTextPtr.SetLength( 0 );

        //        

        iTempBuf.Zero();

        iTempBuf.Num( aDownloadUiData.iIconIndex );

        newItemTextPtr.Append( iTempBuf ); // Add icon array index

        newItemTextPtr.Append( KCharTab );

        //

        if ( aDownloadUiData.iName.Length() )

            {

            newItemTextPtr.Append( aDownloadUiData.iName );

            }

        else

            {

            newItemTextPtr.Append( KNullDesC );

            }

        newItemTextPtr.Append( KCharTab );

        // If its album download, format display string cur track/total tracks

        if ((aDownloadUiData.iNumMediaObjects > 1) &&

            (EHttpDlMultipleMOCompleted != aDownloadUiData.iDownloadState))

            {

            TBuf<KMaxIndexStringLength> indexStr;

            indexStr.Format( KIndexString, aDownloadUiData.iActiveMoIndex, aDownloadUiData.iNumMediaObjects );

            newItemTextPtr.Append( indexStr ); 

            }

        iProgressInfoRes.Zero();

		if ( aDownloadUiData.iDownloadState == EHttpDlMultipleMOCompleted ) 

				}

			}

        else

            {

            if ( aDownloadUiData.iFullSize <= 0 )

                {

                iProgressInfoCreator->ProgressInfo( aDownloadUiData.iDownloadedSize, 

                                                    iProgressInfoRes );

                }

            else

                {

                iProgressInfoCreator->ProgressInfo( aDownloadUiData.iDownloadedSize, 

                                                    aDownloadUiData.iFullSize, 

                                                    iProgressInfoRes );

                }

            }

        //

        newItemTextPtr.Append( iProgressInfoRes );

        newItemTextPtr.Append( KCharTab );

        //

        if ( aDownloadUiData.iDownloadState == EHttpDlCreated || // User must be able to start it via Resume.

             aDownloadUiData.iDownloadState == EHttpDlPaused || 

             aDownloadUiData.iDownloadState == EHttpDlMultipleMOFailed ) // User must be able to restart it.

            {

            // Add a "Paused" icon.

            iTempBuf.Zero();

            iTempBuf.Num( iPausedIconIndex );

            newItemTextPtr.Append( iTempBuf ); // iPausedIconIndex in literal form

            }

        newItemTextPtr.Append( KCharTab );

        //

        if ( aDownloadUiData.iIsOnExternalMemory )

            {

            // Add an "External memory" icon.

            iTempBuf.Zero();

            iTempBuf.Num( iExternalMemoryIconIndex );

            newItemTextPtr.Append( iTempBuf ); // iExternalMemoryIconIndex in literal form

            }

        }

    return iNewItemText ? (TPtrC)*iNewItemText : (TPtrC)*iNullDesC;

    }

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

// CDownloadsListArray::LBTextLength

// This function must be consistent with LBTextFromUiData()!

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

//

TInt CDownloadsListArray::LBTextLength( const TDownloadUiData& aDownloadUiData )

    {

    TInt ret(0);

    iTempBuf.Zero();

    iTempBuf.Num( aDownloadUiData.iIconIndex );

    ret += iTempBuf.Length();

    ret += KCharTab().Length();

    ret += aDownloadUiData.iName.Length();

    ret += KCharTab().Length();

    if( aDownloadUiData.iNumMediaObjects > 1 )

        {

        TBuf<KMaxIndexStringLength> indexStr;

        indexStr.Format( KIndexString, aDownloadUiData.iActiveMoIndex, aDownloadUiData.iNumMediaObjects );

        ret += indexStr.Length();

        }

    iProgressInfoRes.Zero();

	if ( aDownloadUiData.iDownloadState == EHttpDlMultipleMOCompleted ) 

		        {

		        }