/*

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

*      This class implements a model of a file list. Features:

*      - Contents of multiple folders in the same list

*      - Filtering with wildcards (*?)

*      - Filtering by maximum file size

*      - Sorting (name / date, ascending / descending)

*      - Entry presentation formatting using an abstract interface

*     The class is inherited from MDesCArray, so it can be used directly

*     as a model for a listbox.

*

*

*/

// CLASS HEADER

#include "CFLDFileListModel.h"

// INTERNAL INCLUDES

#include "CFLDOperationObserver.h"

#include "CFLDChangedItemObserver.h"

#include "CFLDEntryReference.h"

#include "CFLDWaitNote.h"

#include "CFLDPopupList.h"

#include "MFLDEntryFormatter.h"

// EXTERNAL INCLUDES

#include <MCLFContentListingEngine.h>

#include <MCLFItem.h>

#include <MCLFItemListModel.h>

#include <MCLFModifiableItem.h>

#include <ContentListingFactory.h>

#include <CLFContentListing.hrh>

#include <barsread.h>	// For TResourceReader

#include <ConeResLoader.h>	// For RConeResourceLoader

#include <coemain.h>	// CCoeEnv

#include <pathinfo.h>

#include <data_caging_path_literals.hrh>	// For KDC_RESOURCE_FILES_DIR

#include <FileList.rsg>	// For R_FLD_WAIT_NOTE

#include <bautils.h>	// For BaflUtils

#include <apgcli.h>	// For RApaLsSession

#include <aknnotewrappers.h>

#include <StringLoader.h>

// CONSTANTS

namespace

	{

	_LIT( KFLDROMDriveLetter, "Z:" );

	const TInt KGranularityFilters( 2 );

	}

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

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

// CFLDFileListModel::NewL

// Two-phased constructor.

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

//

 CFLDFileListModel* CFLDFileListModel::NewL(

  const TInt aModelResourceId, const TInt aDirectoriesResourceId )

    {

    // The default stuff.

    CFLDFileListModel* self =

     CFLDFileListModel::NewLC( aModelResourceId, aDirectoriesResourceId );

    CleanupStack::Pop( self ); // self

    return self;

    }

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

// CFLDFileListModel::NewLC

// Two-phased constructor.

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

//

CFLDFileListModel* CFLDFileListModel::NewLC(

 const TInt aModelResourceId, const TInt aDirectoriesResourceId )

    {

    CFLDFileListModel* self =

        new( ELeave ) CFLDFileListModel();

    CleanupStack::PushL( self );

    self->ConstructL( aModelResourceId, aDirectoriesResourceId );

    return self;

    }

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

// CFLDFileListModel::CFLDFileListModel

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

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

//

CFLDFileListModel::CFLDFileListModel()

	: iExclusiveMimeTypes( KGranularityFilters ),

	iExclusiveMediaTypes( KGranularityFilters ),

	iDirectoryPaths( KGranularityFilters ),

	iRomDirectoryPaths( KGranularityFilters ),

	iMaxFileSize( 0 )

    {

    }

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

// CFLDFileListModel::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CFLDFileListModel::ConstructL(

 const TInt aModelResourceId, const TInt aDirectoriesResourceId )

    {

	// Create CLF Operation Observer to monitor, when

    // refresh operation has completed

    iObserver = CFLDOperationObserver::NewL();

    // Create Content Listing Engine and a list model

    iEngine = ContentListingFactory::NewContentListingEngineLC();

    CleanupStack::Pop(); // iEngine

	// Load CLF definitions from user given resource

    TResourceReader reader;

	CCoeEnv::Static()->CreateResourceReaderLC( reader, aModelResourceId );

    iModel = iEngine->CreateListModelLC( *iObserver, reader );

    CleanupStack::Pop(); // iModel

   	CleanupStack::PopAndDestroy();  // reader

    // Load wait note from default-resource

    iWaitNote = CFLDWaitNote::NewL( R_FLD_WAIT_NOTE );

	// Load directories

	CFLDFileListModel::LoadDirectoriesL( aDirectoriesResourceId );

	// Create changed item observer to monitor, when

    // tone selection files are modified or deleted

    iChangedItemObserver = CFLDChangedItemObserver::NewL(iWaitNote);

	iEngine->AddChangedItemObserverL( *iChangedItemObserver );

	// Set post filter	

	iModel->SetPostFilter( this );

    }

