/*

* Copyright (c) 2002-2009 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: 

*

*/

// INCLUDE FILES

#include    "CCLFItemListModelImpl.h"

#include    "CCLFDbItemProvider.h"

#include    "CCLFDefaultOperation.h"

#include    <MCLFOperationObserver.h>

#include    <MCLFItem.h>

#include    <MCLFSortingStyle.h>

#include    "MGTracePrint.h"

#include    <ContentListingFactory.h>

#include    <barsread.h>

#include    <collate.h>

#include    "MGDebugPrint.h"

// for CleanupResetAndDestroyPushL

#include <mmf/common/mmfcontrollerpluginresolver.h>

// CONSTANTS

const TInt KCLFResourceVersionNumber( 1 );

const TInt KCLFEmptyArrayGranularity( 1 );

const TInt KCLFSortingStyleArrayGranularity( 3 );

const TInt KCLFResourceVersion1( 1 );

const TInt KCLFResourceVersion2( 2 );

_LIT( KCLFAllMimeTypeMatchString, "*" );

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

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

// CCLFItemListModelImpl::CCLFItemListModelImpl

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

//

CCLFItemListModelImpl::CCLFItemListModelImpl(

                                        CCLFDbItemProvider* aItemProvider,

                                        MCLFOperationObserver& aObserver,

                                        MCLFChangedItemProvider& aChangedItemProvider )

    : iMimeTypeArray( NULL ),

      iMediaTypeArray( NULL ),

      iGrouper( NULL ),

      iSorter( NULL ),

      iPostFilter( NULL ),

      iItemProvider( aItemProvider ),

      iOperationObserver( aObserver ),

      iSortingStyleArray( KCLFSortingStyleArrayGranularity ),

      iChangedItemProvider( aChangedItemProvider ),

      iIsItemsFetched( EFalse )

    {

    }

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

// CCLFItemListModelImpl::ConstructL

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

//

void CCLFItemListModelImpl::ConstructL()

    {

    iMediaTypeArray = new ( ELeave ) CArrayFixFlat< TInt >( KCLFEmptyArrayGranularity );

    iMimeTypeArray = new ( ELeave ) CDesCArrayFlat( KCLFEmptyArrayGranularity );

    iDefaultOperation = CCLFDefaultOperation::NewL();

    iSorter = iDefaultOperation;

    iGrouper = iDefaultOperation;

    iPostFilter = iDefaultOperation;

    }

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

// CCLFItemListModelImpl::ConstructL

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

//

void CCLFItemListModelImpl::ConstructL( TResourceReader& aResource )

   {

    ConstructL();

    const TInt version( aResource.ReadInt16() );

    // resource versions are defined in Content Listing framework .rh file

    if( version != KCLFResourceVersion1 &&

        version != KCLFResourceVersion2 )

        {

        User::Leave( KErrNotSupported );

        }

    SetGroupingStyle( TCLFGrouping( aResource.ReadInt32() ) );

    SetWantedMimeTypesL( aResource );

    SetWantedMediaTypesL( aResource );

    const TInt count(

        version == KCLFResourceVersion2 ? aResource.ReadInt16() - 1 : 0 );

    MCLFSortingStyle* sortingStyle =

                        ContentListingFactory::NewSortingStyleLC( aResource );

    iSortingStyleArray.AppendL( sortingStyle ); // takes ownership

    CleanupStack::Pop(); // sortingStyle

    iDefaultOperation->SetSortingStyle( sortingStyle);

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

        {

        MCLFSortingStyle* sortingStyle =

                        ContentListingFactory::NewSortingStyleLC( aResource );

        iSortingStyleArray.AppendL( sortingStyle ); // takes ownership

        CleanupStack::Pop(); // sortingStyle

        iDefaultOperation->AppendSortingStyleL( *sortingStyle );

        }

    }

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

// CCLFItemListModelImpl::NewLC

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

//

