// Copyright (c) 1995-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the License "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:

// e32\euser\cbase\ub_act.cpp

// 

//

#include "ub_std.h"

#include "us_data.h"

#ifdef __SMP__

#include <e32atomics.h>

#endif

#pragma warning( disable : 4705 )	// statement has no effect

EXPORT_C CActive::CActive(TInt aPriority)

/**

Constructs the active object with the specified priority.

Derived classes must define and implement a constructor through which the

priority can be specified. A typical implementation calls this active object

constructor through a constructor initialization list.

@param aPriority An integer specifying the priority of this active object.

                 CActive::TPriority defines a standard set of priorities.

*/

	{

	iLink.iPriority=aPriority;

	}

#pragma warning( default : 4705 )

EXPORT_C CActive::~CActive()

/**

Frees resources prior to destruction.

Specifically, it removes this active object from the active scheduler's

list of active objects.

Typically, a derived class calls Cancel() in its destructor.

@panic E32USER-CBase 40 if the active object has an outstanding request when

       the destructor is called,

@see CActive::Cancel

*/

	{

	__ASSERT_ALWAYS(!(iStatus.iFlags&TRequestStatus::EActive),Panic(EReqStillActiveOnDestruct));

	if (IsAdded())

		iLink.Deque();

	}

EXPORT_C void CActive::Cancel()

/**

Cancels the wait for completion of an outstanding request.

If there is no request outstanding, then the function does nothing.

If there is an outstanding request, the function:

1. calls the active object's DoCancel() function, provided by

   the derived class to implement cancellation of the request.

2. waits for the cancelled request to complete; this must complete as fast as

   possible.

3. marks the active object's request as complete (i.e. the request is no longer

   outstanding).

@see CActive::DoCancel

@see CActive::IsActive

@see CActive::~CActive

@see User::WaitForRequest

*/

	{

	if (iStatus.iFlags&TRequestStatus::EActive)

		{

		DoCancel();

		User::WaitForRequest(iStatus);

    	iStatus.iFlags&=~(TRequestStatus::EActive | TRequestStatus::ERequestPending); //iActive=EFalse;

		}

	}

EXPORT_C void CActive::Deque()

/**

Removes the active object from the active scheduler's list of active objects.

Before being removed from the active scheduler's list, the function cancels

any outstanding request.

@see CActive::Cancel

*/

	{

	__ASSERT_ALWAYS(IsAdded(),Panic(EActiveNotAdded));

	Cancel();

	iLink.Deque();

	iLink.iNext=NULL; // Must do this or object cannot be re-queued

	}

EXPORT_C void CActive::SetActive()

/**

Indicates that the active object has issued a request and that

it is now outstanding.

Derived classes must call this function after issuing a request.

A request is automatically marked as complete (i.e. it is no longer

outstanding) by:

1. the active scheduler, immediately before it calls the active object's RunL()

   function.

or

2. the active object within the implementation of the Cancel() function.

E32USER-CBase 46 panics may occur if an active object is set active but

no request is made on its TRequestStatus, or vice-versa. This panic happens

no earlier than the next time that the active scheduler assesses which

objects are ready to run, and may happen much later. This panic is termed 

a 'stray event' because it indicates that some entity has sent an event 

to the active scheduler thread, but this thread is not in a state ready to handle it.

@see CActive::IsActive

@see CActive::RunL

@see CActive::Cancel

@panic E32USER-CBase 42 if this active object is already active

@panic E32USER-CBase 49 if this active object has not been added to the active

       scheduler.

*/

	{

	__ASSERT_ALWAYS(!(iStatus.iFlags&TRequestStatus::EActive),Panic(EReqAlreadyActive));

	__ASSERT_ALWAYS(IsAdded(),Panic(EActiveNotAdded));

	iStatus.iFlags|=TRequestStatus::EActive;

	}

EXPORT_C void CActive::SetPriority(TInt aPriority)

/**

Sets the priority of the active object.

@param aPriority An integer specifying the new priority of this active object.

                 CActive::TPriority defines a standard set of priorities.

@panic E32USER-CBase 50 if this function is called while a request

       is outstanding.

*/

	{

	__ASSERT_ALWAYS(!(iStatus.iFlags&TRequestStatus::EActive),Panic(ESetPriorityActive));

	iLink.iPriority=aPriority;

	if (IsAdded())

		{

		Deque();

		iLink.iNext=NULL; // Make this not added

		CActiveScheduler::Add(this);

		}

	}

