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

// Implements the CSmsuActive class

// 

//

/**

 @file

*/

#include "smsuact.h"

#include "SmsuTimer.h"

#include "smsstacklog.h"

#include "smsumain.h"

/**

 *  Constructor.

 *  

 *  @param aPriority Active object priority

 *  @capability None

 */

EXPORT_C CSmsuActiveBase::CSmsuActiveBase(TInt aPriority)

: CActive(aPriority)

	{

	CActiveScheduler::Add(this);

	} // CSmsuActiveBase::CSmsuActiveBase

/**

 *  Destructor.

 *  @capability None

 */

EXPORT_C CSmsuActiveBase::~CSmsuActiveBase()

	{

	Cancel();

	delete iSmsuTimeout;

	} // CSmsuActiveBase::~CSmsuActiveBase

/**

 *  Constructs a timer.

 *  

 *  This is required before use of TimedSetActive().

 *  @capability None

 */

EXPORT_C void CSmsuActiveBase::ConstructTimeoutL()

	{

	LOGSMSU1("CSmsuActiveBase::ConstructTimeoutL()");

	iSmsuTimeout = CSmsuTimeout::NewL(*this);

	} // CSmsuActiveBase::ConstructTimeoutL

/**

 *  Activates the object, and sets it to be completed after a specified time.

 *  

 *  @param aTimeIntervalMicroSeconds32 Time after which to complete the object

 *  @capability None

 */

EXPORT_C void CSmsuActiveBase::TimedSetActive(const TTimeIntervalMicroSeconds32& aTimeIntervalMicroSeconds32)

	{

	LOGSMSU2("CSmsuActiveBase::TimedSetActive(): aTimeIntervalMicroSeconds32=%d",

			 aTimeIntervalMicroSeconds32.Int());

	__ASSERT_DEBUG(iSmsuTimeout != NULL, SmsuPanic(ESmsuTimeoutNull));

	if (iSmsuTimeout != NULL)

		{

		iSmsuTimeout->Start(aTimeIntervalMicroSeconds32);

		}

	SetActive();

	} // CSmsuActiveBase::TimedSetActive

/**

 *  Cancels a TimedSetActive() request.

 *

 *  @see TimedSetActive

 */

EXPORT_C void CSmsuActiveBase::TimedSetActiveCancel()

	{

	LOGSMSU1("CSmsuActiveBase::TimedSetActiveCancel()");

	if (iSmsuTimeout != NULL)

		{

		iSmsuTimeout->Cancel();

		}

	} // CSmsuActiveBase::TimedSetActiveCancel

/**

 *  Determines if the object has timed out.

 *

 *  @see TimedSetActive

 */

EXPORT_C TBool CSmsuActiveBase::TimedOut() const

	{

	LOGSMSU1("CSmsuActiveBase::TimedOut()");

	if (iSmsuTimeout != NULL)

		{

		return iSmsuTimeout->TimedOut();

		}

	return EFalse;

	} // CSmsuActiveBase::TimedOut

/**

 *  Sets an asynchronous observer to which to report completion of this object.

 *  

 *  @param aStatus Asynchronous status word of the observer

 *  @capability None

 */

EXPORT_C void CSmsuActiveBase::Queue(TRequestStatus& aStatus)

	{

	LOGSMSU1("CSmsuActiveBase::Queue()");

	__ASSERT_DEBUG(iReport==NULL, SmsuPanic(ESmsuAlreadyActive));

	aStatus=KRequestPending;

	iReport=&aStatus;

	} // CSmsuActiveBase::Queue

/**

 *  Handles the object's request completion event.

 *  

 *  If a timer has been set with TimedSetActive(), this is cancelled. DoRunL()

 *  is then called. If, after this, the object is not active, Complete() is called.

 *  @capability None

 */

EXPORT_C void CSmsuActiveBase::RunL()

	{

	LOGSMSU1("CSmsuActiveBase::RunL()");

	if (iSmsuTimeout != NULL)

		{

		iSmsuTimeout->Cancel();

		}

	DoRunL();

    if (!IsActive())

    	{

        Complete(iStatus.Int());

        }

	} // CSmsuActiveBase::RunL

/**

 *  Object use complete.

 *  

 *  This is called at the end of the RunL(), if the RunL() has not reset the object

 *  to be active.

 *  

 *  If an observer has been set (see Queue()), DoComplete() is called, and that

 *  observer is signalled with the object status.

 *  

 *  @param aStatus Active object status word

 *  @capability None

 */

EXPORT_C void CSmsuActiveBase::Complete(TInt aStatus)

	{

	LOGSMSU2("CSmsuActiveBase::Complete(): aStatus=%d", aStatus);

	if (iReport)

		{

		DoComplete(aStatus);

		User::RequestComplete(iReport, aStatus);

		iReport = NULL;

		}

	} // CSmsuActiveBase::Complete

/**

 *  Handles leaves occurring in the RunL() function.

 *  

 *  It calls Complete().

 *  

 *  @param aError RunL() leave code

 *  @return KErrNone

 *  @capability None

 */

EXPORT_C TInt CSmsuActiveBase::RunError(TInt aError)

	{

	LOGSMSU2("CSmsuActiveBase::RunError(): aError=%d", aError);

	__ASSERT_DEBUG(!IsActive(), User::Invariant());

	Complete(aError);

	return KErrNone;

	} // CSmsuActiveBase::RunError

/**

 *  Signals this object.

 *  

 *  @param aStatus Status code with which to signal the object

 *  @param aSetActive True to set the object to be active

 *  @capability None

 */

EXPORT_C void CSmsuActiveBase::CompleteMyself(TInt aStatus, TBool aSetActive /* = ETrue */)

    {

    // Ignore in code coverage - not used within the SMS stack.

    BULLSEYE_OFF

    LOGSMSU3("CSmsuActiveBase::CompleteMyself(): aStatus=%d, aSetActive=%d",

             aStatus, aSetActive);

    // Initialise iStatus with a pending request...

    iStatus = KRequestPending;

    // Set active if required...

    if (aSetActive)

        {

        SetActive();

        }

    // Complete the request...

    TRequestStatus* status = &iStatus;

    User::RequestComplete(status, aStatus);

    BULLSEYE_RESTORE

    }

/**

 *  This function is used to request that the active object is completed

 *  after the current timeout is handled. When a timeout occurs, the active

 *  object is cancelled which requires DoCancel() to be called. However

 *  the object is active until after the DoCancel() meaning it is not

 *  possible to make a new request. This function requests a second

 *  call to Complete() (via RunL etc.) which is done without the object

 *  being active.

 *

 *  This function can only be called when a timeout occurs, otherwise

 *  it would not get actioned.

 *  

 *  @param aStatus Status code with which to signal the object

 *

 *  @capability None

 */

EXPORT_C void CSmsuActiveBase::CompleteMyselfAfterTimeout(TInt aStatus)

	{

	LOGSMSU2("CSmsuActiveBase::CompleteMyselfAfterTimeout(): aStatus=%d", aStatus);

	__ASSERT_DEBUG(iSmsuTimeout != NULL, SmsuPanic(ESmsuTimeoutNull));

	if (iSmsuTimeout != NULL  &&  iSmsuTimeout->TimedOut())

		{

		iSmsuTimeout->RequestCompleteMyselfAfterCancel(aStatus);

		}

	} // CSmsuActiveBase::CompleteMyselfAfterTimeout