// Copyright (c) 2004-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 FILES

//

#include "SIPExSIPEngine.h"

#include "SIPExSIPStateBase.h"

#include <uri8.h>

#include <sipstrings.h>

#include <sipstrconsts.h>

// CONSTANTS

_LIT8( KSdpNoInfoDesC8, "-" );

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------

// CSIPExSIPEngine::NewL

// Two-phased constructor.

// -----------------------------------------------------------------------------

EXPORT_C CSIPExSIPEngine* CSIPExSIPEngine::NewL( 

    TUid aAppUid,

	MSIPExSIPEngineObserver* aObserver )

	{

	CSIPExSIPEngine* self = new( ELeave ) CSIPExSIPEngine();

	CleanupStack::PushL( self );

	self->ConstructL( aAppUid, aObserver );

	CleanupStack::Pop( self );

	return self;

	}

// -----------------------------------------------------------------------------

// Destructor.

// -----------------------------------------------------------------------------

CSIPExSIPEngine::~CSIPExSIPEngine()

	{

	SdpCodecStringPool::Close();

	delete iIdle;

	delete iClientEstablishing;

	delete iClientOffering;

	delete iServerOffering;

	delete iServerEstablishing;

	delete iEstablished;

	delete iTerminating;

	delete iClientTx;

	delete iServerTx;

	delete iDialogAssoc;

	delete iConnection;

	delete iProfile;

	delete iProfileRegistry;

	delete iSIP;

	}

// -----------------------------------------------------------------------------

// CSIPExSIPEngine::CSIPExSIPEngine

// C++ default constructor.

// -----------------------------------------------------------------------------

CSIPExSIPEngine::CSIPExSIPEngine()

	{

	}

// -----------------------------------------------------------------------------

// CSIPExSIPEngine::ConstructL

// Symbian 2nd phase constructor. Can leave.

// -----------------------------------------------------------------------------

void CSIPExSIPEngine::ConstructL( 

    TUid aAppUid,

	MSIPExSIPEngineObserver* aObserver )

	{

	// Make note of the observer class.

	iObserver = aObserver;

	// Create instances of the CSIP and Profile Registry classes

	iSIP = CSIP::NewL( aAppUid, *this );

	iProfileRegistry = CSIPProfileRegistry::NewL( *iSIP, *this );

	// Open SDP Codec String Pool

	StringPoolL();

	// Set our local address

	const TUint32 KInetAddr = INET_ADDR(127,0,0,1);

	iLocalAddr.SetAddress( KInetAddr );

	// Set up the state machine

	// Create instances of the state classes.

	iIdle = CSIPExSIPIdleState::NewL();

	iClientEstablishing = CSIPExSIPClientEstablishingState::NewL();

	iClientOffering = CSIPExSIPClientOfferingState::NewL();

	iServerOffering = CSIPExSIPServerOfferingState::NewL();

	iServerEstablishing = CSIPExSIPServerEstablishingState::NewL();

	iEstablished = CSIPExSIPEstablishedState::NewL();

	iTerminating = CSIPExSIPTerminatingState::NewL();

	// Create the links for state transitions.

	iIdle->LinkStates( *iClientEstablishing, *iServerOffering );

	iClientEstablishing->LinkStates( *iIdle, *iClientOffering, *iEstablished );

	iClientOffering->LinkStates( *iIdle, *iEstablished, *iIdle );

	iServerOffering->LinkStates( *iServerEstablishing, *iIdle );

	iServerEstablishing->LinkStates( *iEstablished, *iIdle );

	iEstablished->LinkStates( *iTerminating, *iIdle );

	iTerminating->LinkStates( *iIdle );

	// Set current state data

	iCurrentState = iIdle;

	iConnState = CSIPConnection::EInactive;

	}

// -----------------------------------------------------------------------------

// CSIPExSIPEngine::EnableProfileL

// First get the default profile from the registry, then, if it is

// an IETF profile, enable it.

// If non-IETF profile is default, call error callback with KErrNotSupported

// and leave

// Not part of the state machine.

// -----------------------------------------------------------------------------

