/*

* Copyright (c) 2007 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:  Active Object operation for serving server logic requests

*				 for listing of triggers.

*

*/

// INCLUDE FILES

#include <e32base.h>

#include <s32mem.h>

#include "lbtlistaooperation.h"

#include "lbtcontainer.h"

#include "lbtaoobserver.h"

#include "lbtglobal.h"

#include "lbtserverconsts.h"

#include "lbtcontainertriggerfilter.h"

#include "lbtcontainertriggerentry.h"

#include "lbtlisttriggeroptions.h"

#include "lbtserverlogicbase.h"

#include "lbttriggerfilterbyattribute.h"

#include "lbtlogger.h"

// ===================== MEMBER FUNCTIONS =====================

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

// CLbtListAOOperation::NewL

// Symbian Two - phase constructor

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

//

CLbtListAOOperation* CLbtListAOOperation::NewL(MLbtAOObserver& aObserver,

											   const RMessage2& aMessage,

											   CLbtContainer& aContainer,

											   TInt aClientType )

	{

	FUNC_ENTER("CLbtListAOOperation::NewL");

	CLbtListAOOperation* self = new (ELeave) CLbtListAOOperation(aObserver, aMessage, aContainer, aClientType);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(); // self

	return self;

	}

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

// CLbtListAOOperation::~CLbtListAOOperation

// Destructor

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

//

CLbtListAOOperation::~CLbtListAOOperation()

	{

	FUNC_ENTER("CLbtListAOOperation::~CLbtListAOOperation");

	// If the operation is not complete yet then complete the 

	// message with server busy

	if(IsActive())

		{

		Cancel();

		}

	iTriggerArray.ResetAndDestroy();

	delete iTriggerBuffer;

	}

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

// CLbtListAOOperation::CLbtListAOOperation

// C++ Default constructor

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

//

CLbtListAOOperation::CLbtListAOOperation(MLbtAOObserver& aObserver,

										 const RMessage2& aMessage,

										 CLbtContainer& aContainer,

										 TInt aClientType)

	: CLbtAOOperationBase(aObserver, aMessage, aContainer, aClientType)

	{

	FUNC_ENTER("CLbtListAOOperation::CLbtListAOOperation");

	}

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

// CLbtListAOOperation::ConstructL

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

//

void CLbtListAOOperation::ConstructL()

	{

	FUNC_ENTER("CLbtListAOOperation::ConstructL");

	CActiveScheduler::Add(this);

	iState = EStateNone;

	}

TInt CLbtListAOOperation::RunError(TInt aError)

	{

	FUNC_ENTER("CLbtListAOOperation::RunError");

	ERROR("RunL Error is %d", aError);

	return aError;

	}

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

// CLbtListAOOperation::RunL

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

//

