/*

* 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"

// Inclusion for thumbnail generation

#include"mgthumbnailgeneration.h"

#include"mgthumbobserver.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

    if(iSortingStyle)

        {

        delete iSortingStyle;

        }

        // release clf observer class

        {

        delete iClfObserver;

        }

        //release iEngine;

    if(iEngine)

        {

        delete iEngine;

        }

        // releasing iTumbnailGeneration

    if(iTumbnailGeneration)

        {

        delete iTumbnailGeneration;

        }

	}

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

// 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( NULL != aServiceObserver )//Asynchronous request

			{

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

   	 	    MCLFItemListModel* listModel = iEngine->

		    SendRequestToClfL( aInParameters.iFileType,

		    				   aInParameters.iFilterField,

		    				   aInParameters.iStartVal,

		    				   aInParameters.iEndVal,

		    				   aInParameters.iSortField,

		    				   aInParameters.iOrder,

			}

		else

			{

			//Synchronous request handling is currently not supported

			User::Leave( KErrNotSupported );

	}

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

// 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( aTransactionID == iTransactionID )

		    {

		    iClfObserver->CancelL( );

		    Clear();

		    return KErrNone;

	    	}

		}

// Calling cancel of thumbnail

	    {

	    return CancelThumbnailReq(aTransactionID);

	    }

	}

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

// CMgService::CancelThumbnailReq

// Cancel the pending asynchronous request for thumbnail generation

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

TInt  CMgService::CancelThumbnailReq( TUint aTransactionID )

    {

    return iTumbnailGeneration->Cancel(aTransactionID);

    }

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

// CMgService::Clear

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

//	function and sorting fields

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

void CMgService::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,

	{

	// 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 );

	 		}

    	}

 	//Set the field on which sorting has to perform

	// Set the sorting field data type

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

		{

		}

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

		{

		}

	else

		{

		User::Leave( KErrArgument );

		}

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

	// set sorting style in CLF.

	}

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

// CPostFilter::SetFilterMetaData

// Method to set the filter metadata

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

void CMgService::SetFilterMetaDataL( const TDesC8& aFilterField,

									 const TDesC& aStartVal,

									 const TDesC& aEndVal,

									 const RArray<TInt>& aMediaTypes, 

	{

	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

   		}

    else

    	{

    	GetMetaDataIdAndType( aFilterField,

    						  metaDataId,

    						  metaDataType,

    						  aMediaTypes);

	 	if( ECLFFieldIdNull == metaDataId )

	 		{

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

	 		User::Leave( KErrArgument );

	 		}

       	// set filter value of CLF

		// Set Post Filter in CLF

	 	}

  	}

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

// 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();

	}

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

// CMgService::CMgService

// Constructor

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

CMgService::CMgService()

          : iState( EMgFree ),

            iEngine( NULL ),

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

// 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)

	{

 		{

 	 	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,

    {

	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() );