/*

* 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:  Interface to MCS service

 *

*/

#include "mcsdef.h"

#include "mcsservice.h"

#include "mcsgetlistimpl.h"

#include "mcsexecuteaction.h"

#include "mcsrunningapps.h"

#include "mcsrequestnotification.h"

#include "mcscallback.h"

#include "mcsconstants.h"

#include "debug.h"

#include "mcsupdateitem.h"

#include "mcsdeleteitem.h"

#include "mcsorganizeimpl.h"

//_LIT( KRunningStatus, "RunningStatus" );

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

// Two-phased constructor.

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

//

EXPORT_C CMCSService* CMCSService::NewL(const TDesC& aContent)

	{

	CMCSService* self = new (ELeave) CMCSService;

	CleanupStack::PushL( self );

	self->ConstructL(aContent);

	CleanupStack::Pop( self );

	return self;

	}

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

// Destructor.

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

//

CMCSService::~CMCSService()

	{

	if( iReqNotifier )

		{

		TRAP_IGNORE(iReqNotifier->StopNotificationL());

		delete iReqNotifier;

		iReqNotifier = NULL;

		}

	iOperationManager.Close();	

	iMCS.Close();

	delete iIgnoredAttributes;

	delete iRequiredAttributes;

	}

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

// Constructor.

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

//

CMCSService::CMCSService()

	{

    }

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

// Two-phased constructor.

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

//

void CMCSService::ConstructL(const TDesC& aContent)

	{

	iMCS.OpenL(aContent);

	iIsRegistered = EFalse;

	iIgnoredAttributes = new (ELeave) CDesC16ArrayFlat(1);

	iRequiredAttributes = new (ELeave) CDesC16ArrayFlat(8);

	}

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

// 

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

//

void CMCSService::SetFlagInMenuitemL( CLiwMap& aInputMap, 

		CMenuItem& aMenuitem, TMenuItem::TFlags aFlag)

	{

	TLiwVariant param;

	TPtrC8 key ( KNullDesC8 );

	switch ( aFlag )

		{

		case TMenuItem::ELockDelete:

			key.Set( KDeleteLocked );

			break;

		case TMenuItem::ELockName:

			key.Set( KNameLocked );

			break;

		case TMenuItem::ELockIcon:

			key.Set( KIconLocked );

			break;

		case TMenuItem::ELockMoveInto:

			key.Set( KMoveLocked  );

			break;

		case TMenuItem::ELockItem:

			key.Set( KAddingLocked );

			break;

		case TMenuItem::EHidden:

			key.Set( KHidden );

			break;	    	    	    	    	    

		case TMenuItem::EMissing:

			key.Set( KMissing );

			break;	    

		}

	if( aInputMap.FindL( key, param))

		{

		if (param.AsTBool())

			{

			aMenuitem.SetFlags(aFlag, ETrue);

			}

		else

			{

			aMenuitem.SetFlags(aFlag, EFalse);

			}

		aInputMap.Remove( key );

		param.Reset();

		}

	}

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

// Update item and its attributes.

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

//