void CLbtListAOOperation::RunL()

	{

	FUNC_ENTER("CLbtListAOOperation::RunL");

	// Remove this active object from the schedule queue since 

	// async requests will not be made anymore

	Deque();

	if( iStatus.Int() == KErrCancel )

		{

		LbtGlobal::RequestComplete(iMessage, KErrCancel);

		iObserver.HandleOperationClosureL(this,iStatus.Int());		

		return;

		}

	switch( iMessage.Function() )

		{

		case EGetFiredTriggersCount:

		case ELbtGetFiredTriggers:

		    {

		    if( iState == EStateUpdateFiredState )

		    	{

		    	iState = EStateUpdateCompleted;

		    	return;

		    	}

		    else if( iState == EStateServiceMessageReceived )

		        {

		        ServiceGetFiredTriggersL();

		        return;

		        }

		    // Got the result from container. Return the number of triggers

			TPckg<TInt> numberOfTriggers(iTriggerArray.Count());

			// Send the number of triggers to client lib

			TInt retVal = LbtGlobal::Write(iMessage, KTriggersSize, numberOfTriggers);			

			if(retVal == KErrNone)

				{

				// Complete the message

				LbtGlobal::RequestComplete(iMessage, iStatus.Int());

				}

			if(iTriggerArray.Count() == 0)

				{

				// Inform the observer that this operation has completed

				iObserver.HandleOperationClosureL(this, retVal);

				return;

				}

			RArray<TLbtTriggerId>  triggerIdArray;

		    TLbtTriggerId triggerId;

		    for( TInt i=0;i<iTriggerArray.Count();i++ )

		        {

		        // This array of trigger ids is passed to container to set the 

				// fired state to false.	

				triggerId = iTriggerArray[i]->TriggerEntry()->Id();

		        }

	        // This active object was dequed from active scheduler once container completes 

			// the list triggers.To use this again,it is necessary to add this to the 

			// active scheduler.

			CActiveScheduler::Add( this );

			// Set the trigger fired flag to false

			iContainer.UpdateTriggerFiredState( triggerIdArray,iAOIdentificationNum,EFalse,iStatus );

		    iState = EStateUpdateFiredState;

		    SetActive();

		    triggerIdArray.Close();	

		    break;

		    }

		case ELbtListTriggerIds:

		case ELbtGetListTriggerIdsSize:

			{

			// Got the result from container. Return the number of triggers

			TPckg<TInt> numberOfTriggers(iTriggerArray.Count());

			// Send the number of triggers to client lib

			TInt retVal = LbtGlobal::Write(iMessage, KTriggersSize, numberOfTriggers);			

			if(retVal == KErrNone)

				{

				// Complete the message

				LbtGlobal::RequestComplete(iMessage, iStatus.Int());

				}

			if(iTriggerArray.Count() == 0)

				{

				// Inform the observer that this operation has completed

				iObserver.HandleOperationClosureL(this, retVal);

				}

			break;

			}

		case ELbtGetTriggersBufferSize: 

			{

			// If there are no triggers found for this client then return zero

			// as the buffer size and complete this operation object

			if(iTriggerArray.Count() == 0)

				{

				TPckg<TInt> triggersSize(0);

				TInt retVal = LbtGlobal::Write(iMessage, KTriggersSize, triggersSize);

				if(retVal == KErrNone)

					{

					// Complete the message

					LbtGlobal::RequestComplete(iMessage, iStatus.Int());

					}

				// Inform the observer that this operation has completed

				iObserver.HandleOperationClosureL(this, retVal);

				break;

				}

			// If there are any triggers present then populate the buffer to get the size

			if(!iTriggerBuffer)

				{

				iTriggerBuffer = CBufFlat::NewL(512);

				}

			RBufWriteStream writeStream;

			writeStream.Open(*iTriggerBuffer);

			CleanupClosePushL(writeStream);

			writeStream.WriteInt32L(iTriggerArray.Count());

			for(TInt i=0;i<iTriggerArray.Count(); ++i)

				{

				writeStream << *(iTriggerArray[i]);				

				}

			writeStream.CommitL();

			CleanupStack::PopAndDestroy(&writeStream);

			// Write the size of the buffer

			TPckg<TInt> triggersSize(iTriggerBuffer->Size());

			TInt retVal = LbtGlobal::Write(iMessage, KTriggersSize, triggersSize);

			if(retVal == KErrNone)

				{

				// Complete the message

				LbtGlobal::RequestComplete(iMessage, iStatus.Int());

				}

			break;

			}

		default:

			{

			break;

			}

		}

	}

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

// CLbtListAOOperation::DoCancel

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

//

void CLbtListAOOperation::DoCancel()

	{

	FUNC_ENTER("CLbtListAOOperation::DoCancel");

	// Cancel container notifications

	iContainer.CancelAsyncOperation(iAOIdentificationNum);

	iMessage.Complete( iStatus.Int() );

    }

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

// CLbtListAOOperation::StartOperationL

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

//