// Destructor

 CFLDFileListModel::~CFLDFileListModel()

    {

     if( iModel )

        {

        iModel->CancelRefresh();

        delete iModel;

        }

    delete iEngine;

    delete iObserver;

    delete iChangedItemObserver;

    delete iEntryFormatter;

	delete iWaitNote;

    iEndNullTextRingingToneArray.ResetAndDestroy();

    iEndNullTextArray.ResetAndDestroy();

    iNullTextRingingToneArray.ResetAndDestroy();

    iNullTextArray.ResetAndDestroy();

    iEntryReferences.ResetAndDestroy();

    iExclusiveMimeTypes.Reset();

    iExclusiveMediaTypes.Reset();

   	iDirectoryPaths.Reset();

   	iRomDirectoryPaths.Reset();

    iRomRingingToneArray.ResetAndDestroy();

    }

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

// CFLDFileListModel::LoadRomDirectoriesL

// (other items were commented in a header).

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

//

void CFLDFileListModel::LoadDirectoriesL( const TInt aDirectoriesResourceId )	

	 {

	 TResourceReader reader;

  	 CCoeEnv::Static()->CreateResourceReaderLC( reader, aDirectoriesResourceId );

	 // Read ROM directories from resource

	 TInt count( reader.ReadInt16() );

	 while( --count >= 0 )

     	{

        TPtrC ptr( reader.ReadTPtrC() );

		// Ignore return value

        AddRomDirectoryL( ptr );

        }

     // Read directories from resource

	 count = reader.ReadInt16();

	 while( --count >= 0 )

     	{

        TPtrC ptr( reader.ReadTPtrC() );

		// Ignore return value

        AddDirectoryL( ptr );

        }

  	 CleanupStack::PopAndDestroy();  // reader

	 }

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

// CFLDFileListModel::AddRomDirectoryL

// (other items were commented in a header).

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

//

 TInt CFLDFileListModel::AddRomDirectoryL( const TDesC& aDirectory )

    {

    TInt index( 0 );

	if( iRomDirectoryPaths.Find( aDirectory, index ) == 0 )

		{

        // A duplicate was found, do not add to the array, return.

		return KErrAlreadyExists;

		}

	RFs& fsSession( CCoeEnv::Static()->FsSession() );

    // Check that the directory really exists

    if ( !BaflUtils::FolderExists( fsSession, aDirectory ) )

        {

        return KErrPathNotFound;

        }

    iRomDirectoryPaths.AppendL( aDirectory );

    return KErrNone;

    }

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

// CFLDFileListModel::AddDirectoryL

// (other items were commented in a header).

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

//

 TInt CFLDFileListModel::AddDirectoryL( const TDesC& aDirectory )

    {

    TInt index( 0 );

	if( iDirectoryPaths.Find( aDirectory, index ) == 0 )

		{

        // A duplicate was found, do not add to the array, return.

		return KErrAlreadyExists;

		}

    iDirectoryPaths.AppendL( aDirectory );

    return KErrNone;

    }

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

// CFLDFileListModel::SetWantedMimeTypesL()

// (other items were commented in a header).

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

//

void CFLDFileListModel::SetWantedMimeTypesL( const MDesCArray& aMimeTypes )

	{

	CFLDFileListModel::ResetExclusiveMimeTypes();

	CFLDFileListModel::ResetExclusiveMediaTypes();

	iModel->SetWantedMimeTypesL( aMimeTypes );

	}

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

// CFLDFileListModel::SetWantedMediaTypesL()

// (other items were commented in a header).

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

//

void CFLDFileListModel::SetWantedMediaTypesL(

 const TArray<TCLFMediaType>& aMediaTypes )

	{

	CFLDFileListModel::ResetExclusiveMimeTypes();

	CFLDFileListModel::ResetExclusiveMediaTypes();

	// Temporary solution

	RArray<TInt> array;

	TInt count( aMediaTypes.Count() );

    CleanupClosePushL( array );

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

		{

		array.AppendL( aMediaTypes[i]);

		}

    iModel->SetWantedMediaTypesL( array.Array() );

    CleanupStack::PopAndDestroy( &array );

	}

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

// CFLDFileListModel::PopulateReferenceListL

// (other items were commented in a header).

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