EXPORT_C void   CMCSService::UpdateItemL(MMCSCallback* aCallBack, TDesC& aType, 

		TInt aId, TInt aParentId, TInt aBeforeId, CLiwMap& aInputMap)

	{

	TBuf8<KMenuMaxAttrNameLen> attrname;

	TBuf16<KMenuMaxAttrNameLen> attrname16;

	TBuf16<KMenuMaxAttrValueLen> paramValStr;

	TPtrC paramvalue;

	TLiwVariant param;

	if( !aCallBack )

		{

		User::Leave( KErrArgument );

		}

	CMenuItem* menuItem;

	// If if is zero then create new menu item

	if (!aId)

		{

		menuItem = CMenuItem::CreateL( iMCS, aType, aParentId, aBeforeId );

		}

	// Otherwise open existing menu item

	else

		{

		menuItem = CMenuItem::OpenL(iMCS, aId);

		}

	CleanupStack::PushL( menuItem ); 

	attrname.Copy(KMenuAttrRefId());  

	if( aInputMap.FindL( attrname, param))

		{

		paramValStr.Num( param.AsTInt32());

		aInputMap.Remove(attrname);

		menuItem->SetAttributeL(KMenuAttrRefId(), paramValStr);

		}

	else

		{

		if( aType == KMenuTypeLink)

			{

			User::Leave( KErrArgument );

			}

		}

	param.Reset();

	// Flags parsing

	SetFlagInMenuitemL( aInputMap, *menuItem, TMenuItem::ELockName);

	SetFlagInMenuitemL( aInputMap, *menuItem, TMenuItem::ELockIcon);

	SetFlagInMenuitemL( aInputMap, *menuItem, TMenuItem::ELockDelete);

	SetFlagInMenuitemL( aInputMap, *menuItem, TMenuItem::ELockMoveInto);

	SetFlagInMenuitemL( aInputMap, *menuItem, TMenuItem::ELockItem);

	SetFlagInMenuitemL( aInputMap, *menuItem, TMenuItem::EHidden);

	SetFlagInMenuitemL( aInputMap, *menuItem, TMenuItem::EMissing);

	for(TInt index = 0; index < aInputMap.Count(); index++)

		{

		aInputMap.AtL(index, attrname);

		aInputMap.FindL( attrname, param);

		paramvalue.Set(param.AsDes());

		attrname16.Copy(attrname);

		menuItem->SetAttributeL( attrname16,  paramvalue );

		param.Reset();

		}

	CMCSUpdateItem* updateAO = CMCSUpdateItem::NewL( *menuItem, aCallBack,

			iOperationManager );

	CleanupStack::PushL( updateAO );

	iOperationManager.AddL( updateAO );

	CleanupStack::Pop(updateAO);

	updateAO->UpdateItemL();

	CleanupStack::Pop(menuItem);

	}

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

// GetListL 

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

//

EXPORT_C void CMCSService::GetListL( const CLiwGenericParamList& aInParamList, MMCSCallback* aCallBack )

	{

	if( !aCallBack )

		{

		User::Leave( KErrArgument );

		}

	CMCSGetListImpl* getListAO = CMCSGetListImpl::NewL( iMCS, aCallBack, 

			iOperationManager );

	CleanupStack::PushL(getListAO);

	iOperationManager.AddL( getListAO );

	CleanupStack::Pop(getListAO);

	getListAO->GetListL( aInParamList );

	}

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

// GetRunningAppsL 

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

//

EXPORT_C  void CMCSService::GetRunningAppsL( MMCSCallback* aCallback ) 

	{

	if( !aCallback )

		{

		User::Leave( KErrArgument );

		}

	CMCSRunningApps* getRunningAppsAO = CMCSRunningApps::NewL( iMCS, aCallback, 

			iOperationManager );

	CleanupStack::PushL(getRunningAppsAO);

	iOperationManager.AddL( getRunningAppsAO );

	CleanupStack::Pop(getRunningAppsAO);

	getRunningAppsAO->GetRunningApplicationL();

	}

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

// ExecuteActionL 

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

//

EXPORT_C  void CMCSService::ExecuteActionL( MMCSCallback* aCallback, 

		TInt aItemId, TDesC8& aAction )

	{

	if( !aCallback )

		{

		User::Leave( KErrArgument );

		}

	CMCSExecuteAction* executeAO = CMCSExecuteAction::NewL( iMCS, aCallback, 

			iOperationManager );

	CleanupStack::PushL( executeAO );

	iOperationManager.AddL( executeAO );

	CleanupStack::Pop(executeAO);

	executeAO->ExecuteActionL( aItemId, aAction);

	}

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

// DeleteL 

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

//

EXPORT_C void CMCSService::DeleteL( MMCSCallback* aCallBack, TInt aItemId )

	{

	if( !aCallBack )

		{

		User::Leave( KErrArgument );

		}

	CMCSDeleteItem* deleteAO = CMCSDeleteItem::NewL( iMCS, aCallBack,

			iOperationManager );

	CleanupStack::PushL(deleteAO);

	iOperationManager.AddL( deleteAO );

	CleanupStack::Pop(deleteAO);

	deleteAO->DeleteItemL( aItemId );

	}

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

// Set GetRunningAppsL output to output parameter

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

//                         

