/*

* Copyright (c) 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 <e32svr.h>

#include <stfeventsystemerrorcodes.h>

#include "waitingevent.h"

/**

 * Constructor for performing 1st stage construction

 */

CWaitingEvent::CWaitingEvent(const TInt aOwnerId): iOwnerId(aOwnerId)

    {

    RDebug::Print(_L("STF [ESS]: CWaitingEvent::CWaitingEvent() iOwnerId=[%d]"), iOwnerId);

    }

/**

 * Destructor.

 */

CWaitingEvent::~CWaitingEvent()

    {

    RDebug::Print(_L("STF [ESS]: CWaitingEvent::~CWaitingEvent() iOwnerId=[%d]"), iOwnerId);

    if(iMessage && iState == EEventWaiting)

        {

        RDebug::Print(_L("STF [ESS]: Cancelling event [%S] in destructor"), iEventName);

        iMessage->Complete(KErrCancel);

        delete iMessage;

        }

    delete iEventName;

    }

/**

 * Two-phased constructor.

 */

CWaitingEvent* CWaitingEvent::NewLC(const TDesC& aEventName, const TInt aOwnerId)

    {

    //RDebug::Print(_L("STF [ESS]: CWaitingEvent::NewLC()"));

    CWaitingEvent* self = new (ELeave) CWaitingEvent(aOwnerId);

    CleanupStack::PushL(self);

    self->ConstructL(aEventName);

    return self;

    }

/**

 * Two-phased constructor.

 */

CWaitingEvent* CWaitingEvent::NewL(const TDesC& aEventName, const TInt aOwnerId)

    {

    //RDebug::Print(_L("STF [ESS]: CWaitingEvent::NewL()"));

    CWaitingEvent* self = CWaitingEvent::NewLC(aEventName, aOwnerId);

    CleanupStack::Pop();

    return self;

    }

/**

 * Constructor for performing 2nd stage construction

 */

void CWaitingEvent::ConstructL(const TDesC& aEventName)

    {

    //RDebug::Print(_L("STF [ESS]: CWaitingEvent::ConstructL()"));

    iEventName = aEventName.AllocL();

    RDebug::Print(_L("STF [ESS]: Event [%S] is set state to [EEventRequested]"), iEventName);

    iState = EEventRequested;

    RDebug::Print(_L("STF [ESS]: Event [%S] is set iEventSetWhenRequested notification to [EFalse]"), iEventName);    

    iEventSetWhenRequested = EFalse;

    }

/**

 * Checks if event name is the same as provided in argument

 */

TInt CWaitingEvent::IsMatchingEvent(const TDesC& aEventName)

    {

    return (aEventName.Compare(*iEventName) == 0) ? (1) : (0);

    }

/**

 * Checks if event name is the same as provided in argument

 */

TInt CWaitingEvent::IsMatchingEvent(const TDesC& aEventName, const TInt aOwnerId)

    {

    return (aEventName.Compare(*iEventName) == 0 && iOwnerId == aOwnerId) ? (1) : (0);

    }

/**

 * Checks if event's session is the same as provided in argument

 */

TInt CWaitingEvent::IsMatchingSession(const CSession2* aSession)

    {

    return (aSession == iSession);

    }

/**

 * Complete event

 */

void CWaitingEvent::CompleteEventL()

    {

    RDebug::Print(_L("STF [ESS]: CWaitingEvent::CompleteEventL(): Completing event [%S]"), iEventName);

    if(iState == EEventWaiting)

        {

        iMessage->Complete(KErrNone);

        delete iMessage;

        iMessage = NULL;

        RDebug::Print(_L("STF [ESS]: Event [%S] switches state to [EEventRequested]"), iEventName);

        iState = EEventRequested;

        if(iEventSetWhenRequested)

            {

            RDebug::Print(_L("STF [ESS]: Event [%S] switches iEventSetWhenRequested notification to [EFalse]"), iEventName);    

            iEventSetWhenRequested = EFalse;

            }

        }

    }

/**

 * Cancel event (because i.e. test case is being cancelled)

 */

void CWaitingEvent::CancelEvent()

    {

    RDebug::Print(_L("STF [ESS]: CWaitingEvent::CancelEvent()"));

    if(iMessage && iState == EEventWaiting)

        {

        iMessage->Complete(KErrCancel);

        delete iMessage;

        iMessage = NULL;

        RDebug::Print(_L("STF [ESS]: Event [%S] switches state to [EEventRequested]"), iEventName);

        iState = EEventRequested;

        }

    }

/**

 * Wait for event (allowed only if event is in requested state)

 */

void CWaitingEvent::WaitL(const RMessage2& aMessage, const CSession2* aSession)

    {

    __ASSERT_ALWAYS(aSession != NULL, PanicClient(aMessage, EEventSystemSessionNotDefined));

    // Check if we can wait for event

    if(iState != EEventRequested)

        {

        RDebug::Print(_L("STF [ESS]: CWaitingEvent::WaitL() Event not requested"));

        User::Leave(EEventSystemNotInRequestedState);

        }

    // Set values

    iMessage = new RMessage2(aMessage);

    iSession = const_cast<CSession2*>(aSession);

    // Switch to real waiting

    RDebug::Print(_L("STF [ESS]: Event [%S] switches state to [EEventWaiting]"), iEventName);

    iState = EEventWaiting;

    // If indication event was set when this event was in requested state, complete immediately

    if(iEventSetWhenRequested)

         {

         CompleteEventL();

         }

    }

/**

 * Give event name

 */

const TDesC& CWaitingEvent::EventName()

    {

    return *iEventName;

    }

/**

 * Check if event is in requested state

 */

TInt CWaitingEvent::IsRequested()

    {

    return iState == EEventRequested;

    }

/**

 * Check if event is waitng

 */

TInt CWaitingEvent::IsWaiting()

    {

    return iState == EEventWaiting;

    }

/**

Panics the client

*/

void CWaitingEvent::PanicClient(const RMessage2& aMessage, const TInt aPanic) const

    {

    RDebug::Print(_L("STF [ESS]: CWaitingEvent::PanicClient"));

    _LIT(KMessage, "CEventSystemSession");

    aMessage.Panic(KMessage, aPanic);

    }

// Notify requested event, that indicatin event 

void CWaitingEvent::NotifyRequestedEventL()

    {

    if(!iEventSetWhenRequested)

        {

        RDebug::Print(_L("STF [ESS]: Event [%S] switches iEventSetWhenRequested notification to [ETrue]"), iEventName);    

        iEventSetWhenRequested = ETrue;

        }

    }

// Give owner id 

TInt CWaitingEvent::OwnerId()

    {

    return iOwnerId;

    }     

// EOF