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