// Copyright (c) 1998-2009 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 <s32std.h>

#include "MSVAPI.H"

#include "MSVCOP.H"

#include "MSVPANIC.H"

#include <tmsvsystemprogress.h>

//**********************************

// CMsvOperation

//**********************************

EXPORT_C CMsvOperation::CMsvOperation(CMsvSession& aMsvSession, TInt aPriority, TRequestStatus& aObserverRequestStatus)

: CActive(aPriority), iObserverRequestStatus(aObserverRequestStatus), iMsvSession(aMsvSession)

//

//

//

/** Constructor. This is called by MTM implementers from the derived class constructor. 

CMsvOperation-derived objects are not created by message client applications. The constructor uses the 

CMsvSession object to obtain a ID for the operation. This ID can be accessed by clients through Id(). 

aPriority is the priority used by the active object. Typically, this is EPriorityStandard.

aObserverRequestStatus is the asynchronous status object of an active object provided by the caller. 

The derived class is required to signal the caller through this when the operation completes. 

It is stored by the constructor in the iObserverRequestStatus member.

@param aMsvSession Session object 

@param aPriority Active object priority 

@param aObserverRequestStatus  Request status of operation observer

 */

	{

	__DECLARE_NAME(_S("CMsvOperation"));

	iId = iMsvSession.OperationId();

	}

EXPORT_C CMsvOperation::~CMsvOperation()

/** Destructor.

This base class function takes no action. Derived classes should implement 

a destructor to do the clean up tasks that they require. Minimally, they should 

call Cancel() to cancel any outstanding request. */

	{}

EXPORT_C const TDesC8& CMsvOperation::FinalProgress()

/** Gets information about a completed operation. 

Unlike ProgressL(), this is guaranteed to provide status information reflecting 

the outcome of a completed operation.

Requirements:

The default implementation of this function returns the result from ProgressL(). 

If the operation is active or ProgressL() leaves, a panic occurs. 

A derived class should implement the function to meet the requirement to provide 

appropriate final status information. Typically, on active object completion, 

it will store progress information in a private member, and return that stored 

information from this function.

@return Descriptor holding progress information

@panic MSGS 285 Operation is active

@panic MSGS 286 Could not get final progress information, as ProgressL() left.

*/

	{	

	__ASSERT_ALWAYS(!IsActive(), PanicServer(EMsvActiveInFinalProgress));

	const TDesC8* progress = &KNullDesC8();

	TRAPD(leave, progress = &ProgressL());

	__ASSERT_ALWAYS(leave == KErrNone, PanicServer(EMsvFinalProgressFailed));

	return *progress;

	}

EXPORT_C TUid CMsvOperation::Mtm() const

/** Gets the UID of the MTM associated with the operation.

This UID can be used to determine the appropriate method of getting information 

from a progress descriptor. 

The default implementation returns iMtm.

@return The UID of the MTM associated with the operation 

@see ProgressL() */

 	{

 	return iMtm;

 	} 

/** This call leads to calling SystemProgress() in the server to populate the

TMsvSystemProgress structure.

@param aOutSysProg The TMsvSystemProgress structure to be populated by the server

@return the error of the Extension_ method call

*/

EXPORT_C TInt CMsvOperation::SystemProgress(TMsvSystemProgress& aOutSysProg)

	{

	TAny* ptrNull = NULL;

	return Extension_(KUIDMsgMsvSystemProgress, ptrNull, &aOutSysProg);

	}

/** The extension method provides a polymorphic behaviour to call the correct

SystemProgress function.

@param aExtensionId The Uid passed in as KUIDMsgMsvSystemProgress to obtain the

System Progress.

@return KErrExtensionNotSupported retuned if no Extension_ function is overriddden

by the derived class.

*/

EXPORT_C TInt CMsvOperation::Extension_(TUint aExtensionId, TAny *&a0, TAny *a1)	

	{

	TInt ret = KErrNone;

	switch(aExtensionId)

		{

		case KUIDMsgMsvSystemProgress:

			{

			ret = KErrExtensionNotSupported;

			}

			break;

		default:

			{

		// Chain to base class

			ret = CActive::Extension_(aExtensionId, a0, a1);

			}

			break;

		}

	return ret;

	}

//**********************************

// CMsvEntryOperation

//**********************************

CMsvEntryOperation* CMsvEntryOperation::NewL(CMsvSession& aMsvSession, TRequestStatus& aObserverRequestStatus)

//

//

//

	{

	CMsvEntryOperation* self = CMsvEntryOperation::NewLC(aMsvSession, aObserverRequestStatus);

	CleanupStack::Pop();

	return self;

	}

CMsvEntryOperation* CMsvEntryOperation::NewLC(CMsvSession& aMsvSession, TRequestStatus& aObserverRequestStatus)

//

//