EXPORT_C TInt CActive::RunError(TInt aError)

/**

Handles a leave occurring in the request completion event handler RunL().

The active scheduler calls this function if this active object's RunL()

function leaves. This gives this active object the opportunity to perform

any necessary cleanup.

A derived class implementation should handle the leave and return KErrNone.

Returning any other value results in the active scheduler function

CActiveScheduler::Error() being called.

The default implementation simply returns the leave code.

Note that if the active scheduler is to handle the error, a suitably derived

CActiveScheduler::Error() function must be supplied.

@param aError The leave code

@return The default implementation returns aError. A derived class

        implementation should return KErrNone, if it handles the leave;

        otherwise it should return any suitable value to cause the handling

        of the error to be propagated back to the active scheduler.

@see CActiveScheduler::Error

*/

	{

	return aError;

	}

/**

Extension function

*/

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

	{

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

	}

EXPORT_C CIdle* CIdle::New(TInt aPriority)

/**

Allocates and initialises an Idle time active object and adds it to the active

scheduler.

@param aPriority An integer specifying the priority of this active object.

                 It must be lower than that of all other active objects on

                 the active scheduler.

                 The value CActive::TPriority::EPriorityIdle is recommended.

@return Pointer to the new Idle time active object, or NULL if the object could

        not be created.

*/

	{

	CIdle *pI=new CIdle(aPriority);

	if (pI!=NULL)

		CActiveScheduler::Add(pI);

	return(pI);

	}

EXPORT_C CIdle* CIdle::NewL(TInt aPriority)

/**

Allocates and initialises an Idle time active object, adds it to the active

scheduler, but leaves on failure.

@param aPriority An integer specifying the priority of this active object.

                 It must be lower than that of all other active objects on

                 the active scheduler.

                 The value CActive::TPriority::EPriorityIdle is recommended.

@return Pointer to the new Idle time active object.

*/

	{

	CIdle *pI=new(ELeave) CIdle(aPriority);

	CActiveScheduler::Add(pI);

	return(pI);

	}

EXPORT_C CIdle::CIdle(TInt aPriority)

	: CActive(aPriority)

/**

Protected constructor taking a priority value.

Sets this active object's priority value.

@param aPriority The active object priority value.

*/

	{}

EXPORT_C CIdle::~CIdle()

/**

Frees resources prior to destruction.

Specifically, it cancels any outstanding request.

*/

	{

	Cancel();

	}

EXPORT_C void CIdle::Start(TCallBack aCallBack)

/**

Starts the background task.

The background task is encapsulated in the callback. The function represented

by this callback is called every time this Idle time active object is scheduled

to run.

The callback function should be structured to perform a background task in

many increments, i.e. it should voluntarily relinquish control (i.e. return)

after a suitable time interval to allow other, higher priority events to be

handled.

If the callback function has further work to do, it should return a true value.

This ensures that the active object is scheduled to run again later.

Once the callback function has finally completed its work, it should return

a false value. The active object is then no longer scheduled to run.

@param aCallBack A callback object encapsulating a function which is called

                 when no higher priority active object is ready to run.

*/

	{

	iCallBack=aCallBack;

	iStatus=KRequestPending;

	TRequestStatus *pS=(&iStatus);

	User::RequestComplete(pS,0);

	SetActive();

	}

EXPORT_C void CIdle::RunL()

/**

Handles this idle active object's request completion event.

It is called when nothing of a higher priority can be scheduled.

@see CActive::RunL

*/

	{

	if (iCallBack.CallBack())

		Start(iCallBack);

	}

EXPORT_C void CIdle::DoCancel()

/**

Implements the cancellation of an outstanding request.

This function is called by the active object's Cancel() function.

@see CActive::DoCancel

*/

	{

	}

EXPORT_C void CAsyncOneShot::Call()