//

 void CFLDFileListModel::PopulateReferenceListL()

    {

    // Do not allow to update model from changed item observer

    iChangedItemObserver->SetFileListModel( NULL );

    // Send reference of CActiveSchedulerWait to the CLF Operation Observer

    iObserver->PrepareForRefresh( iWait );

    // CLF hogs the processor when doing its refresh. Make sure we'll

    // have enough of a slice to be able to handle the End key presses.

    RWsSession& wsSession = CCoeEnv::Static()->WsSession();

    wsSession.ComputeMode( RWsSession::EPriorityControlDisabled );

    // Call refresh to get all music files from the file system to the model

    iModel->RefreshL();

	// Display a wait note if user tries to do something while refresh

	// operation of the list model has not finished yet.

    if( iObserver->IsRefreshOngoing() && !iWait.IsStarted() )

        {

        // View the wait note

        if( iWaitNote && !iWaitNote->IsRunning() )

        	{

        	 iWaitNote->OpenWaitNoteL();

        	}

   	    // Wait for the refresh operation to complete. Operation Observer will

       	// stop this wait when the refresh operation has compeleted.

       	iWait.Start(); // CSI: 10 # the state of iWait is checked above

        // Close the wait note

       	if ( iWaitNote )

       		{

       		iWaitNote->CloseWaitNoteL();	

       		}       

        }

    // Back to default behavior

    wsSession.ComputeMode( RWsSession::EPriorityControlComputeOff );

	PopulateListBoxL();

	if( iPopupList )

		{ // Model has updated; list should try to handle it

		iPopupList->CancelPreview();

		TRAP_IGNORE( iPopupList->ListBox()->HandleItemAdditionL() );

		// List has updated; set focus to the first item

		iPopupList->ListBox()->SetCurrentItemIndexAndDraw( 0 );

		}

	// Allow to update model from changed item observer

	// (unless we're displaying ROM tones only)

	if( !iRomTonesOnly )

		{

		iChangedItemObserver->SetFileListModel( this );

		}

    }

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

// CFLDFileListModel::ScanRomDirectoriesL

// (other items were commented in a header).

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

//

void CFLDFileListModel::ScanRomDirectoriesL()

	{

	CDir* fileList( NULL );

	RFs& fsSession( CCoeEnv::Static()->FsSession() );

	TInt directoryCount( iRomDirectoryPaths.Count() );

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

		{

		User::LeaveIfError(fsSession.GetDir(

			iRomDirectoryPaths.MdcaPoint(i),

			 KEntryAttNormal,ESortByName, fileList));

		CleanupStack::PushL( fileList );

		TInt fileCount( fileList->Count() );

		for ( TInt j=0; j<fileCount; j++ )

			{

			const TEntry item = (*fileList)[j];

			TBufC<KMaxFileName> tempBuf = item.iName;

			HBufC* concateName = HBufC::NewLC(

			 iRomDirectoryPaths.MdcaPoint(i).Length() + tempBuf.Length() );

			TPtr des = concateName->Des();

			des.Insert(0, iRomDirectoryPaths.MdcaPoint(i) );

			des.Append( tempBuf );

			// Only files located on ROM must be scanned

			// CLF has already scanned other ( supported ) locations

			if( ( des.Left( KFLDROMDriveLetter().Length() ).CompareF(

          		KFLDROMDriveLetter ) == 0 ) )

				{

				TParsePtrC parsedName( des );

				MCLFModifiableItem* clfModifiableItem

				 = ContentListingFactory::NewModifiableItemLC();

				clfModifiableItem->AddFieldL( ECLFFieldIdFileName, parsedName.NameAndExt() );

				clfModifiableItem->AddFieldL( ECLFFieldIdPath, parsedName.Path() );

				clfModifiableItem->AddFieldL( ECLFFieldIdDrive, parsedName.Drive() );

#ifdef RD_VIDEO_AS_RINGING_TONE

				if( PathInfo::PathType( parsedName.DriveAndPath() ) == PathInfo::EVideosPath )

					{

					clfModifiableItem->AddFieldL( ECLFFieldIdMediaType, ECLFMediaTypeVideo);

					}

				else

					{

					clfModifiableItem->AddFieldL( ECLFFieldIdMediaType, ECLFMediaTypeSound);

					}

#else

				clfModifiableItem->AddFieldL( ECLFFieldIdMediaType, ECLFMediaTypeSound);

#endif

				clfModifiableItem->AddFieldL( ECLFFieldIdFileNameAndPath, des );

        		// Find out MIME type

        		RApaLsSession apaLsSession;

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

    			CleanupClosePushL( apaLsSession );

    			TUid dummyUid = { 0 }; // instantiate as zero

    			TDataType dataType( dummyUid );

    			TInt err = apaLsSession.AppForDocument( parsedName.FullName(), dummyUid, dataType );

    			CleanupStack::PopAndDestroy(); // apaLsSession.Close()

    			if( err == KErrNone )

    				{

        			clfModifiableItem->AddFieldL( ECLFFieldIdMimeType, dataType.Des() );

    				User::LeaveIfError(	iRomRingingToneArray.Append( clfModifiableItem ) );

    				CleanupStack::Pop(); // clfModifiableItem

    				}

    			else

    				{

    				CleanupStack::PopAndDestroy(); // clfModifiableItem

    				}

				}

			CleanupStack::PopAndDestroy( concateName );

			}

		CleanupStack::PopAndDestroy( fileList);

		}

	}

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

