/*

* Copyright (c) 2010 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: 

*

*/

#ifndef WAITINGEVENT_H

#define WAITINGEVENT_H

// INCLUDES

#include <e32std.h>

#include <e32base.h>

// CLASS DECLARATION

/**

 *  CWaitingEvent - class representing waiting events 

 *  Object of that type is created when there was a request for the event.

 *  After event is requested, it can wait for another event.

 */

class CWaitingEvent : public CBase

    {

    public:

        // Destructor.

        ~CWaitingEvent();

        // Two-phased constructor.

        static CWaitingEvent* NewL(const TDesC& aEventName, const TInt aCallerId);

        // Two-phased constructor.

        static CWaitingEvent* NewLC(const TDesC& aEventName, const TInt aCallerId);

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

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

        // Complete waiting event

        void CompleteEventL();

        // Cancel event

        void CancelEvent(void);

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

        TInt IsMatchingEvent(const TDesC& aEventName, const TInt aCallerId);

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

        TInt IsMatchingEvent(const TDesC& aEventName);

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

        TInt IsMatchingSession(const CSession2* aSession);

        // Give event name

        const TDesC& EventName();

        // Check if event is in requested state

        TInt IsRequested();

        // Check if event is waitng

        TInt IsWaiting();

        // Notify requested event, that indicatin event 

        void NotifyRequestedEventL();

        // Give owner id 

        TInt OwnerId();

    private:

        // Shows current state of the event

        enum TEventState

            {

            EEventRequested,

            EEventWaiting

            };

        // Constructor for performing 1st stage construction

        CWaitingEvent(const TInt aCallerId);

        // Constructor for performing 2nd stage construction

        void ConstructL(const TDesC& aEventName);

        // Panics the client

        void PanicClient(const RMessage2& aMessage, const TInt aPanic) const;

    private:

        // Event name

        HBufC* iEventName;

        // Owner id. The same named waiting event may be requested by different callers - so we need to distinguish them

        const TInt iOwnerId;

        // Message to complete with event

        RMessage2* iMessage;

        // Session of the waiting event

        CSession2* iSession;

        // State of the event

        TEventState iState;

        // Defines if indication event was set in the moment when this waiting event was in requested state

        TBool iEventSetWhenRequested;

    };

#endif // WAITINGEVENT_H

// EOF