/**

Queues this active object to be run once.

@panic E32USER-CBase 2 In debug builds only, if this active object has not

       already been added to the active scheduler.

*/

	{

	__ASSERT_DEBUG(IsAdded(),Panic(ECAsyncOneShotNotAdded));

	TRequestStatus *pS=(&iStatus);

	iStatus = KRequestPending;

	SetActive();

	iThread.RequestComplete(pS,0);

	}

EXPORT_C void CAsyncOneShot::DoCancel()

/**

Implements cancellation of an outstanding request.

The class provides an empty implementation.

This is called by the destructor.

*/

	{

	// Empty

	}

EXPORT_C CAsyncOneShot::CAsyncOneShot(TInt aPriority)

	:CActive(aPriority)

/**

Constructor taking a priority value.

Specifically, the constructor:

1. sets this active object's priority value

2. opens a handle to the current thread to ensure that the thread cannot be

   closed until this CAsyncOneShot object is destroyed

3. adds this active object to the current active scheduler.

@param aPriority The active object priority value. CActive::TPriority defines

                 a standard set of priorities.

@panic E32USER-CBase 93 if the attempt to open a handle to the current thread

       fails.

*/

	{

	Setup();

	}

void CAsyncOneShot::Setup()

//

// ensures that we are added to the Scheduler.

//

	{

	// No error checking was done initially.  As this function is called from

	// the c'tor, there is no way to fix it properly without breaking BC.  So

	// we panic if something goes wrong (should only happen in extreme

	// circumstances if the kernel heap is exhausted or heavily fragmented).

	__ASSERT_ALWAYS(iThread.Duplicate(RThread()) == KErrNone, Panic(EAsyncOneShotSetupFailed));

	// Add ourself to the current active scheduler

	// This is because we might be being used as an inter thread call

	// we need to make sure that we're on the correct scheduler for

	// the RThread were going to duplicate.

	CActiveScheduler::Add(this);

	}

EXPORT_C CAsyncOneShot::~CAsyncOneShot()

/**

Frees resources prior to destruction.

Specifically, it closes the handle to the current thread.

@see CActive::~CActive

*/

	{

	Cancel();

	iThread.Close();

	}

EXPORT_C CAsyncCallBack::CAsyncCallBack(TInt aPriority)

	: CAsyncOneShot(aPriority), iCallBack(NULL)

/**

Constructor taking a priority value.

Specifically, the constructor sets this active object's priority value through

a call to the base class constructor in its ctor list.

No call back is set, which means that it must be set subsequently through

a call to the Set() function.

@param aPriority The active object priority value. CActive::TPriority defines

                 a standard set of priorities.

@see CAsyncCallBack::Set

*/

	{

	}

EXPORT_C CAsyncCallBack::CAsyncCallBack(const TCallBack& aCallBack, TInt aPriority)

	: CAsyncOneShot(aPriority), iCallBack(aCallBack)

/**

Constructor taking a priority value and a callback.

Specifically, the constructor:

1. sets this active object's priority value through a call to the base class

   constructor in its ctor list

2. sets the callback; the function encapsulated by the callback is called when

   this active object is scheduled to run.

@param aCallBack A reference to a callback object encapsulating a function

                 which is called when this active object is ready to run.

                 The constructor takes a copy of this callback object, which

                 means that it can be safely discarded after construction.

@param aPriority The active object priority value.

*/

	{

	}

EXPORT_C CAsyncCallBack::~CAsyncCallBack()

/**

Destructor.

*/

	{

	}

EXPORT_C void CAsyncCallBack::CallBack()

/**

Queues this active object to be run, if it is not already queued.

*/

	{

	if (!IsActive())

		Call();

	}

EXPORT_C void CAsyncCallBack::Set(const TCallBack& aCallBack)

/**

Sets the call back.

@param aCallBack A reference to a callback object encapsulating a function

                 which is called when this active object is ready to run.

@panic E32USER-CBase 1 if the active object is currently active.

*/

	{

	__ASSERT_ALWAYS(!IsActive(), Panic(ECAsyncCBIsActive));

	iCallBack = aCallBack;

	}

void CAsyncCallBack::RunL()

/**

Calls the callback function.

@see TCallBack::CallBack

*/

	{

	iCallBack.CallBack();

	}

struct CActiveScheduler::TLoop

	{

	TLoop* iNext;

	CActiveScheduler::TLoopOwner* iOwner;

	TCallBack iCallback;

	TInt iExitCode;

	};

