/*

* Copyright (c) 2007-2007 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:  This Class provides the core functionality to Media Management

*				 SAPI Interafce

*

*/

#include <mclfitemlistmodel.h>

#include <mclfcontentlistingengine.h>

#include <contentlistingfactory.h>

#include <mclfsortingstyle.h>

#include "mgservice.h"

#include "mgpostfilter.h"

#include "mgoperationobserver.h"

#include "mgclfoperationobserver.h"

#include "mgconsts.h"

//Media types.

_LIT8( KMgMusic        ,"Music" );

_LIT8( KMgSound        ,"Sound" );

_LIT8( KMgImage        ,"Image" );

_LIT8( KMgVideo        ,"Video" );

_LIT8( KMgStreamingURL ,"StreamingURL" );

//SortingOrder

_LIT8( KMgDescending,   "Descending" );

//_LIT8( KMgAscending,   "Ascending" );

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

// CMgService::NewLC

// Returns the instance of CMgService class.

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

EXPORT_C CMgService* CMgService::NewL()

	{

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

	CleanupStack::PushL( self );

	self->ConstructL();

	CleanupStack::Pop( self );

	return self;

	}

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

// CMgService::~CMgService

// Destructor

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

CMgService::~CMgService()

	{

    //release filter class

    delete iFilter;

    // release sorting style

    delete iSortingStyle;

	// release clf observer class

    delete iClfObserver;

    //release iEngine;

    delete iEngine;

	}

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

// CMgService::GetFiles

// This function extracts all media item that match the given arguments

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

EXPORT_C void CMgService::GetListL(const TMgServiceRequest& aInParameters,

						  MMgOperationObserver* aServiceObserver)

	{

	//Check if the class is busy or waiting for asynchronous request

	//This has already been verified by SAPI interface class ,still this condition

	//is checked keeping in mind that this class may be called directly by a

	//Series60 application in future

	if( EMgFree == iState )

		{

		if( NULL != aServiceObserver )//Asynchronous request

			{

			// create the instance of CLF list Model for the current request

   	 	    MCLFItemListModel* listModel = iEngine->

   	 	                                   CreateListModelLC( *iClfObserver );

		    SendRequestToClfL( aInParameters.iFileType,

		    				   aInParameters.iFilterField,

		    				   aInParameters.iStartVal,

		    				   aInParameters.iEndVal,

		    				   aInParameters.iSortField,

		    				   aInParameters.iOrder,

		    				   listModel );

		    CleanupStack::Pop();

		    iTransactionID = aInParameters.iTransactionID;

		    iClfObserver->SetMemberVar( aInParameters.iTransactionID,

		                                aServiceObserver,

										listModel,

										this );

			}

		else

			{

			//Synchronous request handling is currently not supported

			User::Leave( KErrNotSupported );

			}

		}//SAPI State

	else

	    {

        User::Leave( KErrServerBusy ); // busy in previous request

	    }

	}

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

// CMgService::Cancel

// Cancel the pending asynchronous request

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

EXPORT_C TInt CMgService::CancelL( TUint aTransactionID)

	{

		// call cancel of CLF

		// Right now we are not supporting aTransactionID

		// but in future we have to find the iClfObserver

		// coresponding to this Transaction ID and Call cancel

		// on that observer

	if( EMgBusy == iState )

		{

		if( aTransactionID == iTransactionID )

		    {

		    iClfObserver->CancelL( );

		    Clear();

		    return KErrNone;

	    	}

		}

 		return KErrArgument;

	}

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

// CMgService::Clear

//	It will clear the set filter metadata field ,registered callback

//	function and sorting fields

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

void CMgService::Clear()

	{

       	iFilter->Clear();

		iState = EMgFree;

		iTransactionID = 0;

	}

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

// CMgService::State

// It will return the state of service class.

// return EMgFree if it is free and ready to accept

// the another request else EMgBusy

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

EXPORT_C const TMgState& CMgService::State() const

	{

    return iState;

	}

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

// CMgService::SetSortingField

// It will set the metadata field on which the result

// should be sorted.

// Leave with KErrArgument if aSortField is not valid.

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

