/*

* 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 interface for

*				 calling the functionality to Media Management SAPI.

*  Interafce

*

*/

#include <liwcommon.h>

#include <utf.h>

#include "mginterface.h"

#include "mgservice.h"

#include "mgserviceobserver.h"

#include "serviceerrno.h"

#include"mgservicethumbnailobserver.h"

//using namespace LIW;

//Supported Operation

_LIT8(KGetList,"GetList");

_LIT8(KCmdCancel,"Cancel");

_LIT8(KGetThumbnail,"GetThumbnail"); 

//Input Keys/arguments

// for Url

_LIT8(KUrl,"Url");

// thumbnailsize

_LIT8(KThumbnailSize,"ThumbnailSize");

// Width

_LIT8(KWidth,"width");

//height

_LIT8(KHeight,"height");

// Data source name

_LIT8(KDsName,"Type");

// Filter Map

_LIT8(KFilter,"Filter");

// Sorting Map

_LIT8(KSort,"Sort");

//Required file type

_LIT8(KFileType,"FileType");

//Filter criteria

_LIT8(KKey,"Key");

//Start range of filter

_LIT8(KStartRange,"StartRange");

//End range of filter

_LIT8(KEndRange,"EndRange");

//Sorting order

_LIT8(KOrder,"Order");

//Possible DataSource or supported operation

_LIT(KFile,"FileInfo");

_LIT(KFileInfo,"FileInfo");

//Output Keys/arguments

_LIT8(KErrorCode,"ErrorCode");

_LIT8(KErrorMessage,"ErrorMessage");

_LIT8(KTransactionID,"TransactionID");

_LIT(KCmdInvalid, 	 "Command Not Supported");

_LIT(KMissing,		 " is missing");

_LIT(KMissingOrInvalid,		 " is missing/invalid");

_LIT(KInvalid,		 " is invalid");

_LIT(KNotSupported,	 " not supported");

_LIT(KInvalidAsyncParam,"Insufficient arguments for async request");

_LIT(KInvalidCancelParam,"Cancel bit not set in aCmdOptions");

_LIT(KServerBusy,	"Server busy");

//_LIT(KTypeMismatch, " Type mismatch");

// Constants for Error Message

_LIT(KErrorMsgSeparator, 	" : ");

_LIT(KDomainName, 			"MediaMgmt");

// Lenght for media file path 

const TInt KFilePath = 230;

const TInt KNegVal = -1;

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

// CMgInterface::NewLC

// Returns the instance of CMgInterface.

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

CMgInterface* CMgInterface::NewL()

	{

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

	CleanupStack::PushL( self );

	self->ConstructL();

	CleanupStack::Pop( self );

	return self;

	}

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

// CMgInterface::~CMgInterface

// Destructor of class

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

CMgInterface::~CMgInterface()

	{

    //Release the instance of service observer class

	//Release the instance of core class

    delete iCoreClass;

	iCoreClass = NULL;

	}

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

// CMgService::ExecuteCmdL

// Request handler method of interface class

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