CActiveScheduler::TLoopOwner* const KLoopNoOwner=reinterpret_cast<CActiveScheduler::TLoopOwner*>(1);

CActiveScheduler::TLoopOwner* const KLoopInactive=0;

EXPORT_C CActiveSchedulerWait::CActiveSchedulerWait()

/**

Default constructor.

*/

	{}

EXPORT_C CActiveSchedulerWait::~CActiveSchedulerWait()

/**

Ensures that the attached scheduler loop, and all nested loops, are stopped

prior to destruction.

@see AsyncStop()

*/

	{

	if (IsStarted())

		AsyncStop();

	}

EXPORT_C void CActiveSchedulerWait::Start()

/**

Starts a new wait loop under the control of the current active scheduler.

Compared with CActiveScheduler::Start(), this object owns control of

the scheduling loop that is started, and that loop can only be stopped

by using this objects AsyncStop() function or the CActiveScheduler::Halt()

function. Start() only returns when either of thos has occurred.

This is the preferred way to start a nested wait loop. Typically, a nested

wait loop is used when the handling of a completed event in an active object

requires processing further events from the other active objects before it

can complete. This is a form of modal processing.

@panic E32USER-CBase 44 if the thread does not have an active scheduler installed.

@panic E32USER-CBase 91 if this object has already been started.

@see CActiveSchedulerWait::AsyncStop

@see CActiveSchedulerWait::IsStarted

@see CActiveScheduler::Start

@see CActiveScheduler::Halt

*/

	{

	__ASSERT_ALWAYS(!IsStarted(), Panic(EActiveSchedulerWaitAlreadyStarted));		// can only start a CActiveSchedulerWait if it isn't already started

	CActiveScheduler::Start(&iLoop);

	}

EXPORT_C void CActiveSchedulerWait::AsyncStop()

/**

Stops the scheduling loop owned by this object.

Note that the corresponding call to Start() only returns once all nested

scheduler loops have stopped.

@panic E32USER-CBase 92 if the wait object has not been started.

*/

	{

	AsyncStop(TCallBack());

	}

EXPORT_C void CActiveSchedulerWait::AsyncStop(const TCallBack& aCallMeWhenStopped)

/**

Stops the scheduling loop owned by this object, specifying a callback.

This version of AsyncStop() provides a callback which is invoked immediately

after the scheduler loop actually stops before the corresponding call

to Start() returns.

Note that the corresponding call to Start() only returns once all nested

scheduler loops have stopped.

@param aCallMeWhenStopped The callback to invoke when the scheduler loop exits.

@panic E32USER-CBase 92 if the wait object has not been started.

 */

	{

	CActiveScheduler::TLoopOwner loop=iLoop;

	__ASSERT_ALWAYS(loop, Panic(EActiveSchedulerWaitNotStarted));		// can only stop a CActiveSchedulerWait if it's started

	__ASSERT_DEBUG(loop->iOwner==&iLoop, User::Invariant());

	loop->iCallback = aCallMeWhenStopped;

	loop->iOwner = KLoopInactive;			// disconnect from owner

	iLoop = 0;

	}

EXPORT_C TBool CActiveSchedulerWait::CanStopNow() const

/**

Reports whether stopping will have immediate effect.

This returns an indication of whether a call to AsyncStop() would be

expected to stop the scheduler loop immediately, or whether it will

have to wait until nested scheduler loops have stopped. This may alter

which version of AsyncStop() you would want to call.

@return Boolean indicating if the scheduling loop would stop immediately.

@panic E32USER-CBase 92 if the wait object has not been started.

@see CActiveSchedulerWait::Start

@see CActiveSchedulerWait::AsyncStop

*/

 	{

	__ASSERT_ALWAYS(IsStarted(), Panic(EActiveSchedulerWaitNotStarted));		// Scheduler must be running

	for (CActiveScheduler::TLoop* loop=GetActiveScheduler()->iStack; loop; loop=loop->iNext)

		{

		if (loop==iLoop)

			return ETrue;

		if (loop->iOwner != KLoopInactive)

			break;

		}

	return EFalse;

	}