void CMgService::SetSortingFieldL(const TDesC8& aSortField ,

								  const TDesC8&  aOrder ,

								  const RArray<TInt>& aMediaTypes,

								  MCLFItemListModel* alistModel )

	{

	// Default sorting as per file name

	TCLFDefaultFieldId metaDataId = ECLFFieldIdFileName;

    TCLFItemDataType  metaDataType = ECLFItemDataTypeDesC;

    //Check If the aSortField is not NULL Descriptor i.e.

    // sorting metadata is specified

   	if( 0 != aSortField.CompareF( KNullDesC8 ) )

   		{

    	GetMetaDataIdAndType( aSortField,

    						  metaDataId,

    						  metaDataType,

    						  aMediaTypes );

	 	if( ECLFFieldIdNull == metaDataId ) // check the return type

	 	    {

	 	    // The given Sort Field  is not supported by Media Management SAPI

	 		User::Leave( KErrArgument );

	 		}

    	}

	iSortingStyle->ResetL();

 	//Set the field on which sorting has to perform

	iSortingStyle->AddFieldL( metaDataId );

	// Set the sorting field data type

	iSortingStyle->SetSortingDataType( metaDataType );

	if( 0 == aOrder.CompareF( KMgDescending ) )

		{

		iSortingStyle->SetOrdering( ECLFOrderingDescending  );

		}

	else if( 0 == aOrder.CompareF( KMgAscending) )

		{

		iSortingStyle->SetOrdering( ECLFOrderingAscending );

		}

	else

		{

		User::Leave( KErrArgument );

		}

	//Items with undefined fields are placed after items with defined fields

	iSortingStyle->SetUndefinedItemPosition( ECLFSortingStyleUndefinedEnd );

	// set sorting style in CLF.

	alistModel->SetSortingStyle( iSortingStyle );

	}

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

// CPostFilter::SetFilterMetaData

// Method to set the filter metadata

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

void CMgService::SetFilterMetaDataL( const TDesC8& aFilterField,

									 const TDesC& aStartVal,

									 const TDesC& aEndVal,

									 const RArray<TInt>& aMediaTypes, 

									 MCLFItemListModel* alistModel )

	{

	TCLFDefaultFieldId metaDataId;

    TCLFItemDataType  metaDataType;

    //Check If the Filter Meta Data is NULL Descriptor, if so

    // no filtration will be performed

    if( 0 == aFilterField.CompareF( KNullDesC8 ) )

    	{

       	metaDataId = ECLFFieldIdNull;

       	metaDataType = ECLFItemDataTypeDesC;	// Blank Descriptor

        iFilter->SetFilterMetaData( metaDataId, metaDataType );

   		}

    else

    	{

    	GetMetaDataIdAndType( aFilterField,

    						  metaDataId,

    						  metaDataType,

    						  aMediaTypes);

	 	if( ECLFFieldIdNull == metaDataId )

	 		{

	 		// The given metaData is not supported by Media Management SAPI

	 		User::Leave( KErrArgument );

	 		}

	 	iFilter->SetFilterMetaData( metaDataId, metaDataType );

       	// set filter value of CLF

	    iFilter->SetFilterValueL( aStartVal,aEndVal );

		// Set Post Filter in CLF

	    alistModel->SetPostFilter( iFilter );

	 	}

  	}

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

// CMgService::ConstuctL

// It will intialize the underlying CLF(Content Listing Framework)

// framework classes and CPostFilter class.

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

void CMgService::ConstructL()

	{

	// create the instance of CLF engine and store it in member data.

	iEngine = ContentListingFactory::NewContentListingEngineLC();

    CleanupStack::Pop();

    // create the instance of CPostFilter and store it in member data

    iFilter = CPostFilter::NewL();

    // Get the sorting style from CLF

	iSortingStyle = ContentListingFactory::NewSortingStyleLC();

 	CleanupStack::Pop();

 	//create the instance of clf observer

 	iClfObserver = CClfOperationObserver::NewL();

	}

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

// CMgService::CMgService

// Constructor

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

CMgService::CMgService()

          : iState( EMgFree ),

            iEngine( NULL ),

			iFilter( NULL ),

			iSortingStyle( NULL ),

			iClfObserver( NULL ),

			iTransactionID( 0 )

	{

	}

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

// CMgService::SetMediaTypeL

// It will convert the aFiletype string into

// equivalent Mediatype ID and Fill the Media Type Array

// if it is not valid then return KErrNotSupported

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

