/*
* Copyright (c) 2008 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 <e32base.h>
#include <e32def.h>
#include "mcsdef.h"
#include "mcsmenufilter.h"
#include "mcsmenuitem.h"

#include "serviceerrno.h"
#include "mcsservice.h"
#include "mcsmcinterface.h"
#include "mcscallback.h"
#include "mcsconstants.h"

// ---------------------------------------------------------------------------
// Two-phased constructor.
// ---------------------------------------------------------------------------
//
CMCSMCInterface* CMCSMCInterface::NewL(const TDesC& aContent)
	{
	CMCSMCInterface* self = new (ELeave) CMCSMCInterface();
	CleanupStack::PushL(self);
	self->ConstructL(aContent);
	CleanupStack::Pop(self);
	return self;
	}
// ---------------------------------------------------------------------------
// Destructor.
// ---------------------------------------------------------------------------
//	
CMCSMCInterface::~CMCSMCInterface()
	{
	delete iMCSService;
	}

// ---------------------------------------------------------------------------
// Constructor
// ---------------------------------------------------------------------------
//
CMCSMCInterface::CMCSMCInterface()
	{
	}

// ---------------------------------------------------------------------------
// Symbian Constructor
// ---------------------------------------------------------------------------
//	
void CMCSMCInterface::ConstructL(const TDesC& aContent)
	{
	iMCSService = CMCSService::NewL(aContent);
	}

// ---------------------------------------------------------------------------
//  Executes the SAPI as per params
// ---------------------------------------------------------------------------
//
void CMCSMCInterface::ExecuteCmdL(const TDesC8& aCmdName,
		const CLiwGenericParamList& aInParamList,
		CLiwGenericParamList& aOutParamList, TUint aCmdOptions,
		MLiwNotifyCallback* aCallback)
	{
	TInt errcode = KErrNotSupported;
	TInt32 transactionId = -1;

	aOutParamList.AppendL(TLiwGenericParam(KErrorCode,
			TLiwVariant(ErrCodeConversion(KErrNone))));
	
	if ( !aCallback )
		{
		// Callback is a null pointer
		errcode = KErrArgument;
		}
	else
		{
		if (aCmdName.CompareF(KCmdExecuteAction) == 0)
			{
			TRAP(errcode, ExecuteActionL( aInParamList, aCallback ));
			}
		else if (aCmdName.CompareF(KcmdRunningApps) == 0)
	        {
			TRAP(errcode, GetRunningAppsL( aInParamList, aCallback ));
			}
		else if (aCmdName.CompareF(KCmdOrganize) == 0)
			{
			aOutParamList.Reset();
			TRAP(errcode, OrganizeL( aInParamList, aOutParamList, aCallback ));
			}
		
		// Append transaction id in case of asynchronous requests 
		if ( (KLiwOptASyncronous & aCmdOptions ) && (errcode
				== KErrNone ) && (transactionId != -1 ))
			{
			aOutParamList.AppendL(TLiwGenericParam(KTransactionID,
					TLiwVariant(TInt32(transactionId))));
			}
		}

	if (errcode != KErrNone)
		{
		aOutParamList.Reset();
		aOutParamList.AppendL(TLiwGenericParam(KErrorCode,
				TLiwVariant(ErrCodeConversion(errcode))));
		}
	}

// ---------------------------------------------------------------------------
// Closes the interface
// ---------------------------------------------------------------------------
//
void CMCSMCInterface::Close()
	{
	delete this;
	}

// ---------------------------------------------------------------------------
// Closes the interface
// ---------------------------------------------------------------------------
//
void CMCSMCInterface::GetRunningAppsL(const CLiwGenericParamList& aInParamList,
		MLiwNotifyCallback* aCallback)
	{
	CMCSCallback* cb = CMCSCallback::NewL(aCallback, aInParamList,
			aCallback->GetTransactionID(), *iMCSService,
			CMCSCallback::EGetRunningApps);
	CleanupStack::PushL(cb);
	iMCSService->GetRunningAppsL(cb);
	CleanupStack::Pop(cb);

	}
// ---------------------------------------------------------------------------
// Execute actions 
// ---------------------------------------------------------------------------
//
void CMCSMCInterface::ExecuteActionL(const CLiwGenericParamList& aInParamList,
		MLiwNotifyCallback* aCallback)
	{
	TLiwVariant param;
	TInt32 itemId = -1;
	TInt pos = 0;
	TPtrC8 action;
	TBuf8<KMenuMaxAttrNameLen> buf8;

	const TLiwGenericParam* inParam = aInParamList.FindFirst(pos, KInData);

	if (inParam)
		{
		const CLiwMap* inputMap = inParam->Value().AsMap();
		if (inputMap)
			{
			// Item Id
			buf8.Copy(KMenuAttrId());
			if (inputMap->FindL(buf8, param))
				{
				itemId = param.AsTInt32();
				}
			param.Reset();
			// Action 
			if (inputMap->FindL(KAction, param))
				{
				action.Set(param.AsData());
				if (param == KActionOpen() )
					{
					action.Set(KMenuCmdOpen());
					}
				else
					if (param == KActionRemove() )
						{
						action.Set(KMenuCmdRemove());
						}
					else
						{
						itemId = -1;
						}
				}
			else
				{
				itemId = -1;
				}
			param.Reset();
			}
		}

	if (itemId == -1)
		{
		User::Leave(KErrArgument);
		}
	else
		{
		CMCSCallback* cb = CMCSCallback::NewL(aCallback, aInParamList,
				aCallback->GetTransactionID(), *iMCSService,
				CMCSCallback::EExecuteAction);
		CleanupStack::PushL(cb);
		iMCSService->ExecuteActionL(cb, itemId, action);
		CleanupStack::Pop(cb);
		}
	}

// ---------------------------------------------------------------------------
// GetParamFromMap
// ---------------------------------------------------------------------------
//
TBool CMCSMCInterface::GetParamFromMapL( const CLiwMap* aInputMap,
		const TDesC8& aParamName, RArray<TInt>& aOutputList )
	{
	TBool status = EFalse;
	TLiwVariant param;
	param.PushL();
	if ( aInputMap->FindL ( aParamName, param ) )
		{
		const CLiwList* paramList = param.AsList();
		if(paramList)
			{
			for (TInt i = 0; i < paramList->Count(); i++)
				{
				TLiwVariant variant;
				variant.PushL();
				if (paramList->AtL(i, variant) )
					{
					TInt value = 0;
					if (variant.Get(value) )
						{
						aOutputList.AppendL( value );
						}
					}
				CleanupStack::PopAndDestroy( &variant );
				}
			}
		}
	CleanupStack::PopAndDestroy( &param );
	
	if( aOutputList.Count() > 0 )
		{
		status = ETrue;
		}
		
	return status;
	}

// ---------------------------------------------------------------------------
// GetParamFromMap
// ---------------------------------------------------------------------------
//
TBool CMCSMCInterface::GetParamFromMapL( const CLiwMap* aInputMap,
		const TDesC8& aParamName, TInt& aOutputValue )
	{
	TBool status = EFalse;
	TLiwVariant param;
	param.PushL();
	if ( aInputMap->FindL( aParamName, param ) )
		{
		param.Get( aOutputValue );
		status = ETrue;
		}
	CleanupStack::PopAndDestroy( &param );
	return status;
	}

// ---------------------------------------------------------------------------
// Organize 
// ---------------------------------------------------------------------------
//
void CMCSMCInterface::OrganizeL( const CLiwGenericParamList& aInParamList,
		                         CLiwGenericParamList& aOutParamList, 
		                         MLiwNotifyCallback* aCallback )
	{
	TInt errcode = KErrArgument;
	TBuf8<KMenuMaxAttrNameLen> attrname;
	TBuf16<KMenuMaxAttrValueLen> paramType;
	TInt pos = 0;
	
	const TLiwGenericParam* inParam = aInParamList.FindFirst(pos, KInData);
	if (inParam)
		{
		const CLiwMap* inputMap = (CLiwMap*)inParam->Value().AsMap();
		if (inputMap)
			{			
			RArray<TInt> list;
			TInt beforeItemId = 0;
            TInt folderId = 0;
			CleanupClosePushL( list );
			if( GetParamFromMapL( inputMap, KItemIds, list ) )
				{
				GetParamFromMapL( inputMap, KBeforeItemId, beforeItemId );
				
				CMCSCallback* cb = CMCSCallback::NewL( aCallback, aInParamList,
					aCallback->GetTransactionID(), *iMCSService,
					CMCSCallback::EOrganize );

				CleanupStack::PushL(cb);
				if( GetParamFromMapL( inputMap, KFolderId, folderId ) )
					{
					iMCSService->OrganizeL( cb, list, folderId, beforeItemId );
					}
				else
					{
					iMCSService->OrganizeL( cb, list[0], beforeItemId );
					}
				CleanupStack::Pop(cb);
				errcode = KErrNone; 
				}

			CleanupStack::PopAndDestroy( &list );
			}
		}

	aOutParamList.AppendL( TLiwGenericParam( KErrorCode,
    		TLiwVariant( ErrCodeConversion( errcode ) ) ) );
	}

// ---------------------------------------------------------------------------
// ErrCode Conversion
// ---------------------------------------------------------------------------
//
TInt32 CMCSMCInterface::ErrCodeConversion(TInt code)
	{
	TInt32 err;
	switch (code)
		{
		case KErrCancel:
			// Returning KErrNone incase of KErrCancel
		case KErrNone:
			err= SErrNone;
			break;

		case KErrNotFound:
			err= SErrNotFound;
			break;

		case KErrNoMemory:
			err = SErrNoMemory;
			break;

		case KErrInUse:
			err = SErrServiceInUse;
			break;

		case KErrNotSupported:
			err = SErrServiceNotSupported;
			break;

		case KErrBadName:
			err = SErrBadArgumentType;
			break;

		case KErrArgument:
			err = SErrInvalidServiceArgument;
			break;

		default:
			err = SErrGeneralError;
			break;
		}

	return err;
	}

// End of file