EXPORT_C CActiveScheduler::CActiveScheduler()

	: iActiveQ(_FOFF(CActive,iLink))

/**

Constructs an active scheduler.

After construction, the scheduler should be installed.

@see CActiveScheduler::Install

*/

	{}

EXPORT_C CActiveScheduler::~CActiveScheduler()

/**

Frees resources prior to destruction.

Specifically, it removes all active objects from the active scheduler's list

of active objects.

An active scheduler should only be destroyed when the top-level call to Start()

has returned.

@see CActiveScheduler::Start

@see CActiveScheduler::Stop

*/

	{

	while (!iActiveQ.IsEmpty())

		iActiveQ.First()->Deque();

	if (GetActiveScheduler()==this)

		SetActiveScheduler(NULL);

	}

EXPORT_C void CActiveScheduler::Install(CActiveScheduler *aManager)

/**

Installs the specified active scheduler as the current active scheduler.

The installed active scheduler now handles events for this thread.

The current active scheduler can be uninstalled by passing a NULL pointer.

@param aManager A pointer to the active scheduler to be installed.

                If this is NULL, the current active scheduler is uninstalled.

@panic E32USER-CBase 43 if If there is already an installed active scheduler.

*/

	{

	if (aManager!=NULL)

		__ASSERT_ALWAYS(GetActiveScheduler()==NULL,Panic(EReqManagerAlreadyExists));

	SetActiveScheduler(aManager);

	}

EXPORT_C void CActiveScheduler::Add(CActive *aRequest)

/**

Adds the specified active object to the current active scheduler.

An active object can be removed from an active scheduler either by

destroying the active object or by using its Deque() member function.

@param aRequest Pointer to the active object to be added.

@panic E32USER-CBase 41 if the active object aRequest has already been added

       to the current active scheduler.

@panic E32USER-CBase 48 if aRequest is NULL.

@panic E32USER-CBase 44 if the thread does not have an installed

       active scheduler.

@see CActive::Deque

*/

	{

	CActiveScheduler *pS=GetActiveScheduler();

	__ASSERT_ALWAYS(pS!=NULL,Panic(EReqManagerDoesNotExist));

	__ASSERT_ALWAYS(aRequest,Panic(EReqNull));

	__ASSERT_ALWAYS(!aRequest->IsAdded(),Panic(EReqAlreadyAdded));

	pS->iActiveQ.Add(*aRequest);

	}

EXPORT_C void CActiveScheduler::WaitForAnyRequest()

/**

Wait for an asynchronous request to complete.

The default implementation just calls User::WaitForAnyRequest().

Derived classes can replace this. Typically, this would be done to implement

code for maintaining an outstanding request; this would be followed by a call

to User::WaitForAnyRequest().

@see User::WaitForAnyRequest

*/

	{

	User::WaitForAnyRequest();

	}

EXPORT_C void CActiveScheduler::Start()

/**

Starts a new wait loop under the control of the current active scheduler.

At least one active object, with an outstanding request, must be added

to the scheduler before the wait loop is started, otherwise no events

will occur and the thread will hang, or any events that do occur will be

counted as stray signals, raising a panic.

While Start() is executing, user code runs only:

1. in the RunL() function of active objects known to the current active scheduler

2. in the RunError() function of an active object that leaves from its RunL()

3. in the current active scheduler’s Error() function, if an active object’s

   RunError() returns an error code.

Start() returns only when a corresponding Stop() or Halt() is issued.

Although this can be used to start a nested wait loop, this API is deprecated

for that specific functionality, and a CActiveSchedulerWait object should be

used instead.

(Note that a nested wait loop is used when the handling of a completed event

 in an active object requires the processing of further events from the other

 active objects before it can complete. This is a form of modal processing.)

@panic E32USER-CBase 44 if the thread does not have an active

       scheduler installed.

@see CActiveScheduler::Stop

@see CActiveScheduler::Halt

@see CActive::RunL

@see CActive::RunError

@see CActiveScheduler::Error

@see CActiveSchedulerWait

*/

	{

	Start(KLoopNoOwner);

	}

void CActiveScheduler::Start(TLoopOwner* aOwner)