void CMgService::SetMediaTypeL (const TDesC8& aFileType,

								RArray<TInt>& aMediaType)

	{

	if( 0 == aFileType.CompareF( KMgMusic ) )

 		{

 	 	aMediaType.AppendL( ECLFMediaTypeMusic );

 	 	}

	else if( 0 == aFileType.CompareF( KMgSound ) )

 	 	{

 	 	aMediaType.AppendL( ECLFMediaTypeSound );

 	 	}

 	else if( 0 == aFileType.CompareF( KMgImage ) )

 	 	{

 	 	aMediaType.AppendL( ECLFMediaTypeImage );

 	 	}

 	else if( 0 == aFileType.CompareF( KMgVideo ) )

 	 	{

 	 	aMediaType.AppendL( ECLFMediaTypeVideo );

 	 	}

 	else if( 0 == aFileType.CompareF( KMgStreamingURL ) )

 	 	{

 	 	aMediaType.AppendL( ECLFMediaTypeStreamingURL );

 	 	}

 	else

 	 	{

 	 	User::Leave ( KErrArgument ); // Media Type Not suuported

 	 	}

   	}

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

// CMgService::SendRequestToCLF

// This Function will pass the request to CLF frame work for required media type.

// return KErrArgument if the FilterMetaData is not Supported

// return KErrArgument if the Start Value is not Supported

// return KErrArgument  if the End Value is mot supported

// return KErrNone if sucessful

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

void CMgService::SendRequestToClfL( const TDesC8& aFileType,

								    const TDesC8& aFilterField,

                				    const TDesC&  aStartVal,

                				    const TDesC&  aEndVal,

                				    const TDesC8& aSortField,

                				    const TDesC8&  aOrder,

                				    MCLFItemListModel* alistModel )

    {

	RArray<TInt> mediaTypes;

	CleanupClosePushL( mediaTypes );

	//check if it is a valid file type or not

	SetMediaTypeL( aFileType,mediaTypes );

	//set wanted media type in CLF

	alistModel->SetWantedMediaTypesL( mediaTypes.Array() );

	// Set Filter Meta Data  and Value

    SetFilterMetaDataL( aFilterField,aStartVal,aEndVal,mediaTypes,alistModel);

    // call set sorting field of CLF

    SetSortingFieldL( aSortField,aOrder,mediaTypes,alistModel );

 	// set the state = Busy

 	// till this request is complete

 	//which indicates no further request will be taken

 	iState = EMgBusy;

	//asynchronous call to CLF ECLFRefreshAll

 	alistModel->RefreshL();

 	CleanupStack::PopAndDestroy( &mediaTypes );

	}

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

// CMgService::GetMetaDataIdAndType

// It will convert the aFilterData string into equivalent Metadata ID and Type

// which is recognized by underlying framework.(i.e CLF)

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

void CMgService::GetMetaDataIdAndType(const TDesC8& aMetaData,

									  TCLFDefaultFieldId&  aMetaDataId,

          							  TCLFItemDataType& aMetaDataType,

          							  const RArray<TInt> &aMediaTypes)

	{

    //File name field

    if( 0 == aMetaData.CompareF( KMgFileName ))

    	{

    	aMetaDataType = ECLFItemDataTypeDesC;

    	aMetaDataId = ECLFFieldIdFileName;

    	}

    // File Extension

    else if( 0 == aMetaData.CompareF( KMgFileExtension ))

    	{

		aMetaDataType = ECLFItemDataTypeDesC;

		aMetaDataId = ECLFFieldIdFileExtension;

    	}

    // File path field

    else if( 0 == aMetaData.CompareF( KMgPath ))

    	{

		aMetaDataType = ECLFItemDataTypeDesC;

		aMetaDataId = ECLFFieldIdPath;

    	}

    // File drive field

    else if( 0 == aMetaData.CompareF( KMgDrive ))

    	{

		aMetaDataType = ECLFItemDataTypeDesC;

		aMetaDataId = ECLFFieldIdDrive;

	    }

    // File size field

    else if( 0 == aMetaData.CompareF( KMgFileSize ))

       	{

   		aMetaDataType = ECLFItemDataTypeTInt32;

   		aMetaDataId = ECLFFieldIdFileSize;

       	}

    // File date field

    else if( 0 == aMetaData.CompareF( KMgFileDate ))

    	{

		aMetaDataType = ECLFItemDataTypeTTime;

		aMetaDataId = ECLFFieldIdFileDate;

    	}

    // Mime type field

    else if( 0 == aMetaData.CompareF( KMgMimeType ))

    	{

		aMetaDataType = ECLFItemDataTypeDesC;

		aMetaDataId = ECLFFieldIdMimeType;