EXPORT_C TBool CSIPExSIPEngine::EnableProfileL()

	{

	// Check for existing profile

	if ( iProfile )

		{

		delete iProfile;

		iProfile = NULL;

		}

    TBool registered( EFalse );

    // Leaves with KErrNotFound if default profile is not found

	iProfile = iProfileRegistry->DefaultProfileL();

    // Safety check that DefaultProfile() didn't return NULL pointer.

    if ( !iProfile )

        {

        iObserver->ProfileError( KErrNotFound );

        _LIT8( KProfileError, "Profile not found. Define a profile:");

        iObserver->WriteLog(KProfileError());

		User::Leave( KErrNotFound );

        }

    // Leaves if profile type is not EInternet

    else if ( iProfile->Type().iSIPProfileClass != TSIPProfileTypeInfo::EInternet )

		{

		delete iProfile;

		iProfile = NULL;

		iObserver->ProfileError( KErrNotSupported );

		User::Leave( KErrNotSupported );

		}

	else

		{

		const TDesC8* aor = NULL;

    	iProfile->GetParameter( KSIPUserAor, aor );  	

    	iObserver->WriteLog( *aor );

		iProfileRegistry->EnableL( *iProfile, *this );

		// check whether profile was immediately set to registered state

		iProfile->GetParameter( KSIPProfileRegistered, registered );

		}

    return registered;

	}

// -----------------------------------------------------------------------------

// CSIPExSIPEngine::DisableProfileL

// Disable the profile given as a parameter.

// Not part of the state machine.

// -----------------------------------------------------------------------------

EXPORT_C void CSIPExSIPEngine::DisableProfileL()

	{

	if ( iProfile )

		{

		iProfileRegistry->Disable( *iProfile );

		delete iProfile;

		iProfile = NULL;		

		}

	}

// -----------------------------------------------------------------------------

// CSIPExSIPEngine::SendInviteL

// Send INVITE to the remote peer given as a parameter.

// -----------------------------------------------------------------------------

EXPORT_C void CSIPExSIPEngine::SendInviteL( const TDesC8& aSipUri )

	{

	iCurrentState->SendInviteL( *this, aSipUri );

	}

// -----------------------------------------------------------------------------

// CSIPExSIPEngine::CancelInvite

// CANCEL a previously sent INVITE.

// -----------------------------------------------------------------------------

EXPORT_C void CSIPExSIPEngine::CancelInviteL()

	{

	iCurrentState->CancelInviteL( *this );

	}

// -----------------------------------------------------------------------------

// CSIPExSIPEngine::AcceptInvite

// Accept a received INVITE with 200 (OK).

// -----------------------------------------------------------------------------

EXPORT_C void CSIPExSIPEngine::AcceptInviteL(const TInetAddr& aIPAddr )

	{

	iLocalAddr = aIPAddr;

	iCurrentState->AcceptInviteL( *this );

	}

// -----------------------------------------------------------------------------

// CSIPExSIPEngine::DeclineInvite

// Decline a received INVITE with 486 (Busy Here).

// -----------------------------------------------------------------------------

EXPORT_C void CSIPExSIPEngine::DeclineInviteL()

	{

	iCurrentState->DeclineInviteL( *this );

	}

// -----------------------------------------------------------------------------

// CSIPExSIPEngine::EndSession

// End the dialog with BYE.

// -----------------------------------------------------------------------------

EXPORT_C void CSIPExSIPEngine::EndSessionL()

	{

	iCurrentState->EndSessionL( *this );

	}

// -----------------------------------------------------------------------------

// CSIPExSIPEngine::CreateIML

// Create and send an Instant Message to recipient defined with parameter.

// This is implemented with the MESSAGE method and is sent outside of a

// dialog.

// -----------------------------------------------------------------------------

