// 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          : CSipCRSessionReceiver.cpp
// Part of       : SIP Client Resolver
// Version       : 1.0
//



// INCLUDES
#include "CSIPCRSessionReceiver.h"
#include "CSIPCRResponseQueue.h"
#include "CSIPCRITCUtility.h"
#include "CSIPCRResponseItem.h"
#include "sipresponse.h"
#include "SIPCRSerializer.h"

// ----------------------------------------------------------------------------
// CSIPCRSessionReceiver::NewLC
// ----------------------------------------------------------------------------
//
CSIPCRSessionReceiver* CSIPCRSessionReceiver::NewL(CSIPCRITCUtility& aITC)
    {
    CSIPCRSessionReceiver* self = CSIPCRSessionReceiver::NewLC(aITC);
    CleanupStack::Pop (self);
    return self;
    }
    
// ----------------------------------------------------------------------------
// CSIPCRSessionReceiver::NewLC
// ----------------------------------------------------------------------------
//
CSIPCRSessionReceiver* CSIPCRSessionReceiver::NewLC(CSIPCRITCUtility& aITC)
    {
    CSIPCRSessionReceiver* self = new(ELeave)CSIPCRSessionReceiver (aITC);
    CleanupStack::PushL(self);
    self->ConstructL ();
    return self;
	}

// ----------------------------------------------------------------------------
// CSIPCRSessionReceiver::ConstructL
// ----------------------------------------------------------------------------
//
void CSIPCRSessionReceiver::ConstructL()
    {
    User::LeaveIfError(iReceiverMutex.CreateLocal());
    iResponseQueue = new(ELeave)CSIPCRResponseQueue;
    }

// ----------------------------------------------------------------------------
// CSIPCRSessionReceiver::~CSIPCRSessionReceiver
// ----------------------------------------------------------------------------
//
CSIPCRSessionReceiver::~CSIPCRSessionReceiver()
	{
	delete iResponseQueue;
	iReceiverMutex.Close();
	}

// ----------------------------------------------------------------------------
// CSIPCRSessionReceiver::ConstructL
// ----------------------------------------------------------------------------
//
CSIPCRSessionReceiver::CSIPCRSessionReceiver(CSIPCRITCUtility& aITC)
: iITC(aITC),
  iClientReadyToReceive(EFalse)
    {
    }
    
// ----------------------------------------------------------------------------
// CSIPCRSessionReceiver::ClientReadyToReceiveL
// ----------------------------------------------------------------------------
//
void CSIPCRSessionReceiver::ClientReadyToReceiveL(const RMessage2& aMessage)
    {
    CSIPCRITCUtility::WaitForMutexLC(iReceiverMutex);
    
    __ASSERT_ALWAYS (!iClientReadyToReceive, User::Leave (KErrAlreadyExists));

    if (iResponseQueue->IsEmpty())
		{
        iClientReadyToReceive = ETrue;
        iReceiveRMessage = aMessage;
		}
    else
        {
        CSIPCRResponseItem& item = iResponseQueue->First();
        TInt error = item.Error();
        iITC.WriteRequestIdL(aMessage, item.RequestId());
        if (error == KErrNone)
            {
            if (item.SIPResponse() == 0)
                {
                iITC.WriteClientResolvedL(aMessage, ESIPCRChannelComplete);
                iITC.WriteChannelUidL(aMessage,item.Channel());
                iResponseQueue->RemoveFirst();
                }
            else
                {
                iITC.WriteClientResolvedL(aMessage, ESIPCRClientNotFound);
                iITC.WriteResponseSizeL(aMessage, item.BufSizes());
                }
            }
        else
            {
            iResponseQueue->RemoveFirst();
            }
        iITC.Complete (aMessage,error);
        }
        
    CleanupStack::PopAndDestroy(); // signals iReceiverMutex     
    }

// ----------------------------------------------------------------------------
// CSIPCRSessionReceiver::CancelClientReceiveL
// ----------------------------------------------------------------------------
//
void CSIPCRSessionReceiver::CancelClientReceiveL()
    {
    CSIPCRITCUtility::WaitForMutexLC(iReceiverMutex);
    
    __ASSERT_ALWAYS (iClientReadyToReceive, User::Leave (KErrNotFound));
    iClientReadyToReceive = EFalse;
    iITC.Complete (iReceiveRMessage, KErrCancel);
    
    CleanupStack::PopAndDestroy(); // signals iReceiverMutex 
    }

// ----------------------------------------------------------------------------
// CSIPCRSessionReceiver::WriteSipResponseToClientL
// ----------------------------------------------------------------------------
//
void CSIPCRSessionReceiver::WriteSipResponseToClientL(
    const RMessage2& aMessage)
    {
    CSIPCRITCUtility::WaitForMutexLC(iReceiverMutex);
    
    __ASSERT_ALWAYS (!iResponseQueue->IsEmpty(), User::Leave (KErrNotFound));
    CSIPCRResponseItem& item = iResponseQueue->First();
    __ASSERT_ALWAYS (item.RequestId() != 0,User::Leave (KErrGeneral));
    __ASSERT_ALWAYS (item.SIPResponse() != 0,User::Leave (KErrGeneral));
    __ASSERT_ALWAYS (item.SIPResponseContent() != 0,User::Leave (KErrGeneral));   
    iITC.WriteSIPResponseL(aMessage, *item.SIPResponse());
    iITC.WriteSIPResponseContentL(aMessage, *item.SIPResponseContent());
    iResponseQueue->RemoveFirst();
    
    CleanupStack::PopAndDestroy(); // signals iReceiverMutex 
    }