EXPORT_C void CMCSService::SetRunningAppsOutputL( RArray<TUid>& aOutputArray, 

		CLiwGenericParamList& aOutParamList )

	{

	//List of Maps

	TBuf8<KMenuMaxAttrNameLen> attrname;

	CLiwDefaultList *list = CLiwDefaultList::NewL();

	CleanupStack::PushL( list );

	TInt arrCount = aOutputArray.Count();

	for( TInt index = 0; index < arrCount; ++index )

		{  

		CLiwDefaultMap* map = CLiwDefaultMap::NewLC(); 

		TUid auid = aOutputArray[index];

		attrname.Copy(KMenuAttrUid());

		map->InsertL( attrname, TLiwVariant( (TInt32) aOutputArray[index].iUid ));

		list->AppendL( TLiwVariant( map ) );

		CleanupStack::PopAndDestroy( map );        

		}

	aOutParamList.AppendL( TLiwGenericParam( KReturnValue, TLiwVariant( list ) ) );

	CleanupStack::Pop( list );

	list->DecRef();

	}

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

// Organize

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

//

EXPORT_C void CMCSService::OrganizeL( MMCSCallback* aCallBack, 

		TInt aMoveItemId, TInt aBeforeItemId )

	{

	if( !aCallBack )

		{

		User::Leave( KErrArgument );

		}

	CMCSOrganizeImpl* organizeAO = CMCSOrganizeImpl::NewL( iMCS, aCallBack,

			iOperationManager );

	CleanupStack::PushL( organizeAO );

	iOperationManager.AddL( organizeAO );

	CleanupStack::Pop( organizeAO );// we pop item from cleanupstack because

	//ownership was transfered to operation manager                                                         

	organizeAO->OrganizeL( aMoveItemId, aBeforeItemId );

	}

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

// Organize

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

//

EXPORT_C void CMCSService::OrganizeL( MMCSCallback* aCallBack, 

		const RArray<TInt>& aList, TInt aFolderId, TInt aBeforeItemId )

	{

	if( !aCallBack )

		{

		User::Leave( KErrArgument );

		}

	CMCSOrganizeImpl* organizeAO = CMCSOrganizeImpl::NewL( iMCS, aCallBack,

			iOperationManager );

	CleanupStack::PushL( organizeAO );

	iOperationManager.AddL( organizeAO );

	CleanupStack::Pop( organizeAO );// we pop item from cleanupstack because

	//ownership was transfered to operation manager

	organizeAO->OrganizeL( aList, aFolderId, aBeforeItemId );

	}

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

// Set RequestNotification output to output parameter

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

//   

EXPORT_C void CMCSService::SetReqNotificationOutputL( TInt aFolderId,

		TInt aEvent, CLiwGenericParamList& aOutParamList )

	{

	TBuf8<KMenuMaxAttrNameLen> attrname;

	CLiwDefaultMap* map = CLiwDefaultMap::NewLC();

	attrname.Copy(KMenuAttrId());

	map->InsertL( attrname, TLiwVariant( (TInt32)aFolderId));

	if(aEvent & RMenuNotifier::EItemsAddedRemoved)

		{

		map->InsertL( KAddRemove, TLiwVariant( (TBool) ETrue) );

		}

	if( aEvent & RMenuNotifier::EItemsReordered)

		{

		map->InsertL( KReorder, TLiwVariant( (TBool) ETrue) );

		}

	if( aEvent & RMenuNotifier::EItemAttributeChanged)

		{

		map->InsertL( KAttributeChange, TLiwVariant( (TBool) ETrue) );

		}

	aOutParamList.AppendL( TLiwGenericParam( KReturnValue, TLiwVariant( map ) ) );

	CleanupStack::PopAndDestroy( map );

	}

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

// Stop Notification for changes in mcs

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

//

EXPORT_C void CMCSService::UnRegisterObserverL()

	{

	if ( iReqNotifier == NULL )

		{

		User::Leave( KErrNotFound );  

		}

	iReqNotifier->StopNotificationL();

	delete iReqNotifier;

	iReqNotifier = NULL;

	iIsRegistered = EFalse;

	}

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

// Start Notification for changes in mcs

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

//

EXPORT_C void CMCSService::RegisterObserverL(TInt aFolderId,TInt aEvents,MMCSCallback* aCallBack )

	{

	if( !aCallBack )

		User::Leave( KErrArgument );

	if(!iIsRegistered)

		{

		iReqNotifier = CMCSReqNotification::NewL( iMCS );

		iIsRegistered = ETrue;

		}

	iReqNotifier->StartNotificationL(aFolderId, aEvents, aCallBack);

	}