void CMgInterface::ExecuteCmdL(const TDesC8& aCmdName,

                           const CLiwGenericParamList& aInParamList,

                           CLiwGenericParamList& aOutParamList,

                           TUint aCmdOptions ,

                           MLiwNotifyCallback* aCallBack)

	{

    TInt32 transactionID = 0;

	TInt errCode = 0;

	TInt pos = 0;

	TPtrC dsName(KNullDesC);

    const TLiwGenericParam* param = NULL;

    TLiwGenericParam posbasedparam;

    TBool postionbasedsearching = EFalse;

    TPtrC url(KNullDesC);

    TPtrC thumbnailsize(KNullDesC);

    if( 0 == aCmdName.CompareF( KCmdCancel ) )

	    {

	    if( aCmdOptions & KLiwOptCancel ) // for cancel asynchronous request

			{

			param = aInParamList.FindFirst( pos, KTransactionID );

			if( ( !param ) && ( aInParamList.Count() > 0) )

			    {

			    pos = 0;

			    aInParamList.AtL( pos, posbasedparam );

			    if ( posbasedparam.Name().Compare(KNullDesC8) != 0 || posbasedparam.Value().IsEmpty() )

			        {

			        param = NULL;

			        }

			    else

			        {

			        param = &posbasedparam;

			        }

			    }

			if( param )

			    {

			    if ((*param).Value().Get( transactionID ))

			        {

				    errCode = iCoreClass->CancelL( transactionID );   

					if ( KErrNone != errCode )

				        {

				        TInt sapiErr = SapiError(errCode);

				        AppendErrorMessageL( aCmdName, KTransactionID, KInvalid );

				        aOutParamList.AppendL( TLiwGenericParam ( KErrorMessage,TLiwVariant( iErrorMessage ) ) );

				        aOutParamList.AppendL(TLiwGenericParam(KErrorCode,TLiwVariant((TInt32)sapiErr)));

			        	}

					else

					    {

                        TInt sapiErr = SapiError(errCode);

                        aOutParamList.AppendL(TLiwGenericParam(KErrorCode,TLiwVariant((TInt32)sapiErr)));

					    }

				    }

				else

				    {

				    AppendErrorMessageL( aCmdName, KTransactionID, KInvalid );

				    aOutParamList.AppendL( TLiwGenericParam ( KErrorMessage,TLiwVariant( iErrorMessage ) ) );

				    aOutParamList.AppendL( TLiwGenericParam ( KErrorCode,TLiwVariant( TInt32( SErrBadArgumentType ) ) ) );

				    }   

			    }

			else

			    {

			    AppendErrorMessageL( aCmdName, KTransactionID, KMissing );

			    aOutParamList.AppendL( TLiwGenericParam ( KErrorMessage,TLiwVariant( iErrorMessage ) ) );

			    aOutParamList.AppendL( TLiwGenericParam ( KErrorCode,TLiwVariant( TInt32( SErrMissingArgument ) ) ) );

			    }

			}

		else

			{

			AppendErrorMessageL( aCmdName, KNullDesC8, KInvalidCancelParam );			        

			aOutParamList.AppendL( TLiwGenericParam ( KErrorMessage,TLiwVariant( iErrorMessage ) ) );

			aOutParamList.AppendL( TLiwGenericParam ( KErrorCode,TLiwVariant( TInt32( SErrBadArgumentType ) ) ) );	

			}

	    return;	

	    }

	// Check the command name;Cmd name should be GetList

	else if( 0 == aCmdName.CompareF( KGetList ) )

		{

		pos = 0 ;

		param = aInParamList.FindFirst( pos, KDsName );

	    if( ( !param ) && ( aInParamList.Count() > 0 ) )

            {

            pos = 0;

            aInParamList.AtL( pos,posbasedparam );

            if ( (posbasedparam.Name().CompareF(KNullDesC8) != 0 ) || posbasedparam.Value().IsEmpty() ) 

                {

                param = NULL;

                }

            else

                {

                param = &posbasedparam;

                postionbasedsearching = ETrue;

                }

            }

		if(param)

			{

	    	if ((*param).Value().Get( dsName ))

	    	    {

	    	    //dsName.Set((*param).Value().AsDes());

			    if( ( 0 == dsName.CompareF( KFileInfo )  )

				    || ( 0 == dsName.CompareF( KFile ) )  )

				    {

				// check if core class ready to accept request

					    if( aCmdOptions & KLiwOptASyncronous ) //Asynchronous request

						    {

						    if( NULL != aCallBack ) // Asynchronous call

								{

								transactionID = aCallBack->GetTransactionID();

							   	 //Sending request to core class

						        }

							else		//Callback  missing

								{

								AppendErrorMessageL( aCmdName, KNullDesC8, KInvalidAsyncParam );

								errCode = KErrNotFound;

								}

							}

						else //synchronous request

							{

						    //synch request currently not supported

						    AppendErrorMessageL( aCmdName, KNullDesC8, KInvalidAsyncParam );

						    errCode = KErrNotFound;

							}//synchronous request

				    else

				        {

				        AppendErrorMessageL( aCmdName, KNullDesC8, KServerBusy );

				        errCode = KErrServerBusy;

					}//Data Source support

				else

				    {

				    //Incorrect Data source

				    AppendErrorMessageL( aCmdName, KDsName, KNotSupported );

				    errCode = KErrNotSupported;

				    }

		    	}//DataType Mismatch

	    	else

	    	    {

	    	    AppendErrorMessageL( aCmdName, KDsName, KInvalid );

			    errCode = KErrArgument;   

	    	    }

		    }//datasource missing

		else

		    {

		    AppendErrorMessageL( aCmdName, KDsName, KMissing );

		    errCode = KErrNotFound;

		    }

		}//GetList

	else if(0 == aCmdName.CompareF( KGetThumbnail ))// Here we need to put implementation  for getThumbnail

	    {

	      //Call 

	        if( (aCmdOptions & KLiwOptASyncronous ) && ( NULL != aCallBack ) ) //Asynchronous request

	            {

	            //Asynch Call

	            transactionID = aCallBack->GetTransactionID();

	            TInt err =0;

	            TRAP(err,GetThumbnailL( aInParamList, aOutParamList, aCallBack , transactionID ));

	            errCode = err;

	            }

		        else

	            {

	            AppendErrorMessageL( aCmdName, KNullDesC8, KInvalidAsyncParam );

                errCode = KErrNotFound;

	            }    

	    }// GetThumbnail

	else   

	    {

	    AppendErrorMessageL( aCmdName, KNullDesC8, KCmdInvalid );

	    errCode = KErrNotSupported; //command not supported

	    }

	// check error code if any error occurs then insert into output list

    posbasedparam.Reset();

    TInt sapiErr = SErrNone;

    if (errCode)

    	{

    	sapiErr = SapiError(errCode);

    	}

    aOutParamList.AppendL(TLiwGenericParam(KErrorCode,TLiwVariant((TInt32)sapiErr)));

	if ( iErrorMessage )

		{

		aOutParamList.AppendL(TLiwGenericParam( KErrorMessage, 

									TLiwVariant(iErrorMessage->Des())));

		delete iErrorMessage;

		iErrorMessage = NULL;		

		}

	aOutParamList.AppendL( TLiwGenericParam( KTransactionID, TLiwVariant( (TInt32)transactionID ) ) );

	}

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

// CMgInterface::CMgInterface

// Constructor  of class

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

CMgInterface::CMgInterface()

	{

	}

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

// CMgInterface::ConstructL

// Two-phased constructor of class

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

void CMgInterface::ConstructL()

	{

	// Create the instance of core class

	iCoreClass = CMgService::NewL();

	//Create the instance of service observer class

	}

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

// CMgInterface::SendRequestL

// This function will send the request to Core class

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

	{

	TInt   pos=0;

	const CLiwMap* filter = NULL;

    const CLiwMap* sorting = NULL;

 	TMgServiceRequest requestParam;

	const TLiwGenericParam* param;

	TLiwVariant fileType;

	TLiwVariant filterField;

	TLiwVariant startVal;

	TLiwVariant endVal;

	TLiwVariant sortingField;

	TLiwVariant order;

	TLiwGenericParam posbasedparam;

	//setting the TransactionID

    requestParam.iTransactionID = aTransactionID;

    //Get the Filter Map

    if ( aPostionBasedSearching && ( aInParamList.Count() > 1) )

        {

         pos = 1;

         aInParamList.AtL( pos,posbasedparam );

         if ( (posbasedparam.Name().CompareF(KNullDesC8) != 0 ) || posbasedparam.Value().IsEmpty() ) 

             {

             param = NULL;

             }

         else

             {

             param = &posbasedparam;

             }

        }

    else

        {

        pos=0;//Search from starting point

        //filter map

        param =  aInParamList.FindFirst( pos, KFilter );

        }

	HBufC8* heapBuffer3 = NULL;

	HBufC8* heapBuffer4 = NULL;

    if(param)

        {

        filter = (*param).Value().AsMap();

        if(!filter)

            {

            //Filter Map missing : 

            posbasedparam.Reset();

            AppendErrorMessageL( KGetList, KFilter, KInvalid );

  	        User ::Leave(KErrArgument);

            }

        }

    if( (param) &&  (filter) )

        {//filter map

	    TPtrC type16;

	    CleanupStack::PushL( TCleanupItem( TLiwVariant::VariantCleanup , &fileType) );	    

	    if( (filter->FindL( KFileType, fileType )) )

	        {

	        if ( (fileType.Get( type16 ))  && (type16.Length() > 0 ) )

		        {

		        heapBuffer3 = HBufC8::NewL( type16.Length() );

	            CleanupStack::PushL( heapBuffer3 );

	            TPtr8 type8( heapBuffer3->Des() );

	            type8.Copy( type16 );

	            requestParam.iFileType.Set(type8);

		        }

	    	else

		        {

		        //fileType.Reset();

		        posbasedparam.Reset();

		        AppendErrorMessageL( KGetList, KFileType, KMissingOrInvalid );

		        User ::Leave(KErrArgument);

	            }

	        }

	    else

	        {

	        //fileType.Reset();

		    posbasedparam.Reset();

		    AppendErrorMessageL( KGetList, KFileType, KMissing );

		    User ::Leave(KErrNotFound);  

	        } 

		CleanupStack::PushL( TCleanupItem( TLiwVariant::VariantCleanup , &filterField) );	       

	    if( filter->FindL( KKey, filterField ) )

	        {

	        TPtrC filter16;

	        if ( filterField.Get( filter16 ))

	            {

		        heapBuffer4 = HBufC8::NewL( filter16.Length() );

	            CleanupStack::PushL( heapBuffer4 );

	            TPtr8 filter8( heapBuffer4->Des() );

	            filter8.Copy( filter16 );

	            requestParam.iFilterField.Set(filter8);

		        }

		    else

		        {

		        //fileType.Reset();

		        //filterField.Reset();

		        posbasedparam.Reset();

		        AppendErrorMessageL( KGetList, KKey, KInvalid );

		        User ::Leave(KErrArgument);

		        }

	        }

 	    CleanupStack::PushL( TCleanupItem( TLiwVariant::VariantCleanup , &startVal) );

 	    if(filter->FindL( KStartRange, startVal ))

 	        {

 	        if ( !startVal.Get( requestParam.iStartVal ))

 	            {

 	            //fileType.Reset();

		        //filterField.Reset();

		        //startVal.Reset();

		        posbasedparam.Reset();

		        AppendErrorMessageL( KGetList, KStartRange, KInvalid );

		        User ::Leave(KErrArgument);

 	            }

 	        }