// ----------------------------------------------------------------------------
// CSIPCRSessionReceiver::AddErrorResponseL
// ----------------------------------------------------------------------------
//
void CSIPCRSessionReceiver::AddErrorResponseL(
    TUint32 aRequestId, 
    CSIPResponse* aResponse)
    {
    CSIPCRITCUtility::WaitForMutexLC(iReceiverMutex);
    
    __ASSERT_ALWAYS (aResponse, User::Leave(KErrArgument));  
    CBufFlat* response = SIPCRSerializer::ExternalizeL(*aResponse);
    CleanupStack::PushL(response);
    HBufC8* content = aResponse->TakeContentOwnershipL();
    CleanupStack::PushL(content);
    CSIPCRResponseItem* item = 
        new(ELeave)CSIPCRResponseItem(aRequestId,response,content);
    CleanupStack::Pop(content);
    CleanupStack::Pop(response);
    CleanupStack::PushL(item);    
    if (iClientReadyToReceive)
        {
        iITC.WriteRequestIdL(iReceiveRMessage, aRequestId);
        iITC.WriteClientResolvedL(iReceiveRMessage, ESIPCRClientNotFound);
        iITC.WriteResponseSizeL(iReceiveRMessage, item->BufSizes());
        User::LeaveIfError(iResponseQueue->AddLast(item));
        iITC.Complete (iReceiveRMessage,KErrNone);
        iClientReadyToReceive = EFalse;
        }
    else
        {
        User::LeaveIfError(iResponseQueue->AddLast(item));
        }
    CleanupStack::Pop(item);
    CleanupStack::PopAndDestroy(); // signals iReceiverMutex 
    
    }

// ----------------------------------------------------------------------------
// CSIPCRSessionReceiver::RequestCompletedL
// ----------------------------------------------------------------------------
//
void CSIPCRSessionReceiver::RequestCompletedL(
    TUint32 aRequestId, 
    TUid aChannel)
    {
    CSIPCRITCUtility::WaitForMutexLC(iReceiverMutex);
    
    __ASSERT_ALWAYS (aChannel.iUid != 0, User::Leave(KErrArgument));
    __ASSERT_ALWAYS (aRequestId, User::Leave(KErrArgument));
    if (iClientReadyToReceive)
        {
        iITC.WriteRequestIdL(iReceiveRMessage, aRequestId);
        iITC.WriteClientResolvedL(iReceiveRMessage, ESIPCRChannelComplete);
        iITC.WriteChannelUidL(iReceiveRMessage, aChannel);
        iITC.Complete (iReceiveRMessage,KErrNone);
        iClientReadyToReceive = EFalse;
        }
    else
        {
        CSIPCRResponseItem* item = 
            new(ELeave)CSIPCRResponseItem(aRequestId,aChannel);
        CleanupStack::PushL(item);
        User::LeaveIfError(iResponseQueue->AddLast(item));
        CleanupStack::Pop(item);
        }
        
    CleanupStack::PopAndDestroy(); // signals iReceiverMutex     
    }
    
// ----------------------------------------------------------------------------
// CSIPCRSessionReceiver::ErrorReceivedL
// ----------------------------------------------------------------------------
//
void CSIPCRSessionReceiver::ErrorReceivedL(
    TUint32 aRequestId,
    TInt aError)   
    {
    CSIPCRITCUtility::WaitForMutexLC(iReceiverMutex);
    
    if (aError != KErrNone)
        {
        if (iClientReadyToReceive)
            {
            iITC.WriteRequestIdL (iReceiveRMessage, aRequestId);
            iITC.Complete(iReceiveRMessage,aError);
            iClientReadyToReceive = EFalse;
            }
        else
            {
            CSIPCRResponseItem* item = 
                new(ELeave)CSIPCRResponseItem(aRequestId,aError);
            CleanupStack::PushL(item);
            User::LeaveIfError(iResponseQueue->AddLast(item));
            CleanupStack::Pop(item);
            }
        }
        
    CleanupStack::PopAndDestroy(); // signals iReceiverMutex     
    }

// ----------------------------------------------------------------------------
// CSIPCRSessionReceiver::RemoveByRequestId
// ----------------------------------------------------------------------------
//
void CSIPCRSessionReceiver::RemoveByRequestId(TUint32 aRequestId)
    {
    iReceiverMutex.Wait();
    iResponseQueue->RemoveByRequestId(aRequestId);
    iReceiverMutex.Signal();
    }
    
// ----------------------------------------------------------------------------
// CSIPCRSessionReceiver::RemoveAll
// ----------------------------------------------------------------------------
//    
void CSIPCRSessionReceiver::RemoveAll()
    {
    iReceiverMutex.Wait();
    iResponseQueue->RemoveAll();
    iReceiverMutex.Signal();
    }

// End of File