// Copyright (c) 2005-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          : CSIPRequestHandler.cpp

// Part of       : SIP Request Handler

// Version       : SIP/4.0 

//

#include "CSIPRequestHandler.h"

#include "SipRequestHandlerInitParams.h"

#include "SipRequestHandlerObserver.h"

#include "sipclientdiscovery.h"

#include "siprequest.h"

#include "sipresponse.h"

#include "sipheaderbase.h"

#include "sipcontenttypeheader.h"

#include "uricontainer.h"

#include "sipstrings.h"

#include "sipstrconsts.h"

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

// CSIPRequestHandler::NewL

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

//

CSIPRequestHandler* CSIPRequestHandler::NewL (TAny* aInitParams)

	{

	__ASSERT_ALWAYS (aInitParams != NULL, User::Leave(KErrArgument));

	TSIPRequestHandlerInitParams* params =

		static_cast<TSIPRequestHandlerInitParams*>(aInitParams);

	MSIPRequestHandlerObserver* observer = params->iObserver;

	__ASSERT_ALWAYS (observer != NULL, User::Leave(KErrArgument));

    CSIPRequestHandler* self = new(ELeave)CSIPRequestHandler(*observer);

    CleanupStack::PushL(self);

    self->ConstructL(params->iUid);

    CleanupStack::Pop(self);

    return self;

	}

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

// CSIPRequestHandler::CSIPRequestHandler

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

//

CSIPRequestHandler::CSIPRequestHandler (MSIPRequestHandlerObserver& aObserver)

 : CSIPRequestHandlerBase(aObserver)

	{

	iContentTypeHeaderName = 

		SIPStrings::StringF(SipStrConsts::EContentTypeHeader);

	}

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

// CSIPRequestHandler::ConstructL

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

//

void CSIPRequestHandler::ConstructL (TUid aUid)

    {

	iSIPClientDiscovery = CSIPClientDiscovery::NewL(*this,aUid);

    }

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

// CSIPRequestHandler::~CSIPRequestHandler

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

//

CSIPRequestHandler::~CSIPRequestHandler()

	{

	delete iSIPClientDiscovery;

	}

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

// CSIPRequestHandler::RegisterL

// From CSIPRequestHandlerBase

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

//

void CSIPRequestHandler::RegisterL(TUid aChannel)

	{

	iSIPClientDiscovery->RegisterL(aChannel);

	}

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

// CSIPRequestHandler::Deregister

// From CSIPRequestHandlerBase

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

//

TInt CSIPRequestHandler::Deregister(TUid aChannel)

	{

	return iSIPClientDiscovery->Deregister(aChannel);

	}

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

// CSIPRequestHandler::ChannelL

// From CSIPRequestHandlerBase

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

//

TUint32 CSIPRequestHandler::ChannelL(CSIPRequest& aSIPRequest)

	{

	CURIContainer* requestURI = aSIPRequest.RequestURI();

	__ASSERT_ALWAYS(requestURI != NULL, User::Leave(KErrArgument));

	HBufC8* requestURIText = requestURI->ToTextL();

	CleanupStack::PushL(requestURIText);

	RPointerArray<CSIPHeaderBase> headers = aSIPRequest.AllHeadersL();

	const CSIPContentTypeHeader* contentTypeHeader = NULL;

	for (TInt i=headers.Count()-1; i >= 0; i--)

		{

		CSIPHeaderBase* header = headers[i];

		if (header->Name() == iContentTypeHeaderName)

			{

			contentTypeHeader = static_cast<CSIPContentTypeHeader*>(header);

			headers.Remove(i);

			}

		}

	TUint32 requestId = iSIPClientDiscovery->ChannelL(aSIPRequest.Method(),

	                                                  *requestURIText,

	                                                  headers,

	                                                  aSIPRequest.Content(),

	                                                  contentTypeHeader);

	CleanupStack::PopAndDestroy(requestURIText);

	return requestId;

	}

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

// CSIPRequestHandler::Cancel

// From CSIPRequestHandlerBase

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

//		

void CSIPRequestHandler::Cancel(TUint32 aRequestId)

	{

	iSIPClientDiscovery->Cancel(aRequestId);

	}

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

// CSIPRequestHandler::ChannelResolvedL

// From MSIPClientDiscoveryObserver

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

//

void CSIPRequestHandler::ChannelResolvedL(TUid aChannel, TUint32 aRequestId)

	{

	iObserver.ClientFoundL(aRequestId,aChannel);

	}

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

// CSIPRequestHandler::ClientNotFoundL

// From MSIPClientDiscoveryObserver

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

//

void CSIPRequestHandler::ClientNotFoundL(TUint32 aRequestId,

                                         TUint aStatusCode, 

                                         RStringF aReasonPhrase, 

                                         RPointerArray<CSIPHeaderBase> aHeaders,

                                         HBufC8* aContent)

	{

	CSIPResponse* response = CSIPResponse::NewLC(aStatusCode,aReasonPhrase);

    if (aContent)

        {

        response->SetContent(aContent->AllocL()); 

        }

	for (TInt i=aHeaders.Count()-1; i >= 0; i--)

		{

		CSIPHeaderBase* header = aHeaders[i];

		response->AddHeaderL(header);

		aHeaders.Remove(i);

		}

	iObserver.ClientNotFoundL(aRequestId,response);

	delete aContent;

	aHeaders.ResetAndDestroy();

	CleanupStack::Pop(response);

	}

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

// CSIPRequestHandler::ErrorOccurred

// From MSIPClientDiscoveryObserver

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

//

void CSIPRequestHandler::ErrorOccurred(TInt aError, TUint32 aRequestId)

	{

	iObserver.ErrorOccurred(aRequestId,aError);

	}