// 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.

*/

	{