EXPORT_C void CSIPExSIPEngine::CreateIML( 

    const TDesC8& aMessage,

	const TDesC8& aSipUri )

	{

	_LIT8( KMediaType, "SIPEx" );	// Part of content type

	_LIT8( KMediaSubType, "InstantMessage" );	// Part of content type

	// Create the necessary elements of the IM

	CSIPRequestElements* reqElem = CreateReqElementsLC( aSipUri );

	CSIPToHeader* toHeader = CreateToHeaderLC( aSipUri );

	reqElem->SetToHeaderL( toHeader );

	CleanupStack::Pop( toHeader );

    // Create the From header value using info from the profile

    const TDesC8* aor = NULL;

    iProfile->GetParameter( KSIPUserAor, aor ); 

	__ASSERT_ALWAYS( aor && *aor != KNullDesC8, User::Leave( KErrNotFound ) );

    CSIPAddress* addr = CSIPAddress::DecodeL( *aor );

	CleanupStack::PushL( addr );

    CSIPFromHeader* fromHeader = CSIPFromHeader::NewL( addr );

	CleanupStack::Pop( addr );

	CleanupStack::PushL( fromHeader );

	reqElem->SetFromHeaderL( fromHeader );

	CleanupStack::Pop( fromHeader );

	reqElem->SetMethodL( SIPStrings::StringF( SipStrConsts::EMessage ) );

	// Get reference to the message elements from the request

	// elements, create and insert content type header (ownership

	// of the content type object is transferred)

	CSIPMessageElements& msgElem = reqElem->MessageElements();

	CSIPContentTypeHeader* ct =

   		CSIPContentTypeHeader::NewLC( KMediaType, KMediaSubType );

	msgElem.SetContentL( aMessage.AllocL(), ct );

	CleanupStack::Pop( ct );

	// Get the current connection

	CSIPConnection& conn = ConnectionL();

	// Send the request using the connection (ownership of the

	// request elements object is transferred)

	CSIPClientTransaction* ctx = conn.SendRequestL( reqElem );

	CleanupStack::Pop( reqElem );

	delete ctx;

	}

// -----------------------------------------------------------------------------

// CSIPExSIPEngine::IMReceivedL

// An Instant Message is received from the network. Respond with 200 (OK)

// and alert the Engine Observer.

// -----------------------------------------------------------------------------

void CSIPExSIPEngine::IMReceivedL( CSIPServerTransaction* aTransaction  )

	{

	const CSIPRequestElements* reqElem = aTransaction->RequestElements();

	const CSIPFromHeader* fromHeader = reqElem->FromHeader();

    CSIPResponseElements* respElem =

    	CSIPResponseElements::NewLC( 200, 

    	    SIPStrings::StringF( SipStrConsts::EPhraseOk ) );

	// Use the transaction to send 200 (OK)

	aTransaction->SendResponseL( respElem );

	CleanupStack::Pop( respElem );

	// Inform the observer of the Instant Message

	iObserver->IMReceived(

	    fromHeader->SIPAddress().Uri8().Uri().Extract( EUriUserinfo ),

		reqElem->MessageElements().Content());	

	// We no longer need aTransaction. Just delete it.

	delete aTransaction;

	aTransaction = NULL;

	}

// -----------------------------------------------------------------------------

// CSIPExSIPEngine::IMReceived

// Call the IMReceivedL method, trapping the possible errors.

// -----------------------------------------------------------------------------

void CSIPExSIPEngine::IMReceived( CSIPServerTransaction* aTransaction  )

	{

	TRAPD( err, IMReceivedL( aTransaction ));

	if ( err != KErrNone )

		{

		iObserver->EngineError( err );

		}

	}

// -----------------------------------------------------------------------------

// CSIPExSIPEngine::SetCurrentState

// Sets the new current state of the state machine.

// -----------------------------------------------------------------------------

void CSIPExSIPEngine::SetCurrentState( CSIPExSIPStateBase* aState )

	{

	iCurrentState = aState;

	}

// -----------------------------------------------------------------------------

// CSIPExSIPEngine::ConnectionL

// Returns the active connection.

// -----------------------------------------------------------------------------

CSIPConnection& CSIPExSIPEngine::ConnectionL()

	{

	CSIPConnection* conn = CurrentConnection();

	if ( !conn )

		{

		TUint32 iapId( 0 );

	    User::LeaveIfError( iProfile->GetParameter( KSIPAccessPointId, iapId ) );

		iConnection = CSIPConnection::NewL( *iSIP, iapId, *this );

		return *iConnection;

		}

	return *conn;

	}

// -----------------------------------------------------------------------------

// CSIPExSIPEngine::Profile

// Returns the enabled profile.

// -----------------------------------------------------------------------------

CSIPProfile& CSIPExSIPEngine::Profile()

	{

	return *iProfile;

	}

// -----------------------------------------------------------------------------

// CSIPExSIPEngine::SetServerTx

// Sets the current Server Transaction.

// -----------------------------------------------------------------------------

void CSIPExSIPEngine::SetServerTx( CSIPServerTransaction* aTx )

	{

	delete iServerTx;

	iServerTx = aTx;

	}

