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



// INCLUDES
#include "CSIPCRITCUtility.h"
#include "SIPCRSerializer.h"
#include "sipCRclientserver.h"
#include "siprequest.h"


// ----------------------------------------------------------------------------
// CSIPCRITCUtility::NewL
// ----------------------------------------------------------------------------
//
CSIPCRITCUtility* CSIPCRITCUtility::NewL()
    {
    CSIPCRITCUtility* self = CSIPCRITCUtility::NewLC();
    CleanupStack::Pop(self);
    return self;
    }

// ----------------------------------------------------------------------------
// CSIPCRITCUtility::NewLC
// ----------------------------------------------------------------------------
//
CSIPCRITCUtility* CSIPCRITCUtility::NewLC()
    {
    CSIPCRITCUtility* self = new(ELeave)CSIPCRITCUtility;
    CleanupStack::PushL(self);
    self->ConstructL();
    return self;
    }
    
// ----------------------------------------------------------------------------
// CSIPCRITCUtility::ConstructL
// ----------------------------------------------------------------------------
//
void CSIPCRITCUtility::ConstructL ()
    {
    iSerializer = new (ELeave) SIPCRSerializer;
    }

// ----------------------------------------------------------------------------
// CSIPCRITCUtility::~CSIPCRITCUtility
// ----------------------------------------------------------------------------
//
CSIPCRITCUtility::~CSIPCRITCUtility ()
    {
    delete iSerializer;
    }
    
// ----------------------------------------------------------------------------
// CSIPCRITCUtility::ReadSIPRequestL
// ----------------------------------------------------------------------------
//
void CSIPCRITCUtility::ReadSIPRequestL(const RMessage2& aMessage, 
                                       CSIPRequest& aRequest)
    {
    HBufC8* request = ReadLC(ESIPCRIpcArgSipRequest, aMessage);
	iSerializer->InternalizeL(*request,aRequest);
	CleanupStack::PopAndDestroy(request);
    HBufC8* content = ReadL(ESIPCRIpcArgSipMessageContent,aMessage);
    aRequest.SetContent(content);  
    }
    
// ----------------------------------------------------------------------------
// CSIPCRITCUtility::ReadResolverUidL
// ----------------------------------------------------------------------------
//
TUid CSIPCRITCUtility::ReadResolverUidL(const RMessage2& aMessage) const
    {
    TPckgBuf<TUid> resolverUidPckg;
    aMessage.ReadL(ESIPCRIpcArgResolverUid, resolverUidPckg);
    return resolverUidPckg();
    }
    
// ----------------------------------------------------------------------------
// CSIPCRITCUtility::WriteChannelUidL
// ----------------------------------------------------------------------------
//
void CSIPCRITCUtility::WriteChannelUidL(const RMessage2& aMessage,
                                        const TUid& aUID) const
    {
    TPckg<TUid> uidPckg(aUID);
    WriteL(ESIPCRIpcArgResolverUid, aMessage, uidPckg);
    }
  
// ----------------------------------------------------------------------------
// CSIPCRITCUtility::WriteSIPResponseL
// ----------------------------------------------------------------------------
//
void CSIPCRITCUtility::WriteSIPResponseL(const RMessage2& aMessage,
                                         CBufFlat& aResponse) const
    {
    TPtr8 responseBufPtr = aResponse.Ptr(0);
    WriteL(ESIPCRIpcArgSipResponse,aMessage,responseBufPtr);
    }
    
// ----------------------------------------------------------------------------
// CSIPCRITCUtility::WriteSIPResponseContentL
// ----------------------------------------------------------------------------
//    
void CSIPCRITCUtility::WriteSIPResponseContentL(const RMessage2& aMessage,
                                                const TDesC8& aContent) const
    {
    WriteL(ESIPCRIpcArgSipMessageContent,aMessage,aContent);
    }    
    

// ----------------------------------------------------------------------------
// CSIPCRITCUtility::ReadUIDL
// ----------------------------------------------------------------------------
//
TUid CSIPCRITCUtility::ReadUIDL(const RMessage2& aMessage) const
    {
    TPckgBuf<TUid> uidPckg;
    aMessage.ReadL(ESIPCRIpcArgClientUid, uidPckg);
    return uidPckg();
    }

// ----------------------------------------------------------------------------
// CSIPClientDiscovery::WriteUIDL
// ----------------------------------------------------------------------------
//
void CSIPCRITCUtility::WriteUIDL(const RMessage2& aMessage,
                                 TUid aUID) const
    {
    TPckg<TUid> uidPckg(aUID);
    WriteL(ESIPCRIpcArgResolverUid, aMessage, uidPckg);
    }

