/*
* 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 "mcsmenunotifier.h"

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


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

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

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

// ---------------------------------------------------------------------------
//  Executes the SAPI as per params
// ---------------------------------------------------------------------------
//
void CMCSDSInterface::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( KCmdAdd ) == 0 ) 
			{
			TRAP(errcode, AddItemL( aInParamList, aCallback ));
			}
		else if ( aCmdName.CompareF( KCmdDelete ) == 0 ) 
			{
			  TRAP(errcode, DeleteL( aInParamList, aCallback ));
			}
		else if ( aCmdName.CompareF( KCmdGetList ) == 0 ) 
			{
			TRAP(errcode, GetListL( aInParamList, aCallback ));
			}
		else if ( aCmdName.CompareF( KCmdReqNotification ) == 0 ) 
			{
			if( aCallback && !(aCmdOptions & KLiwOptCancel) )
	            {
	            TRAP(errcode, RequestNotificationL(aInParamList, aCallback));
	            }
	        if ( aCmdOptions & KLiwOptCancel )
	            {
	            TRAP(errcode, iMCSService->UnRegisterObserverL());
	            }
			
			}
		
		// 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 CMCSDSInterface::Close()
	{
	delete this;
	}

// ---------------------------------------------------------------------------
// Issues Add a new Item request to MCSService
// ---------------------------------------------------------------------------
//
void CMCSDSInterface::AddItemL( const CLiwGenericParamList& aInParamList, 
                              MLiwNotifyCallback* aCallback )
    {
    TInt32 itemId = 0;
    TInt32 parentId = 0;
    TInt32 beforeId = 0;    
    TInt pos = 0;
    TPtrC paramvalue;

    TBuf16<KMenuMaxAttrValueLen> paramValStr;
    TBuf16<KMenuMaxAttrNameLen> attrname16;
    TBuf8<KMenuMaxAttrNameLen> attrname;
    TBuf16<KMenuMaxAttrValueLen> paramType;
    TLiwVariant param;    
    
    const TLiwGenericParam* inParam = aInParamList.FindFirst( pos, KInData );
    if (inParam)
        {
        CLiwMap* inputMap = (CLiwMap*)inParam->Value().AsMap();
        if ( inputMap )
           {
           attrname.Copy(KMenuAttrId());
           if( inputMap->FindL( attrname, param))
        	   {
        	   param.Get(itemId);
        	   inputMap->Remove( attrname );
        	   }
           param.Reset();
           if( inputMap->FindL( KParentId, param))
        	   {
        	   param.Get(parentId);
        	   inputMap->Remove( KParentId );
        	   }
           param.Reset();

           if( inputMap->FindL( KBeforeId, param))
        	   {
        	   param.Get(beforeId);
        	   inputMap->Remove(KBeforeId);
        	   }
           param.Reset();
           if( inputMap->FindL( KType, param))
        	   {
        	   paramType.Copy(param.AsDes());
        	   inputMap->Remove( KType ); 
        	   }
           param.Reset();
           
           CMCSCallback* cb = CMCSCallback::NewL(aCallback, aInParamList, 
                   aCallback->GetTransactionID(), *iMCSService,CMCSCallback::EAddORChange );
           CleanupStack::PushL(cb);
           iMCSService->UpdateItemL(cb, paramType, itemId, parentId, beforeId, *inputMap);
           CleanupStack::Pop(cb);
           }
        else
        	{
        	User::Leave(KErrArgument);
        	}
        }
    else
        {             
       User::Leave(KErrArgument);
        }
    }
           
// ---------------------------------------------------------------------------
// Issues GetList request to MCSService
// ---------------------------------------------------------------------------
//
void CMCSDSInterface::GetListL( const CLiwGenericParamList& aInParamList, 
		                      MLiwNotifyCallback* aCallback )
	{
	CheckGetListInputListL( aInParamList );
    CMCSCallback* cb = CMCSCallback::NewL(aCallback, aInParamList, 
    		aCallback->GetTransactionID(), *iMCSService,CMCSCallback::EGetList );
    CleanupStack::PushL(cb);
    iMCSService->GetListL( aInParamList, cb );
    CleanupStack::Pop(cb);
	}
// ---------------------------------------------------------------------------
// Check if inputlist for getlist is proper
// ---------------------------------------------------------------------------
//
void CMCSDSInterface::CheckGetListInputListL( const CLiwGenericParamList&
			aInParamList )
	{
	TInt pos( 0 );
	const TLiwGenericParam* inParam = aInParamList.FindFirst( pos, KInData );
	if (inParam)
		{
		const CLiwMap* inputMap = inParam->Value().AsMap();
		if ( inputMap )
	        {
	        TLiwVariant param;
	        // Folder Id
	        if( !inputMap->FindL( KMenuAttrId8, param ) )
	                {
	            	User::Leave( KErrArgument );
	                }
            }
	    else
		   	{
        	User::Leave( KErrArgument );
		   	}
		}
	else
		{
    	User::Leave( KErrArgument );
		}
	}

// ---------------------------------------------------------------------------
// Issues Change Notification request to MCSService
// ---------------------------------------------------------------------------
//
void CMCSDSInterface::RequestNotificationL( const CLiwGenericParamList& aInParamList, 
					                       			MLiwNotifyCallback* aCallback)
													
	{
	TInt pos = 0;
	TInt events = 0;
    TBuf8<KMenuMaxAttrNameLen> attrname;
    TInt paramFolderId = 0;
    TLiwVariant param;
	const TLiwGenericParam* inParam = aInParamList.FindFirst( pos, KInData );
	if (inParam)
	        {
	        const CLiwMap* inputMap = inParam->Value().AsMap();
	        if ( inputMap )
	            {
	            // Folder Id
	            attrname.Copy(KMenuAttrId());
	            if( inputMap->FindL( attrname, param))
	                {
	                paramFolderId = param.AsTInt32();
	                }
	            param.Reset();
	            if( inputMap->FindL( KAddRemove, param))
                   {
                   if (param.AsTBool())
                       {
                        events =  events  | RMenuNotifier::EItemsAddedRemoved;
                       }
                   }
                param.Reset();
                if( inputMap->FindL( KReorder, param))
                   {
                   if (param.AsTBool())
                      {
                       events =  events  | RMenuNotifier::EItemsReordered;
                      }
                   }
                param.Reset();
                if( inputMap->FindL( KAttributeChange, param))
                   {
                   if (param.AsTBool())
                     {
                      events =  events  | RMenuNotifier::EItemAttributeChanged;
                     }
                   }
                param.Reset();
	            }
	        }
	
	CMCSCallback* cb = CMCSCallback::NewL(aCallback, aInParamList, 
	                aCallback->GetTransactionID(), *iMCSService,  CMCSCallback::ERequestNotification );
	CleanupStack::PushL( cb );
		
	// Issue request
	if(events)
		{
		iMCSService->RegisterObserverL(paramFolderId, events, cb );
		}
	else
		{
        User::Leave(KErrArgument);
		}
	CleanupStack::Pop( cb );
	}

// ---------------------------------------------------------------------------
// Issues Delete an item  request to MCSService
// ---------------------------------------------------------------------------
//
void CMCSDSInterface::DeleteL( const CLiwGenericParamList& aInParamList, 
                              MLiwNotifyCallback* aCallback )
    {
    TInt pos = 0;    
    TBuf8<KMenuMaxAttrNameLen> attrname;
    TInt itemId = -1;
    TLiwVariant param;
    const TLiwGenericParam* inParam = aInParamList.FindFirst( pos, KInData );
    if (inParam)
            {
            const CLiwMap* inputMap = inParam->Value().AsMap();
            if ( inputMap )
                {
                // Item Id
                attrname.Copy(KMenuAttrId());
                if( inputMap->FindL( attrname, param))
                    {
                    itemId = param.AsTInt32();
                    }
                param.Reset();
                }
            }

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


// ---------------------------------------------------------------------------
// ErrCode Conversion
// ---------------------------------------------------------------------------
//
TInt32 CMCSDSInterface::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;
			
		case KErrAccessDenied: 
				err = SErrAccessDenied;
				break;
	
		default:
			err = SErrGeneralError;
			break;
		}
	
    return err;
	}

// End of file