// -----------------------------------------------------------------------------

// CSIPExSIPEngine::ServerTx

// Returns the current Server Transaction.

// -----------------------------------------------------------------------------

CSIPServerTransaction& CSIPExSIPEngine::ServerTx()

	{

	return *iServerTx;

	}

// -----------------------------------------------------------------------------

// CSIPExSIPEngine::SetClientTx

// Sets the current Client Transaction.

// -----------------------------------------------------------------------------

void CSIPExSIPEngine::SetClientTx( CSIPClientTransaction* aTx )

	{

	delete iClientTx;

	iClientTx = aTx;

	}

// -----------------------------------------------------------------------------

// CSIPExSIPEngine::ClearClientTx

// Deletes the current Client Transaction.

// -----------------------------------------------------------------------------

void CSIPExSIPEngine::ClearClientTx()

	{

	delete iClientTx;

	iClientTx = NULL;

	}

// -----------------------------------------------------------------------------

// CSIPExSIPEngine::ClientTx

// Returns the current Client Transaction.

// -----------------------------------------------------------------------------

CSIPClientTransaction& CSIPExSIPEngine::ClientTx()

	{

	return *iClientTx;

	}

// -----------------------------------------------------------------------------

// CSIPExSIPEngine::SetDialogAssoc

// Sets the current Invite Dialog Association.

// -----------------------------------------------------------------------------

void CSIPExSIPEngine::SetDialogAssoc( CSIPInviteDialogAssoc& aAssoc )

	{

	delete iDialogAssoc;

	iDialogAssoc = &aAssoc;

	}

// -----------------------------------------------------------------------------

// CSIPExSIPEngine::DialogAssoc

// Returns the current Invite Dialog Association.

// -----------------------------------------------------------------------------

CSIPInviteDialogAssoc& CSIPExSIPEngine::DialogAssoc()

	{

	return *iDialogAssoc;

	}

// -----------------------------------------------------------------------------

// CSIPExSIPEngine::CreateToHeaderLC

// (other items were commented in a header).

// -----------------------------------------------------------------------------

CSIPToHeader* CSIPExSIPEngine::CreateToHeaderLC( const TDesC8& aSipUri )

	{

	CSIPAddress* addr = CSIPAddress::DecodeL( aSipUri );

	CleanupStack::PushL( addr );

	CSIPToHeader* to = CSIPToHeader::NewL( addr );

	CleanupStack::Pop( addr );

	CleanupStack::PushL( to );

	return to;

	}

// -----------------------------------------------------------------------------

// CSIPExSIPEngine::CreateReqElementsLC

// (other items were commented in a header).

// -----------------------------------------------------------------------------	

CSIPRequestElements* CSIPExSIPEngine::CreateReqElementsLC( const TDesC8& aSipUri )

    {

    CUri8* uri8 = ConvertToUri8LC( aSipUri );

    CSIPRequestElements* req = CSIPRequestElements::NewL( uri8 );

    CleanupStack::Pop( uri8 );

    CleanupStack::PushL( req );

    return req;

    }

// -----------------------------------------------------------------------------

// CSIPExSIPEngine::CreateMessageElementsLC

// Create a CSIPMEssageElements instance with the required information.

// -----------------------------------------------------------------------------

CSIPMessageElements* CSIPExSIPEngine::CreateMessageElementsLC()

	{

	_LIT8( KMediaType, "application" );

	_LIT8( KMediaSubType, "sdp" );

	CSIPMessageElements* msgElements = CSIPMessageElements::NewLC();

	CSdpDocument* sdpDocument = SdpDocumentLC();

	MediaFieldsL( sdpDocument );

    HBufC8* content = SdpBodyL( sdpDocument );

    CleanupStack::PushL( content );

   	CSIPContentTypeHeader* ct =

   		CSIPContentTypeHeader::NewLC( KMediaType, KMediaSubType );

	msgElements->SetContentL( content, ct );

	CleanupStack::Pop( ct );

	CleanupStack::Pop( content );

	CleanupStack::PopAndDestroy( sdpDocument );

	return msgElements;

	}

// -----------------------------------------------------------------------------

// CSIPExSIPEngine::ConvertToUri8LC

// (other items were commented in a header).

// -----------------------------------------------------------------------------