CCLFItemListModelImpl* CCLFItemListModelImpl::NewLC(

                                            CCLFDbItemProvider* aItemProvider,

                                            MCLFOperationObserver& aObserver,

                                            MCLFChangedItemProvider& aChangedItemProvider )

    {

    CCLFItemListModelImpl* self = new( ELeave ) CCLFItemListModelImpl( aItemProvider, aObserver, aChangedItemProvider );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CCLFItemListModelImpl::NewLC

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

//

CCLFItemListModelImpl* CCLFItemListModelImpl::NewLC(

                                            CCLFDbItemProvider* aItemProvider,

                                            MCLFOperationObserver& aObserver,

                                            MCLFChangedItemProvider& aChangedItemProvider,

                                            TResourceReader& aResource)

    {

    CCLFItemListModelImpl* self = new( ELeave ) CCLFItemListModelImpl( aItemProvider, aObserver, aChangedItemProvider );

    CleanupStack::PushL( self );

    self->ConstructL( aResource );

    return self;

    }

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

// CCLFItemListModelImpl::~CCLFItemListModelImpl

// Destructor

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

//

CCLFItemListModelImpl::~CCLFItemListModelImpl()

    {

    iChangedItemProvider.RemoveChangedItemProviderObserver( this );

    delete iMimeTypeArray;

    delete iMediaTypeArray;

    iItemArray.ResetAndDestroy();

    delete iItemProvider;

    iResultArray.Close();

    delete iDefaultOperation;

    iSortingStyleArray.ResetAndDestroy();

    }

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

// CCLFItemListModelImpl::Item

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

//

const MCLFItem& CCLFItemListModelImpl::Item( TInt aIndex ) const

    {

    return *( iResultArray[aIndex] );

    }

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

// CCLFItemListModelImpl::ItemCount

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

//

TInt CCLFItemListModelImpl::ItemCount() const

    {

    return iResultArray.Count();

    }

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

// CCLFItemListModelImpl::SetSortingStyle

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

//

void CCLFItemListModelImpl::SetSortingStyle( MCLFSortingStyle* aSortingStyle )

    {

    iDefaultOperation->SetSortingStyle( aSortingStyle );

    iSortingStyleArray.ResetAndDestroy();

    }

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

// CCLFItemListModelImpl::AppendSecondarySortingStyleL

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

//

void CCLFItemListModelImpl::AppendSecondarySortingStyleL(

                                            MCLFSortingStyle& aSortingStyle )

    {

    iDefaultOperation->AppendSortingStyleL( aSortingStyle );

    }

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

// CCLFItemListModelImpl::SetCustomSorter

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

//

void CCLFItemListModelImpl::SetCustomSorter( MCLFCustomSorter* aCustomSorter )

    {

    if( aCustomSorter )

        {

        iSorter = aCustomSorter;

        }

    else

        {

        iSorter = iDefaultOperation;

        }

    }

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

// CCLFItemListModelImpl::SetGroupingStyle

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

//

void CCLFItemListModelImpl::SetGroupingStyle( TCLFGrouping aGrouping )

    {

    iDefaultOperation->SetGrouping( aGrouping );

    }

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

// CCLFItemListModelImpl::SetCustomGrouper

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

//

void CCLFItemListModelImpl::SetCustomGrouper(

                                            MCLFCustomGrouper* aCustomGrouper )

    {

    if( aCustomGrouper )

        {

        iGrouper = aCustomGrouper;

        }

    else

        {

        iGrouper = iDefaultOperation;

        }

    }

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

// CCLFItemListModelImpl::SetPostFilter

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

//

void CCLFItemListModelImpl::SetPostFilter( MCLFPostFilter* aPostFilter )

    {

    if( aPostFilter )

        {

        iPostFilter = aPostFilter;

        }

    else

        {

        iPostFilter = iDefaultOperation;

        }

    }

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

// CCLFItemListModelImpl::SetWantedMimeTypesL

// Method makes new array, because if we can't make new then old array is used

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

//

void CCLFItemListModelImpl::SetWantedMimeTypesL( const MDesCArray& aMimeTypes )

    {

    const TInt mimeTypeCount( aMimeTypes.MdcaCount() );

    if( mimeTypeCount > 0 )

        {

        if( mimeTypeCount == 1 )

            {

            TCollationMethod m = *Mem::CollationMethodByIndex( 0 );

            m.iFlags = ( TCollationMethod::EIgnoreNone | TCollationMethod::EFoldCase );   

            const TDesC& mimeType = aMimeTypes.MdcaPoint( 0 );

            if ( mimeType.CompareC( KCLFAllMimeTypeMatchString, 3, &m ) == 0 )

                {

                ResetMimeTypeArrayL();

                return;

                }

            }

        CDesCArray* array = new (ELeave) CDesCArrayFlat( mimeTypeCount );

        CleanupStack::PushL( array );

        for( TInt i = mimeTypeCount - 1; i >=0; i--)

            {

            array->AppendL( aMimeTypes.MdcaPoint( i ) );

            }

        CleanupStack::Pop( array );

        delete iMimeTypeArray;

        iMimeTypeArray = array;

        }

    else

        {

        ResetMimeTypeArrayL();

        }

    }

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

// CCLFItemListModelImpl::SetWantedMimeTypesL

// Method makes new array, because if we can't make new then old array is used

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

//

void CCLFItemListModelImpl::SetWantedMimeTypesL( TResourceReader& aResource )

    {

    CheckVersionL( aResource, KCLFResourceVersionNumber );

    const TInt numMimeTypes( aResource.ReadInt16() );

    if ( numMimeTypes > 0 )

        {

        // TResourceReader re-reads the length, have to rewind

        aResource.Rewind( sizeof( TInt16 ) );

        CDesCArray* array = aResource.ReadDesCArrayL();

        delete iMimeTypeArray;

        iMimeTypeArray = array;

        }

    else

        {

        ResetMimeTypeArrayL();

        }

    }

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

// CCLFItemListModelImpl::SetWantedMediaTypesL

// Method makes new array, because if we can't make new then old array is used

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

//

void CCLFItemListModelImpl::SetWantedMediaTypesL(

                            const TArray<TInt>& aMediaTypes )

    {

    const TInt count( aMediaTypes.Count() );

    if( count > 0 )

        {

        CArrayFix<TInt>* array =

                        new ( ELeave ) CArrayFixFlat<TInt>( count );

        CleanupStack::PushL( array );

        for(TInt i = count - 1; i >=0; i--)

            {

            array->AppendL( aMediaTypes[i] );

            }

        CleanupStack::Pop( array );

        delete iMediaTypeArray;

        iMediaTypeArray = array;

        }

    else

        {

        ResetMediaTypeArrayL();

        }

    }

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

// CCLFItemListModelImpl::SetWantedMediaTypesL

// Method makes new array, because if we can't make new then old array is used

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

//

void CCLFItemListModelImpl::SetWantedMediaTypesL( TResourceReader& aResource )

    {

    CheckVersionL( aResource, KCLFResourceVersionNumber );

    const TInt numMediaTypes( aResource.ReadInt16() );

    if ( numMediaTypes > 0 )

        {

        CArrayFix<TInt>* array =

                new ( ELeave ) CArrayFixFlat<TInt>( numMediaTypes );

        CleanupStack::PushL( array );

        for( TInt i = numMediaTypes - 1; i >=0; i--)

            {

            array->AppendL( aResource.ReadInt32() );

            }

        CleanupStack::Pop( array );

        delete iMediaTypeArray;

        iMediaTypeArray = array;

        }

    else

        {

        ResetMediaTypeArrayL();

        }

    }

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

// CCLFItemListModelImpl::RefreshL

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

//

void CCLFItemListModelImpl::RefreshL()

    {

    MG_TRACE1( KCLFTrace, "CLF list model refresh start" )

    iIsItemsFetched = EFalse;

    iItemArray.ResetAndDestroy();

    iItemProvider->PrepareItemsL( *iMimeTypeArray,

                             iMediaTypeArray->Array(),

                             *this );

    }

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

// CCLFItemListModelImpl::RefreshL

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

//

void CCLFItemListModelImpl::RefreshL( TInt32 aRefreshType )

    {

    RPointerArray<MCLFItem> tmpArray;

    CleanupClosePushL( tmpArray );

    MG_TRACE1( KCLFTrace, "CLF list model refresh post filter start" )

    if( aRefreshType & ECLFRefreshPostFilter )

        {

        iPostFilter->FilterItemsL( iItemArray.Array(), tmpArray );

        }

    else

        {

        CopyArrayL( iItemArray.Array(), tmpArray );

        }

    iResultArray.Reset();

    MG_TRACE1( KCLFTrace1, "CLF list model refresh grouping start" )

    if( aRefreshType & ECLFRefreshGrouping )

        {

        iGrouper->GroupItemsL( tmpArray.Array(), iResultArray );

        }

    else

        {

        CopyArrayL( tmpArray.Array(), iResultArray );

        }

    CleanupStack::PopAndDestroy( &tmpArray );

    MG_TRACE1( KCLFTrace2, "CLF list model refresh sorting start" )

    if( aRefreshType & ECLFRefreshSorting )

        {

        iSorter->SortItemsL( iResultArray );

        }

    MG_TRACE1( KCLFTrace3, "CLF list model refresh sorting done" )

    }

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

// CCLFItemListModelImpl::CopyArrayL

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

//

void CCLFItemListModelImpl::CopyArrayL( const TArray<MCLFItem*>& aSource,

                                        RPointerArray<MCLFItem>& aDest )

    {

    CleanupResetAndDestroyPushL( aDest );

    for( TInt i = aSource.Count() - 1; i >=0; i--)

        {

        aDest.AppendL( aSource[i] );

        }

    CleanupStack::Pop( &aDest );

    }

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

// CCLFItemListModelImpl::CancelRefresh

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

//

void CCLFItemListModelImpl::CancelRefresh()

    {

    iItemProvider->Cancel();

    }

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

// CCLFItemListModelImpl::OperationCompleteL

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

//

void CCLFItemListModelImpl::OperationCompleteL( TInt aError )

    {

    MG_TRACE1( KCLFTrace, "CLF list model items ready" )

    TInt error( aError );

    if ( error == KErrNone )

        {

        iIsItemsFetched = ETrue;

        iResultArray.Reset(); // reset result array before items are deleted

        iItemArray.ResetAndDestroy();

        error = iItemProvider->GetItems( iItemArray );

        if ( error == KErrNone )

            {

            RefreshL( ECLFRefreshAll );

            }

        }

    iOperationObserver.HandleOperationEventL( ECLFRefreshComplete, error );

    }

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

// CCLFItemListModelImpl::CheckVersionL

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

//

void CCLFItemListModelImpl::CheckVersionL( TResourceReader& aResource,

                                           TInt aVersion )

    {

    const TInt version( aResource.ReadInt16() );

    if( version != aVersion )

        {

        User::Leave( KErrNotSupported );

        }

    }

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

// CCLFItemListModelImpl::ResetMimeTypeArrayL

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

//

void CCLFItemListModelImpl::ResetMimeTypeArrayL()

    {

    CDesCArray* array =

                new (ELeave) CDesCArrayFlat( KCLFEmptyArrayGranularity );

    delete iMimeTypeArray;

    iMimeTypeArray = array;

    }

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

// CCLFItemListModelImpl::ResetMediaTypeArrayL

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

//

void CCLFItemListModelImpl::ResetMediaTypeArrayL()

    {

    CArrayFix<TInt>* array =

                        new ( ELeave ) CArrayFixFlat<TInt>(

                                            KCLFEmptyArrayGranularity );

    delete iMediaTypeArray;

    iMediaTypeArray = array;

    }