// CompareEntries

// For sorting entry references alphabetically by tone name.

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

//

TInt CompareEntries(const CFLDEntryReference& entry1, const CFLDEntryReference& entry2 )

	{

	TParsePtrC parsed1( entry1.PathAndMediaFileName() );

	TParsePtrC parsed2( entry2.PathAndMediaFileName() );

	return parsed1.Name().CompareF( parsed2.Name() );

	}

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

// CFLDFileListModel::ScanRomDirectoriesAndInsertL

// (other items were commented in a header).

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

//

void CFLDFileListModel::ScanRomDirectoriesAndInsertL()

	{

	CDir* fileList( NULL );

	RFs fsSession;

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

	CleanupClosePushL( fsSession );

	TInt directoryCount( iRomDirectoryPaths.Count() );

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

		{

		User::LeaveIfError(fsSession.GetDir(

			iRomDirectoryPaths.MdcaPoint(i),

			 KEntryAttNormal,ESortByName, fileList));

		CleanupStack::PushL( fileList );

		TInt fileCount( fileList->Count() );

		for ( TInt j=0; j<fileCount; j++ )

			{

			const TEntry item = (*fileList)[j];

			TBufC<KMaxFileName> tempBuf = item.iName;

			HBufC* concateName = HBufC::NewLC(

			 iRomDirectoryPaths.MdcaPoint(i).Length() + tempBuf.Length() );

			TPtr des = concateName->Des();

			des.Insert(0, iRomDirectoryPaths.MdcaPoint(i) );

			des.Append( tempBuf );

			// Only files located on ROM must be scanned

			if( ( des.Left( KFLDROMDriveLetter().Length() ).CompareF(

          		KFLDROMDriveLetter ) == 0 ) )

				{

				// Add file to entry-list 							            	

		   		CFLDEntryReference* entryRef = new( ELeave ) CFLDEntryReference();

		   		CleanupStack::PushL( entryRef );

	        	HBufC* pathAndMediaFileName	= des.AllocL();

				entryRef->SetPathAndMediaFileName( pathAndMediaFileName );

				TParsePtrC parsedName( des );

				if( PathInfo::PathType( parsedName.DriveAndPath() ) == PathInfo::EVideosPath )

					{

					entryRef->SetMediaType( ECLFMediaTypeVideo);

					}

				else

					{

					entryRef->SetMediaType( ECLFMediaTypeSound);

					}

    			iEntryFormatter->FormatL( *entryRef );

				User::LeaveIfError(	iEntryReferences.Append( entryRef ) );

				CleanupStack::Pop( entryRef );

				}

			CleanupStack::PopAndDestroy( concateName );

			}

		CleanupStack::PopAndDestroy( fileList);

		}

	TLinearOrder<CFLDEntryReference>* sorter = 

		new( ELeave ) TLinearOrder<CFLDEntryReference> ( CompareEntries );

	iEntryReferences.Sort( *sorter );

	delete sorter;

	CleanupStack::PopAndDestroy(); // fsSession

	}

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

// CFLDFileListModel::FilterItemsL

// (other items were commented in a header).

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

//

void CFLDFileListModel::FilterItemsL( const TArray<MCLFItem*>& aItemList,

                                RPointerArray<MCLFItem>& aFilteredItemList )

	{

	// Add all found entries into model

    TInt count( aItemList.Count() );

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

    	{

		MCLFItem* item = aItemList[i];

		aFilteredItemList.AppendL( item );	    	

    	}