void CLbtListAOOperation::StartOperationL()

	{

	FUNC_ENTER("CLbtListAOOperation::StartOperationL");

	switch(iFunction)

		{

		case ELbtGetTriggersBufferSize: // Get the buffer size needed to store the trigger entry objects

		case EGetFiredTriggersCount: // Get number of fired triggers for the client

		case ELbtGetListTriggerIdsSize: // Get number of triggers owned by this client

			{

			CLbtListTriggerOptions* options = CLbtListTriggerOptions::NewL();

			CleanupStack::PushL(options);

			CLbtContainerFilter* containerFilter = CLbtContainerFilter::NewL();

			CleanupStack::PushL(containerFilter);

	    	TLbtSecurityPolicy securityPolicy;

			if ( iClientType == CLbtServerLogicBase::TLbtClientLibrary )

			    {

    			securityPolicy.SetOwnerSecureId( iMessage.SecureId() );	

			    }

			if(iFunction == ELbtGetListTriggerIdsSize || 

			   iFunction == ELbtGetTriggersBufferSize )

				{

				HBufC8* listOptionsBuffer = LbtGlobal::CopyClientBuffer8LC(iMessage, KParamFilter);

				if( listOptionsBuffer == NULL )

					{

					CleanupStack::PopAndDestroy(2);

					iObserver.HandleOperationClosureL(this, KErrBadDescriptor);

					return;

					}

				// Read the buffer into a stream

				RDesReadStream stream(*listOptionsBuffer);

				CleanupClosePushL(stream);

				options->InternalizeL(stream);				

				CleanupStack::PopAndDestroy(2, listOptionsBuffer); // listOptionsBuffer, stream

				}

			else if( iFunction == EGetFiredTriggersCount )

				{

				containerFilter->AddFiredInfoInFilterL(ETrue);

				}

			CLbtContainerListOptions* containerOptions = CLbtContainerListOptions::NewL(options, containerFilter);

			CleanupStack::Pop(2); // options, filter

            TLbtTriggerAttributeFieldsMask triggerMask;

            TLbtTriggerDynamicInfoFieldsMask dynInfoMask;

            // Add the Trigger Id attribute since it shouls always be retrieved whether the

            // client specifies it or not.

			containerOptions->ListOptions()->GetRetrievedFields( triggerMask, dynInfoMask );

			triggerMask = triggerMask | CLbtTriggerEntry::EAttributeId;

			containerOptions->ListOptions()->SetRetrievedFields( triggerMask, dynInfoMask );

			containerOptions->SetDataMask(CLbtContainerTriggerEntry::EContainerAttributeFireInfo);

			// Request triggers of the client

			iContainer.ListTriggers(containerOptions, iTriggerArray,iAOIdentificationNum,iStatus,securityPolicy);

			SetActive();

			break;

			}

		default:

			{

			break;

			}

		}

	}

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

// CLbtListAOOperation::ServiceMessageL

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

//