//

	{

	CMsvEntryOperation* self = new(ELeave) CMsvEntryOperation(aMsvSession, aObserverRequestStatus);

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

CMsvEntryOperation::CMsvEntryOperation(CMsvSession& aMsvSession, TRequestStatus& aObserverRequestStatus)

: CMsvOperation(aMsvSession, EPriorityStandard, aObserverRequestStatus)

//

//

//

	{

	__DECLARE_NAME(_S("CMsvEntryOperation"));

	}

CMsvEntryOperation::~CMsvEntryOperation()

//

//

//

	{

	Cancel();

	delete iProgress;

	}

void CMsvEntryOperation::ConstructL()

//

//

//

	{

	iProgress = HBufC8::NewL(KMsvProgressBufferLength);

	CActiveScheduler::Add(this);

	}

void CMsvEntryOperation::DoCancel()

//

//

//

	{

	TPtr8 des = iProgress->Des();

	iMsvSession.Session().CancelOperation(Id(), des); // error ignored

	// signal the observer that the operation has completed

	TRequestStatus* status = &iObserverRequestStatus;

	User::RequestComplete(status, KErrCancel);

	}

void CMsvEntryOperation::RunL()

//

//

//

	{

	// get the final Msv system progress from the server

	iErrorGetSystemProgress = iMsvSession.Session().OperationSystemProgress(Id(), iSystemProgress);

	// get the final progress from the server

	TPtr8 des = iProgress->Des();

	TInt length=des.Length();

	TInt error = iMsvSession.Session().OperationCompletion(Id(), des); 

	if (error)

		des.SetLength(length);

	// signal the observer that the operation has completed

	TRequestStatus* status = &iObserverRequestStatus;

	// If there is no operation then complete with our status

	// Otherwise complete with the operation completion error

	if (error == KErrNotFound && iStatus.Int())

		User::RequestComplete(status, iStatus.Int());

	else

		User::RequestComplete(status, error ? error : iStatus.Int());

	}

const TDesC8& CMsvEntryOperation::ProgressL()

//

//

//

	{

	if (IsActive())

		{

		TPtr8 des = iProgress->Des();

		User::LeaveIfError(iMsvSession.Session().OperationProgress(Id(), des));

		}

	return *iProgress;

	}

/** The extension method provides a polymorphic behaviour to get the TMsvSystemProgress

structure in one of the Operations.

@param aExtensionId The Uid passed in as KUIDMsgMsvSystemProgress to obtain the

System Progress.

@return error from the call of DoGetSystemProgress() method.

*/

EXPORT_C TInt CMsvEntryOperation::Extension_(TUint aExtensionId, TAny *&a0, TAny *a1)

	{

	if (aExtensionId == KUIDMsgMsvSystemProgress)

		{

		TMsvSystemProgress* systemProgress = reinterpret_cast<TMsvSystemProgress*>(a1);

		return DoGetSystemProgress(*systemProgress);

		}

	// Chain to base class

	return CMsvOperation::Extension_(aExtensionId, a0, a1);

	}

/** This function calls the session which eventually goes to SystemProgress() in the server

to populate the TMsvSystemProgress structure.

@param aOutSysProg The TMsvSystemProgress structure to be populated by the server

@return the error from the SystemProgress() call.

*/

TInt CMsvEntryOperation::DoGetSystemProgress(TMsvSystemProgress& aOutSysProg)

	{

	TInt err = KErrNone;

	// use RMsvSession

	if (IsActive())

		{

		err = iMsvSession.Session().OperationSystemProgress(Id(), aOutSysProg);

		}

	else

		{

		aOutSysProg = iSystemProgress;

		err = iErrorGetSystemProgress;

		}

	return err;

	}

const TDesC8& CMsvEntryOperation::FinalProgress()

	{

	__ASSERT_ALWAYS(!IsActive(), PanicServer(EMsvActiveInFinalProgress));

	return *iProgress;

	}

void CMsvEntryOperation::Start()

//

//

//

	{

	iObserverRequestStatus=KRequestPending;

	SetActive();

	}

//**********************************

// CMsvOperationWait

//**********************************

// static 

/** Allocates and constructs a new CMsvOperationWait object.

The new object is added to the active scheduler and left on

the cleanup stack.

@param aPriority Active object priority. It has a default value of 

EPriorityStandard.

@return New CMsvOperationWait object

@leave KErrNoMemory

*/

EXPORT_C CMsvOperationWait* CMsvOperationWait::NewLC(TInt aPriority)

	{

	CMsvOperationWait* self = new (ELeave) CMsvOperationWait(aPriority);

	CleanupStack::PushL(self);

	return self;

	}

/** Constructor.

@param aPriority Active object priority

*/

CMsvOperationWait::CMsvOperationWait(TInt aPriority)

: CActive(aPriority)

	{

	CActiveScheduler::Add(this);

	}

/** Destructor.

Any active request on the object is cancelled.

*/

EXPORT_C CMsvOperationWait::~CMsvOperationWait()

	{

	Cancel();

	}

/** Sets the object to be active.

*/

EXPORT_C void CMsvOperationWait::Start()

	{

	iStatus = KRequestPending;

	SetActive();

	}

/** Handles a request completion event.

The function stops the current active scheduler.

@see CActive::RunL()

*/

void CMsvOperationWait::RunL()

	{

	CActiveScheduler::Stop();

	}

/** Implements cancellation of an outstanding request.

@see CActive::DoCancel()

*/

void CMsvOperationWait::DoCancel()

	{

	TRequestStatus* s=&iStatus;

	User::RequestComplete(s, KErrCancel);

	}

//**********************************

// CMsvOperationActiveSchedulerWait

//**********************************

// static 

/** Allocates and constructs a new CMsvOperationActiveSchedulerWait object.

The new object is added to the active scheduler and left on

the cleanup stack.

@param aPriority Active object priority. It has a default value of 

EPriorityStandard.

@return New CMsvOperationActiveSchedulerWait object

@leave KErrNoMemory

*/

EXPORT_C CMsvOperationActiveSchedulerWait* CMsvOperationActiveSchedulerWait::NewLC(TInt aPriority)

	{

	CMsvOperationActiveSchedulerWait* self = new (ELeave) CMsvOperationActiveSchedulerWait(aPriority);

	CleanupStack::PushL(self);

	return self;

	}

/** Constructor.

@param aPriority Active object priority

*/

CMsvOperationActiveSchedulerWait::CMsvOperationActiveSchedulerWait(TInt aPriority)

: CActive(aPriority)

	{

	CActiveScheduler::Add(this);

	}

/** Destructor.

Any active request on the object is cancelled.

*/

EXPORT_C CMsvOperationActiveSchedulerWait::~CMsvOperationActiveSchedulerWait()

	{

	Cancel();

	}

/** Sets the object to be active, and wait until the request is completed.

*/

EXPORT_C void CMsvOperationActiveSchedulerWait::Start()

	{

	SetActive();

	iActiveSchedulerWait.Start();	//Re-enter the active scheduler--execution halts here until RunL is called

	}

/** Handles a request completion event.

The function stops the object waiting, and allows the program to resume execution after the Start() function call.

@see CActive::RunL()

*/

void CMsvOperationActiveSchedulerWait::RunL()

	{

	iActiveSchedulerWait.AsyncStop();	//Exit current scheduler loop, resuming execution of the Start() function

	}

/** Implements cancellation of an outstanding request.

@see CActive::DoCancel()

*/

void CMsvOperationActiveSchedulerWait::DoCancel()

	{

	TRequestStatus* s=&iStatus;

	User::RequestComplete(s, KErrCancel);

	}

//**********************************

// CMsvCompletedOperation

//**********************************

// static

/** Allocates and constructs a new CMsvCompletedOperation object.

The new object is added to the active scheduler and its asynchronous request 

immediately set to complete.

@param aSession Message Server session to use

@param aMtm The UID of the MTM associated with the operation. 

@param aProgress Operation progress information buffer. This is copied by the object.

@param aService The ID of the service that is associated with this operation. 

@param aObserverRequestStatus Request status of the operation observer. This 

observer is signalled that the operation is complete. 

@param aError Error code with which to complete the request. Use KErrNone to 

indicate that the operation completed successfully. 

@return New CMsvOperationActiveSchedulerWait object

@leave KErrNoMemory

*/

EXPORT_C CMsvCompletedOperation* CMsvCompletedOperation::NewL(CMsvSession& aSession, TUid aMtm, const TDesC8& aProgress, TMsvId aService, TRequestStatus& aObserverRequestStatus, TInt aError)

	{

	CMsvCompletedOperation* self = new (ELeave) CMsvCompletedOperation(aSession, aObserverRequestStatus);

	CleanupStack::PushL(self);

	self->ConstructL(aMtm, aError, aProgress, aService);

	CleanupStack::Pop();

	return self;

	}

CMsvCompletedOperation::CMsvCompletedOperation(CMsvSession& aSession, TRequestStatus& aObserverRequestStatus)

: CMsvOperation(aSession, EPriorityStandard, aObserverRequestStatus) 

	{

	__DECLARE_NAME(_S("CMsvCompletedOperation"));

	}

/** Destructor.

Any active request on the object is cancelled.

*/

EXPORT_C CMsvCompletedOperation::~CMsvCompletedOperation()

	{

	Cancel();

	delete iProgress;

	}

void CMsvCompletedOperation::ConstructL(TUid aMtm, TInt aError, const TDesC8& aProgress, TMsvId aService)

	{

	iProgress = HBufC8::NewL(aProgress.Length());

	*iProgress = aProgress;

	iMtm=aMtm;

	iService=aService;

	//

	CActiveScheduler::Add(this);

	iStatus = KRequestPending;

	SetActive();

	//

	TRequestStatus* pstat=&iStatus;

	User::RequestComplete(pstat, aError);

	iObserverRequestStatus = KRequestPending;

	}

/** Gets information on the progress of the operation.

For a CMsvCompletedOperation, the progress information returned by 

ProgressL() and FinalProgress() is the same, and is the progress 

information set in the NewL() function. 

@return Descriptor holding progress information.

@see CMsvOperation::ProgressL()

*/

const TDesC8& CMsvCompletedOperation::ProgressL()

	{

	return *iProgress;

	}

/** Gets information about a completed operation. 

@return Descriptor holding progress information.

@see CMsvOperation::FinalProgress()

*/