/**

@internalComponent

Start a new nesting level

*/

	{

	CActiveScheduler* pS=GetActiveScheduler();

	__ASSERT_ALWAYS(pS!=NULL, Panic(EReqManagerDoesNotExist));

	// Instantiate the local loop control

	TLoop loop;

	loop.iOwner=aOwner;

	if (aOwner != KLoopNoOwner)

		*aOwner=&loop;

	loop.iNext=pS->iStack;

	pS->iStack=&loop;

	loop.iExitCode=0;

	// Run the scheduler loop

#if 1

	// FIXME!!! Will support old-style leave-from-Error() transiently

	// in order to avoid simultaneous integration requirement.

	// This should be reverted to the conditionally excluded code once

	// fixes have been made elsewhere

	TRAPD(r,pS->Run(loop.iOwner));

	if (r!=KErrNone)

		{

		loop.iExitCode = r;

		TLoopOwner* owner=loop.iOwner;

		if (TUint(owner) > TUint(KLoopNoOwner))

			*owner = NULL;

		}

#else	// fixme

#ifdef _DEBUG

	// catch old-style bad behaviour - leaving from Error()

	TRAPD(r,pS->Run(loop.iOwner));

	__ASSERT_DEBUG(r==KErrNone,User::Invariant());

#else

	pS->Run(loop.iOwner);

#endif

#endif

	pS->iStack=loop.iNext;

	loop.iCallback.CallBack();

	// propagate the exit-code via a leave (yuck, but blame BAFL & co.)

	if (loop.iExitCode)

		User::Leave(loop.iExitCode);

	}

/*

@internalComponent

Dummy Function. This is used as a dummy object to put onto the cleanupstack in order

to check for imbalance in the CActiveScheduler::DoRunL.

 */

void DummyFunc(TAny* /*aPtr*/)

	{}

#ifdef __LEAVE_EQUALS_THROW__

/**

@internalComponent

Start dispatching request completions.

Stop when aLoop becomes 'Inactive'

This version uses the implementation of TRAP/Leave in terms of C++ exceptions.

We have to make sure here that we don't call Active Object's RunError() or Active Scheduler's Error()

while we are still in exception (within 'catch' brackets), as it can lead to nested-exceptions scenario.

It is not fatal by default, but if two nested exceptions are due to OOM condition, RVCT implementation

of exception will run out of emergency buffers and terminate the thread.

*/

void CActiveScheduler::Run(TLoopOwner* const volatile& aLoop)

	{

	CActive * volatile curr_obj = 0;

	TBool leaveException = EFalse;

	TInt exceptionReason = 0;

	do

		{

		try	{

			__WIN32SEHTRAP

			TTrapHandler* t = User::MarkCleanupStack();

#ifdef _DEBUG

			//We cache the cleanupstack here do avoid repeated exec calls in DoRunL

			TCleanupTrapHandler *pH=(TCleanupTrapHandler *)GetTrapHandler();

			CCleanup* cleanupPtr=NULL;

			TCleanupBundle cleanupBundle;

			if(pH!=NULL) // test whether there's a CleanupTrapHandler installed

				{

				CCleanup& ccleanup =pH->Cleanup();

				//Store pointer as need the scope of ccleanup increased

				cleanupPtr = &ccleanup; 

				cleanupBundle.iCleanupPtr = cleanupPtr;

				//Push a dummy item onto the stack - we check it after the AO's RunL has returned

				//and we check to make sure its still at the top.

				ccleanup.PushL(TCleanupItem(DummyFunc, &(cleanupBundle.iDummyInt)));

				DoRunL(aLoop, curr_obj, &cleanupBundle);

				//Dummy Int must (will) be at the top

				//Cleanup our stack

				cleanupPtr->Pop(1);

				} 

			else // no cleanup stack installed

				{

				DoRunL(aLoop, curr_obj, NULL);

				}

#else

			DoRunL(aLoop, curr_obj, NULL);

#endif

			User::UnMarkCleanupStack(t);

			__WIN32SEHUNTRAP

			return;

			}

		catch (XLeaveException& l)

			{

			Exec::LeaveEnd();

			leaveException = ETrue;

			exceptionReason = l.Reason();

			}

		catch (...)

			{

			User::Invariant();

			}

		if (leaveException)

			{

			if (exceptionReason != KErrNone)

				{