void CLbtListAOOperation::ServiceMessageL(const RMessage2 aMessage)

	{

	FUNC_ENTER("CLbtListAOOperation::ServiceMessageL");

	iMessage=aMessage;

	switch(aMessage.Function())

		{

		case ELbtGetFiredTriggers:

			{

			iMessage = aMessage;

			if( iState == EStateUpdateCompleted )

				{

				ServiceGetFiredTriggersL();

				}

			else

				{

				iState = EStateServiceMessageReceived;

				}

		    break;

			}

		case ELbtListTriggerIds: // Send the acquired triggers id's

			{

			CBufFlat* buffer = CBufFlat::NewL(512);

			CleanupStack::PushL(buffer);

			RBufWriteStream writeStream;

			writeStream.Open(*buffer);

			CleanupClosePushL(writeStream);			

			for(TInt i=0;i<iTriggerArray.Count(); ++i)

				{

				TLbtTriggerId triggerId = iTriggerArray[i]->TriggerEntry()->Id();

				TUint8* ptr = reinterpret_cast<TUint8*>(&triggerId);

				writeStream.WriteL(ptr, sizeof(TLbtTriggerId));				

				}

			writeStream.CommitL();			

			CleanupStack::PopAndDestroy(&writeStream);

			TPtr8 ptr = buffer->Ptr(0);

			// Write the trigger array into the IPC

			TInt retVal = LbtGlobal::Write(iMessage, KParamTriggerEntry, ptr);			

			if(retVal == KErrNone)

				{

				// Complete the message

				LbtGlobal::RequestComplete(iMessage, KErrNone);

				}

			CleanupStack::PopAndDestroy(buffer);

			// Inform the observer that this operation has completed

	        iObserver.HandleOperationClosureL(this, KErrNone);

	        break;

			}

		case ELbtGetTriggers:

			{

			TInt error = KErrNone;

			if( iTriggerBuffer )

				{

				TPtr8 ptr = iTriggerBuffer->Ptr(0);

				// Write the trigger array into the IPC

				TInt retVal = LbtGlobal::Write(iMessage, KParamTriggerEntry, ptr);			

				if(retVal == KErrNone)

					{

					// Complete the message

					LbtGlobal::RequestComplete(iMessage, KErrNone);

					}

				delete iTriggerBuffer;

				iTriggerBuffer = NULL;

				}

			else

				{

				error = KErrNotFound;

				LbtGlobal::RequestComplete(iMessage, KErrNotFound);

				}

			// Inform the observer that this operation has completed

	        iObserver.HandleOperationClosureL( this, error );

			break;

			}

		default:

			{

			// Not received the first part of the message. This 

			// should not happen and should be made sure by the client

			// library

			LbtGlobal::RequestComplete(iMessage, KErrUnknown);

			// Inform the observer that this operation has completed

	        iObserver.HandleOperationClosureL(this, KErrNone);

			break;

			}

		}

    }

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

// CLbtListAOOperation::CancelListOperation

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

//

void CLbtListAOOperation::CancelListOperation()

	{

	FUNC_ENTER("CLbtListAOOperation::CancelListOperation");

	if(iStatus.Int()==KRequestPending)

		{

		Cancel();

		}

	else

		{

		// HandleOperationClosureL method internally calls LoadOrUnloadStrategyPluginL 

		// method which may leave only during the loading operation,but here the expected 

		// behaviour is the unloading of strategy plugin which never fails .Hence we have ignored.

        LbtGlobal::RequestComplete(iMessage,KErrCancel);   

		TRAP_IGNORE( iObserver.HandleOperationClosureL(this,KErrCancel) );

		}	

	}

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

// CLbtListAOOperation::ServiceGetFiredTriggersL

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

//

void CLbtListAOOperation::ServiceGetFiredTriggersL()

    {

    FUNC_ENTER("CLbtListAOOperation::ServiceGetFiredTriggers");

    //TInt sizeOfFireInfo = sizeof(TLbtTriggerFireInfo);

	CBufFlat* buffer = CBufFlat::NewL(512);

	CleanupStack::PushL(buffer);

	RBufWriteStream writeStream;

	writeStream.Open(*buffer);

	CleanupClosePushL(writeStream);

	for(TInt i=0;i<iTriggerArray.Count(); ++i)

		{

		TLbtTriggerFireInfo fireInfo;

		// Get the fire info from Container

		fireInfo = iTriggerArray[i]->ExtendedTriggerInfo()->GetFiredInfo();

		TUint8* ptr = reinterpret_cast<TUint8*>(&fireInfo);

		writeStream.WriteL(ptr, sizeof(TLbtTriggerFireInfo));

		}

	writeStream.CommitL();

	CleanupStack::PopAndDestroy(&writeStream);

	TPtr8 ptr = buffer->Ptr(0);			

	// Write the trigger array into the IPC			

	TInt retVal = LbtGlobal::Write(iMessage, KParamTriggerFireInfo, ptr);			

	if(retVal == KErrNone)

		{

		// Complete the message

		LbtGlobal::RequestComplete(iMessage, KErrNone);

		}

	CleanupStack::PopAndDestroy(buffer);

	// Inform the observer that this operation has completed

    iObserver.HandleOperationClosureL(this, KErrNone);

    }

// end of file