// ----------------------------------------------------------------------------
// CSIPCRITCUtility::WriteRequestIdL
// ----------------------------------------------------------------------------
//
void CSIPCRITCUtility::WriteRequestIdL(const RMessage2& aMessage, 
                                       TUint32 aId) const
    {
    TPckg<TUint32> idPckg(aId);
    WriteL(ESIPCRIpcArgReqId, aMessage, idPckg);
    }
    
// ----------------------------------------------------------------------------
// CSIPCRITCUtility::WriteClientResolvedL
// ----------------------------------------------------------------------------
//
void CSIPCRITCUtility::WriteClientResolvedL(const RMessage2& aMessage, 
                                            TSIPCRIpcResponses aResponse) const
    {
    TPckg<TInt> responsePckg(aResponse);
    WriteL(ESIPCRIpcArgClientResolved, aMessage, responsePckg);
    }
    
// ----------------------------------------------------------------------------
// CSIPCRITCUtility::WriteResponseSizeL
// ----------------------------------------------------------------------------
//
void CSIPCRITCUtility::WriteResponseSizeL(const RMessage2& aMessage, 
                                          TSIPCRMessageBufSizes aSizes) const
    {
    TPckgBuf<TSIPCRMessageBufSizes> sizesPckg(aSizes);
    WriteL(ESIPCRIpcArgBufSizes, aMessage, sizesPckg);
    }
    
// ----------------------------------------------------------------------------
// CSIPCRITCUtility::ReadRequestIdL
// ----------------------------------------------------------------------------
//
TUint32 CSIPCRITCUtility::ReadRequestIdL (const RMessage2& aMessage) const
    {
    TPckgBuf<TUint32> requestIdPckg;
    aMessage.ReadL(ESIPCRIpcArgReqId, requestIdPckg);
    return requestIdPckg();   
    }
    
// ----------------------------------------------------------------------------
// CSIPCRITCUtility::Complete
// ----------------------------------------------------------------------------
//
void CSIPCRITCUtility::Complete (const RMessage2& aMessage,
                                 TInt aCompletionCode) const
	{
    aMessage.Complete(aCompletionCode);
	}          	

// ----------------------------------------------------------------------------
// CSIPCRITCUtility::WaitForMutexLC
// ----------------------------------------------------------------------------
//
void CSIPCRITCUtility::WaitForMutexLC(RMutex& aMutex)
    {
    aMutex.Wait();
    TCleanupItem mutexCleanup(SignalMutex,&aMutex);
    CleanupStack::PushL(mutexCleanup);
    }

// -----------------------------------------------------------------------------
// CSIPCRITCUtility::SignalMutex
// -----------------------------------------------------------------------------
//
void CSIPCRITCUtility::SignalMutex(TAny* aMutex)
    {
    reinterpret_cast<RMutex*>(aMutex)->Signal();
    }
	
// ----------------------------------------------------------------------------
// CSIPCRITCUtility::WriteL
// ----------------------------------------------------------------------------
//
 void CSIPCRITCUtility::WriteL (TSIPCRIpcArguments aItcArgIndex,
                                const RMessage2& aMessage,
                                const TDesC8& aDes) const
    {
    TInt length = aMessage.GetDesMaxLength(aItcArgIndex);
    if (length < 0)
        {
        User::Leave (KErrArgument);
        }
    if (length < aDes.Length())
        {
        User::Leave (KErrOverflow);
        }

    aMessage.WriteL(aItcArgIndex, aDes);               
    }

// ----------------------------------------------------------------------------
// CSIPCRITCUtility::ReadL
// ----------------------------------------------------------------------------
//
HBufC8* CSIPCRITCUtility::ReadL (TSIPCRIpcArguments aItcArgIndex,
							     const RMessage2&  aMessage) const
	{	
	HBufC8* buf = ReadLC(aItcArgIndex,aMessage);
    CleanupStack::Pop(buf);
	return buf;
	}

// -----------------------------------------------------------------------------
// CSIPCRITCUtility::ReadLC
// -----------------------------------------------------------------------------
//
HBufC8* CSIPCRITCUtility::ReadLC (TSIPCRIpcArguments aItcArgIndex,
                                  const RMessage2& aMessage) const
	{
    TInt length = aMessage.GetDesLength(aItcArgIndex);
    if (length < 0)
        {
        User::Leave(KErrBadDescriptor);
        }
    HBufC8* buf = HBufC8::NewLC (length);
	if (length > 0)
		{
		TPtr8 bufPtr(buf->Des());
		aMessage.ReadL(aItcArgIndex, bufPtr);
		}
    return buf;
	}

//  End of File