/*
* Copyright (c) 2005 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 CMCEEVENT_H
#define CMCEEVENT_H

// INCLUDES
#include <e32base.h>
#include <mcedefs.h>

// FORWARD DECLARATIONS
class CDesC8Array;
class TMceIds;
class CMceItcSender;
class CMceManager;
class CMceEventReceiver;
class CMceMsgBase;
class TMceEvent;
class CMceSession;
class CMceRefer;

// CLASS DECLARATION

/**
* Base class for MCE events, inherited by both CMceInEvent and CMceOutEvent.
*
* CMceEvent represents peer-to-peer connection made with remote terminal.
* This connection is also known as dialog and it is set up using SIP SUBSCRIBE
* method.
*
* MCE events are typically used for queurying state of some parameter of 
* remote terminal. The queuried parameter is known as event header.
* The changes of this parameter are notified to another terminal by sending
* SIP NOTIFY messages.
*
* The event can be finally terminated by either endpoints.
*
* If for any reason instance of this class is deleted while in active state,
* event is automatically terminated by MCE server.
*
*  @lib mceclient.lib
*/
class CMceEvent : public CBase
    {
    public: // Event states
    
        enum TState
            {
            EIdle, 
            EPending,
            EActive,
            ETerminated 
            };
    
    public: // Constructors and destructors

		/**
		* Destructor.
		*/
		virtual ~CMceEvent();
	
    public: // New functions

		/**
        * Terminates the event.
	    * @pre State() == CMceEvent::EActive
	    * @post State() == CMCEvent::EPending
		* @param aHeaders, additional headers of the message. 
		*        The Ownership is transferred.
		* @param aContentType, the type of the message content. 
		*        The ownership is transferred.
	    * @param aContent, the content to be added in the message body. 
	    *        The ownership is transferred.	    	  
	    * @leave KErrNotSupported if event cannot be terminated 
	    *        (e.g. event attached to a CMceOutRefer)
        */
        IMPORT_C void TerminateL(
            CDesC8Array* aHeaders = 0,
            HBufC8* aContentType = 0,
            HBufC8* aContent = 0 );         

        /**
        * Returns the state of the event.
        * @return The current state of the event
        */
        IMPORT_C TState State() const;
        
        /**
        * Returns the address of the recipient
        * @return The the address of the recipient
        */
        IMPORT_C const TDesC8& Recipient() const;
        
        /**
        * Returns the address of the originator
        * @return the address of the Originator
        */
        IMPORT_C const TDesC8& Originator() const;
        
        /**
        * Returns the Event header.
        * @return the Event header
        */
        IMPORT_C const TDesC8& EventHeader() const;

        /**
        * Returns the associated session, if any.
        * @return CMceSession Associated session, NULL if does not exist.
        */
        IMPORT_C CMceSession* AssociatedSession() const;

        /**
        * Returns the associated events, if any.
	    * @return RPointerArray array of associated events, ownership is transferred.
	    */
		IMPORT_C RPointerArray< CMceEvent >* AssociatedEventsL() const;

        /**
        * Returns the associated refers, if any.
	    * @return RPointerArray array of associated refers, ownership is transferred.
	    */
		IMPORT_C RPointerArray< CMceRefer >* AssociatedRefersL() const;
        
	public: // New functions, internal
	    
	    /**
        * ID 
        * @return ID
        */
	    TUint32 Id() const;

	    /**
        * Dialog ID 
        * @return dialog ID
        */
	    TUint32 DialogId() const;
	    
	    /**
        * Gets SIP profile id.
        * @return profile id.
        */
		TUint32 ProfileId() const;
	    
	    /**
        * Gets sender for ITC.
        * @return ITC sender
        */
        CMceItcSender& ITCSender();
        
        /**
        * Gets manager
        * @return manager
        */
        CMceManager& Manager();
        
        /**
        * Gets the type of the event
        * @return ETrue in InEvent
        */
		virtual TBool IsInEvent() const = 0;
		
    
    public: // New functions, event handling 

        /**
        * Handles reception of event update
        * @param aId id of object whose state is needed to be updated
        */
        void EventReceivedL( TMceIds& aId );

        /**
        * Handles reception of event update
        * @param aId id of object whose state is needed to be updated
        * @param aMessage the message
        */
        void EventReceivedL( TMceIds& aId, CMceMsgBase& aMessage );

        /**
        * Handles reception of event update
        * @param aId id of object whose state is needed to be updated
        * @param aMessage the message
        * @param aContent the content
        */
        void EventReceivedL( TMceIds& aId, CMceMsgBase& aMessage, HBufC8* aContent );

        /**
        * Handling of error
        * @param aError the error
        */
        void ErrorOccuredL( TInt aError );
        
	protected:  // New functions
	    
	    /**
        * C++ default constructor.
        * @param aManager, reference to event manager.
        * @param aProfileId, id of the sip profile used for the event.
        * @param aDialogId, 
        * @param aRefreshInterval, 
        */
        CMceEvent( CMceManager& aManager, 
                   TUint32 aProfileId,
                   TUint32 aDialogId,
                   TUint32 aRefreshInterval );	
	    
	    /**
        * Prepares ids for ITC
        * @param aId ITC ids
        */
        void PrepareForITC( TMceIds& aId );
        
        /**
        * second-phase constructor
        * @param aEventHeader
        * @param aRecipient
        * @param aOriginator
        * @param aDialogType
        */
	    void ConstructL( HBufC8* aEventHeader, 
	                     HBufC8* aRecipient,
	                     HBufC8* aOriginator,
	                     TUint32 aDialogType,
	                     CDesC8Array* aParams );
	 
	 
    private: // New functions, event handling and update
    
        /**
        * Traversal event handler
        * @param aEvent the event
        */
        void EventReceivedL( TMceEvent& aEvent );
        
        /**
        * Handles event
        * @param aEvent the event
        */
        void HandleEventL( TMceEvent& aEvent );
        
    protected:  // Data

        // current event state
        TState iState;
        
        /**
        * Sender, owned
        */
        CMceItcSender* iSender;
        
        /**
        * Event receiver, owned
        */
        CMceEventReceiver* iReceiver;
        
        /**
        * Event manager,not owned
        */
        CMceManager& iManager;
        
        /**
        * SIP profile id
        */        
        TUint32 iProfileId;
        
        /**
        * ID
        */
        TUint32 iId;
        
        /**
        * dialog id
        */
	    TUint32 iDialogId;
        
        /**
        * The event header
        */
        HBufC8* iEventHeader;

        /**
        * The recipient
        */
        HBufC8* iRecipient;
        
        /**
        * The originator
        */
        HBufC8* iOriginator;
        
        /**
        * The refresh interval
        */
        TUint32 iRefreshInterval;
        
    private: // Reserved for future use
    
        TAny* iReserved;       

	    MCE_UNIT_TEST_DEFS
        
    };

#endif