/*
* Copyright (c) 2008-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:
* Name        : SipImplementation.h
* Part of     : SIP Client
* Version     : SIP /6.0
*
*/




/**
 @internalComponent
*/

#ifndef CSIPIMPLEMENTATION_H
#define CSIPIMPLEMENTATION_H

// INCLUDES
#include <e32base.h>
#include "_sipcodecdefs.h"
#include "sipclientobserver.h"
#include "transactionassociation.h"

// FORWARD DECLARATIONS
class CDesC8Array;
class MSIPObserver;
class CSIPClient;
class CSIPConnection;
class CSIPConnectionImplementation;
class CRegistrationState;
class CUnregistered;
class CRegistering;
class CRegistered;
class CUnregistering;
class CDialogState;
class CDialogTrying;
class CDialogEarly;
class CDialogConfirmed;
class CDialogTerminated;
class CSIPRequestElements;
class CPendingTransaction;
class CSIPClientTransaction;
class CSIPRefresh;
class CSIPHttpDigest;

// CLASS DECLARATION

/**
*  Implementation class for connecting to SIP server.
*/
class CSIPImplementation :
    public CBase,
    public MSIPClientObserver,
    public MTransactionAssociation
	{
    public: //Constructors and destructor
        
	    /**
        * Two-phased constructor.
		* @param aUid an unique id that identifies client
		* @param aObserver a observer for asynchronous event
        * @return New object, ownership is transferred
        */
		static CSIPImplementation* NewL(const TUid& aUid,
										MSIPObserver& aObserver);
	    
        /**
        * Destructor.               
        */
		~CSIPImplementation();

	public : //From MSIPClientObserver:
		/**
		* Request has been received from network.
        *
        * @param aIapId IAP-id for which the user should create a
        *   CSIPConnection
        * @param aElements Some SIP headers of the received request. Ownership
        *   is transferred.
        * @param aRequestId RequestId associated with the received request
		*/
		void IncomingRequestL(TUint32 aIapId,
        	                  CSIPRequestElements* aElements,
            	              TUint32 aRequestId);


        /**
	     * The transcation related to the received SIP request timed out and it
         * has been destroyed. This happens if the user fails to create a SIP
         * connection and does not send an appropriate SIP response.
         *
         * @param aRequestId RequestId of the request
	     */
    	void TimeOut(TUint32 aRequestId);

        void ChallengeReceivedL(
            TUint32 aRequestId,
            CSIPResponseElements* aResponse,
            MSIPHttpDigestChallengeObserver2& aObserver);

        void ChallengeReceivedInRefreshL(
            TUint32 aRefreshId,
            TUint32 aRequestId,
            CSIPResponseElements* aResponse,
            MSIPHttpDigestChallengeObserver2& aObserver);

    public: //From MTransactionAssociation:        
        
        CSIPClientConnection& ClientConnectionL();
        
        CSIPClientConnection* ClientConnection();

        CSIPConnection& SIPConnectionL();

        void AddTransactionL(CSIPTransactionBase& aTransaction);

        void RemoveTransaction(const CSIPTransactionBase& aTransaction);

    public: // New functions

		/**
		* Gets all supported security mechanisms
		* @return supported SIP security mechanisms names (e.g. digest);
        *   the ownership is transferred
		*/
		CDesC8Array* SupportedSecurityMechanismsL() const;

		/**
		* Checks if the signalling compression (SigComp) is supported.
        * Leaves on failure with a system wide error code.
		* @return ETrue if supported, EFalse otherwise
		*/
		TBool IsSigCompSupportedL() const;

		/**
		* Gets negotiated security mechanism with the next hop
		* on the signaling path.
		* @param aHop the next hop's FQDN or numeric IP address
		* @return negotiated security mechanism or zero-pointer in case no
		*		  security mechanism was negotiated with the next hop;
		*		  the ownership is transferred
		*/
		HBufC8* NegotiatedSecurityMechanismL(const TDesC8& aHop) const;

		/**
		* Checks if the user has a connection created for given IAP-id
		* @param aIapId IAP-id
 		* @return sip connection or 0-pointer if connection does not exist.
        *   Ownership is not transferred.
		*/
		CSIPConnection* Connection(TUint32 aIapId) const;

        /*
        * By default the SIP built-in security mechanisms are enabled.
        * @param aEnabled if set to EFalse the build-in SIP security handling 
        *        mechanism is disabled.
        */
        void SetSecurityHandlingL(TBool aEnabled);

        /*
        * Tests if SIP security handling mechanism is enabled/disabled
        * @return ETrue if built-in mechanisms are enabled, EFalse otherwise.
        */
        TBool IsSecurityHandlingEnabled() const;

        /*
        * Create a client transaction for handling a received challenge.
        * @param aRequestId Request id
        * @param aResponse Response elements, ownership is transferred
        * @param aRefresh Refresh to which the transaction will be associated,
        *				  or NULL if no refresh used.
        *				  Ownership is not transferred.
        */
		CSIPClientTransaction*
			CreateTransactionL(TUint32 aRequestId,
							   CSIPResponseElements* aResponse,
							   CSIPRefresh* aRefresh);

		/**
		* Ignore each challenge present in the response in the transaction.
        * @param aTransaction Client transaction
        * @param aDigest HTTP digest
		*/
        void IgnoreChallenges(const CSIPClientTransaction& aTransaction,
        					  CSIPHttpDigest& aDigest);

        /**
		* Obtains the used CSIPClient instance
        *
 		* @return SIPClient
		*/
        CSIPClient& SIPClient();

        /**
		* Adds a new connection into CSIPImplementation.
        *        
		* @param aConnImplementation Implementation of the connection to add
        * @param aIapId IAP-id        
		*/
        void AddConnectionL(CSIPConnectionImplementation& aConnImplementation,
        					TUint32 aIapId);

        /**
		* Detach a connection from CSIPImplementation
        *
		* @param aConnection Connection to remove
		*/
        void RemoveConnection(const CSIPConnection& aConnection);

		/**
		* Attach a CSIPHttpDigest to CSIPImplementation
        *        
		* @param aDigest CSIPHttpDigest object to attach
		*/
        void AddDigestL(CSIPHttpDigest& aDigest);

		/**
		* Detach a CSIPHttpDigest from CSIPImplementation
        *
		* @param aDigest CSIPHttpDigest object to remove
		*/
		void RemoveDigest(const CSIPHttpDigest& aDigest);

        /**
		* Obtains the initial state for CSIPRegistrations
        *
		* @return Initial state of registration state machine. Ownership isn't
        *   transferred.
		*/
        CRegistrationState* InitialRegisterState();
        
        /**
		* Obtains the initial state for CSIPDialog
        *
		* @return Initial state of dialog state machine. Ownership isn't
        *   transferred.
		*/
        CDialogState* InitialDialogState();

    private: // Constructors
        CSIPImplementation(MSIPObserver& aObserver);

        void ConstructL(const TUid& aUid);

	private: // Data
        //Application's UID
        TUid iUid;
        
        TBool iSecurityHandlingEnabled;

        //Callback to the application
        MSIPObserver& iObserver;

        //SIP client
        CSIPClient* iSIPClient;

        //Existing connections, CSIPImplementation doesn't own them.
        RPointerArray<CSIPConnection> iConnections;

        //When a request comes from network with an IAP-id for which there is
        //no CSIPConnection instance, the created ServerTransaction is stored
        //here. In case TimeOut occurs, CSIPImplementation can give the pointer
        //to the associated ServerTransaction to application.
        //When application creates a CSIPConnection, all ServerTransactions
        //which have the same IAP-id are removed from this array.
        RPointerArray<CPendingTransaction> iPendingServerTransactions;

		//CSIPHttpDigest objects are not owned
		RPointerArray<CSIPHttpDigest> iDigests;

        //Registration states. These are owned by CSIPImplementation and are
        //shared by all CSIPRegistrationBinding instances.
        CUnregistered* iUnregistered;
        CRegistering* iRegistering;
        CRegistered* iRegistered;
        CUnregistering* iUnregistering;        

        //Dialog states. These are owned by CSIPImplementation and are shared
        //by all CSIPDialog instances. There is no proceeding state.
        CDialogTrying* iDialogTrying;        
        CDialogEarly* iDialogEarly;
        CDialogConfirmed* iDialogConfirmed;
        CDialogTerminated* iDialogTerminated;		
	
	private: // For testing purposes
	    UNIT_TEST(CSIP_Test)
        UNIT_TEST(CSIPRegistrationBinding_Test)
        UNIT_TEST(CSIPInviteDialogAssoc_Test)
        UNIT_TEST(CSIPSubscribeDialogAssoc_Test)
        UNIT_TEST(CSIPReferDialogAssoc_Test)
        
		void __DbgTestInvariant() const;

		};

#endif