/*

* Copyright (c) 2005 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:  DM Utilities

*

*/

#include <s32mem.h>

#include <smldmadapter.h>

#include "nsmldmcmdarghandler.h"

// ===========================================================================

// NSmlDmCmdArgHandler

// ===========================================================================

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

// NSmlDmCmdArgHandler::PacketDataL()

// Packet elements to stream

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

EXPORT_C void NSmlDmCmdArgHandler::PacketDataL(RWriteStream& aWriteStream,

	const TDesC8& aLuid,

	const TDesC8& aData,

	const TDesC8& aURI,

	const TDesC8& aType)

	{

	aWriteStream.WriteUint16L(aLuid.Length());

	aWriteStream.WriteL(aLuid);

	aWriteStream.WriteUint16L(aData.Length());

	aWriteStream.WriteL(aData);

	aWriteStream.WriteUint16L(aURI.Length());

	aWriteStream.WriteL(aURI);

	aWriteStream.WriteUint16L(aType.Length());

	aWriteStream.WriteL(aType);

	}

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

// NSmlDmCmdArgHandler::ParseDataL()

// Parse data from stream

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

EXPORT_C void NSmlDmCmdArgHandler::ParseDataL(RReadStream& aReadStream,

	HBufC8*& aLuid,

	HBufC8*& aData,

	HBufC8*& aURI,

	HBufC8*& aType)

	{

	TUint16 length16;

	length16 = aReadStream.ReadUint16L();

	aLuid = HBufC8::NewLC(length16);

	TPtr8 luidPtr= aLuid->Des();

	aReadStream.ReadL(luidPtr,length16);

	length16 = aReadStream.ReadUint16L();

	aData = HBufC8::NewLC(length16);

	TPtr8 dataPtr= aData->Des();

	aReadStream.ReadL(dataPtr,length16);

	length16 = aReadStream.ReadUint16L();

	aURI = HBufC8::NewLC(length16);

	TPtr8 uriPtr= aURI->Des();

	aReadStream.ReadL(uriPtr,length16);

	length16 = aReadStream.ReadUint16L();

	aType = HBufC8::NewLC(length16);

	TPtr8 typePtr= aType->Des();

	aReadStream.ReadL(typePtr,length16);

	CleanupStack::Pop(4); //aLuid,aData,aURI,aType

	}

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

// NSmlDmCmdArgHandler::PacketFetchArgumentsL()

// Packet fetch arguments to stream

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

EXPORT_C void NSmlDmCmdArgHandler::PacketFetchArgumentsL(

	RWriteStream& aWriteStream,

	const TDesC8& aLuid,

	const TDesC8& aURI,

	const TDesC8& aType,

	const CArrayFixFlat<TSmlDmMappingInfo>& aPreviousURISegementList)

	{

	aWriteStream.WriteUint16L(aLuid.Length());

	aWriteStream.WriteL(aLuid);

	aWriteStream.WriteUint16L(aURI.Length());

	aWriteStream.WriteL(aURI);

	aWriteStream.WriteUint16L(aType.Length());

	aWriteStream.WriteL(aType);

	TUint8 count=aPreviousURISegementList.Count();

	aWriteStream.WriteUint8L(count);

	for(TUint8 i=0;i<count;i++)

		{

		aWriteStream.WriteUint8L(

			aPreviousURISegementList.At(i).iURISeg.Length());

		aWriteStream.WriteL(aPreviousURISegementList.At(i).iURISeg);

		aWriteStream.WriteUint8L(

			aPreviousURISegementList.At(i).iURISegLUID.Length());

		aWriteStream.WriteL(aPreviousURISegementList.At(i).iURISegLUID);

		}

	}

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

// NSmlDmCmdArgHandler::ParseFetchArgumentsL()

// Parse fetch arguments from stream

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

EXPORT_C void NSmlDmCmdArgHandler::ParseFetchArgumentsL(

	RReadStream& aReadStream,

	HBufC8*& aLuid,

	HBufC8*& aURI,

	HBufC8*& aType,

	CArrayFixFlat<TSmlDmMappingInfo>& aPreviousURISegementList,

	RPointerArray<HBufC8>& aLuids)

	{

	TUint16 length16;

	length16 = aReadStream.ReadUint16L();

	aLuid = HBufC8::NewLC(length16);

	TPtr8 luidPtr = aLuid->Des();

	aReadStream.ReadL(luidPtr,length16);

	length16 = aReadStream.ReadUint16L();

	aURI = HBufC8::NewLC(length16);

	TPtr8 uriPtr = aURI->Des();

	aReadStream.ReadL(uriPtr,length16);

	length16 = aReadStream.ReadUint16L();

	aType = HBufC8::NewLC(length16);

	TPtr8 typePtr = aType->Des();

	aReadStream.ReadL(typePtr,length16);

	TUint8 count = aReadStream.ReadUint8L();

	TUint8 length8;

	for(TInt i=0;i<count;i++)

		{

		length8 = aReadStream.ReadUint8L();

		HBufC8 *uriSeg =HBufC8::NewLC(length8);

		TPtr8 uriSegPtr = uriSeg->Des();

		aReadStream.ReadL(uriSegPtr,length8);

		length8 = aReadStream.ReadUint8L();

		HBufC8 *luid =HBufC8::NewLC(length8);

		TPtr8 luidPtr = luid->Des();

		aReadStream.ReadL(luidPtr,length8);

		aLuids.AppendL(luid);

		CleanupStack::Pop(); //luid

		TSmlDmMappingInfo mapInfo;

		mapInfo.iURISeg = TBufC8<KSmlMaxURISegLen>(uriSegPtr);

		mapInfo.iURISegLUID.Set(*luid);

		aPreviousURISegementList.AppendL(mapInfo);

		CleanupStack::PopAndDestroy(); //uriSeg

		}

	CleanupStack::Pop(3); //aLuid,aURI,aType

	}

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

// NSmlDmCmdArgHandler::PacketMappingsL()

// Packet mappings to stream

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

EXPORT_C void NSmlDmCmdArgHandler::PacketMappingsL(

	RWriteStream& aWriteStream,

	const CArrayPtrSeg<HBufC8>& aURIs,

	const CArrayPtrSeg<HBufC8>& aLuids )

	{

	if(aURIs.Count()!=aLuids.Count())

		{

		aWriteStream.WriteUint16L(0);

		return;

		}

	aWriteStream.WriteUint16L(aURIs.Count());

	for(TInt i=0;i<aURIs.Count();i++)

		{

		aWriteStream.WriteUint16L(aURIs.At(i)->Length());

		aWriteStream.WriteL(*aURIs.At(i));

		aWriteStream.WriteUint16L(aLuids.At(i)->Length());

		aWriteStream.WriteL(*aLuids.At(i));

		}

	}

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

// NSmlDmCmdArgHandler::ParseMappingsL()

// Parse mappings from stream

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

EXPORT_C void NSmlDmCmdArgHandler::ParseMappingsL(

	RReadStream& aReadStream,

	CArrayPtrSeg<HBufC8>& aURIs,

	CArrayPtrSeg<HBufC8>& aLuids )

	{

	TUint16 mapCount = aReadStream.ReadUint16L();

	for(TUint16 i=0;i<mapCount;i++)

		{

		TUint16 length;

		length = aReadStream.ReadUint16L();

		HBufC8* uri = HBufC8::NewLC(length);

		TPtr8 uriPtr = uri->Des();

		aReadStream.ReadL(uriPtr,length);

		CleanupStack::Pop(); //uri

		aURIs.AppendL(uri);

		length = aReadStream.ReadUint16L();

		HBufC8* luid = HBufC8::NewLC(length);

		TPtr8 luidPtr = luid->Des();

		aReadStream.ReadL(luidPtr,length);

		CleanupStack::Pop(); //luid

		aLuids.AppendL(luid);

		}

	}

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

// NSmlDmCmdArgHandler::PacketStatusesL()

// Packet statuses to stream

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

EXPORT_C void NSmlDmCmdArgHandler::PacketStatusesL(RWriteStream& aWriteStream,

	const RArray<TNSmlDmStatusElement>& aStatusArray)

	{

	TUint16 count = aStatusArray.Count();

	aWriteStream.WriteUint16L(count);

	for(TInt i=0;i<count;i++)

		{

		aWriteStream.WriteUint16L(aStatusArray[i].iStatusRef);

		aWriteStream.WriteUint8L(aStatusArray[i].iStatus);

		}

	}

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

// NSmlDmCmdArgHandler::ParseStatusesL()

// Parse statuses from stream

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

EXPORT_C void NSmlDmCmdArgHandler::ParseStatusesL(RReadStream& aReadStream,

	RArray<TNSmlDmStatusElement>& aStatusArray )

	{

	TUint16 count = aReadStream.ReadUint16L();

	for(TUint16 i=0;i<count;i++)

		{

		TNSmlDmStatusElement element;

		element.iStatusRef = aReadStream.ReadUint16L();

		element.iStatus = (MSmlDmAdapter::TError) aReadStream.ReadUint8L();

		aStatusArray.AppendL(element);

		}

	}

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

// NSmlDmCmdArgHandler::PacketResultsL()

// Packet results to stream

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

EXPORT_C void NSmlDmCmdArgHandler::PacketResultsL(RWriteStream& aWriteStream,

	const RPointerArray<CNSmlDmResultElement>& aResults)

	{

	TUint16 count = aResults.Count();

	aWriteStream.WriteUint16L(count);

	for(TInt i=0;i<count;i++)

		{

		aWriteStream.WriteUint16L(aResults[i]->iResultRef);

		aWriteStream.WriteUint32L(aResults[i]->iResult->Size());

		aWriteStream.WriteL(aResults[i]->iResult->Ptr(0),aResults[i]->iResult->Size());

		aWriteStream.WriteUint16L(aResults[i]->iMimeType->Length());

		aWriteStream.WriteL(*aResults[i]->iMimeType);

		}

	}

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

// NSmlDmCmdArgHandler::ParseResultsL()

// Parse results from stream

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

EXPORT_C void NSmlDmCmdArgHandler::ParseResultsL(RReadStream& aReadStream,

	RPointerArray<CNSmlDmResultElement>& aResults)

	{

	TUint16 count = aReadStream.ReadUint16L();

	for(TUint16 i=0;i<count;i++)

		{

		CNSmlDmResultElement* element = new (ELeave) CNSmlDmResultElement();

		CleanupStack::PushL(element);

		element->iResultRef = aReadStream.ReadUint16L();

		TUint32 len32 = aReadStream.ReadUint32L();

		if(len32)

			{

			element->iResult = CBufFlat::NewL(len32);

			}

		else

			{

			element->iResult = CBufFlat::NewL(8);

			}

		element->iResult->ResizeL(len32);

		TPtr8 resultPtr = element->iResult->Ptr(0);

		aReadStream.ReadL(resultPtr,len32);

		TUint16 len16 = aReadStream.ReadUint16L();

		element->iMimeType = HBufC8::NewL(len16);

		TPtr8 mimePtr = element->iMimeType->Des();

		aReadStream.ReadL(mimePtr,len16);

		aResults.AppendL(element);	

		CleanupStack::Pop();  //element

		}

	}

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

// NSmlDmCmdArgHandler::PacketCopyArgumentsL()

// Packet copy arguments to stream

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

EXPORT_C void NSmlDmCmdArgHandler::PacketCopyArgumentsL(

	RWriteStream& aWriteStream,

	const TDesC8& aTargetLuid,

	const TDesC8& aTargetURI,

	const TDesC8& aSourceLuid,

	const TDesC8& aSourceURI,

	const TDesC8& aType)

	{

	aWriteStream.WriteUint16L(aTargetLuid.Length());

	aWriteStream.WriteL(aTargetLuid);

	aWriteStream.WriteUint16L(aTargetURI.Length());

	aWriteStream.WriteL(aTargetURI);

	aWriteStream.WriteUint16L(aSourceLuid.Length());

	aWriteStream.WriteL(aSourceLuid);

	aWriteStream.WriteUint16L(aSourceURI.Length());

	aWriteStream.WriteL(aSourceURI);

	aWriteStream.WriteUint16L(aType.Length());

	aWriteStream.WriteL(aType);

	}

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

// NSmlDmCmdArgHandler::ParseCopyArgumentsL()

// Parse copy arguments from stream

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

EXPORT_C void NSmlDmCmdArgHandler::ParseCopyArgumentsL(

	RReadStream& aReadStream,

	HBufC8*& aTargetLuid,

	HBufC8*& aTargetURI,

	HBufC8*& aSourceLuid,

	HBufC8*& aSourceURI,

	HBufC8*& aType)

	{

	TUint16 length16;

	length16 = aReadStream.ReadUint16L();

	aTargetLuid = HBufC8::NewLC(length16);

	TPtr8 targetLuidPtr= aTargetLuid->Des();

	aReadStream.ReadL(targetLuidPtr,length16);

	length16 = aReadStream.ReadUint16L();

	aTargetURI = HBufC8::NewLC(length16);

	TPtr8 targetUriPtr= aTargetURI->Des();

	aReadStream.ReadL(targetUriPtr,length16);

	length16 = aReadStream.ReadUint16L();

	aSourceLuid = HBufC8::NewLC(length16);

	TPtr8 sourceLuidPtr= aSourceLuid->Des();

	aReadStream.ReadL(sourceLuidPtr,length16);

	length16 = aReadStream.ReadUint16L();

	aSourceURI = HBufC8::NewLC(length16);

	TPtr8 sourceUriPtr= aSourceURI->Des();

	aReadStream.ReadL(sourceUriPtr,length16);

	length16 = aReadStream.ReadUint16L();

	aType = HBufC8::NewLC(length16);

	TPtr8 typePtr= aType->Des();

	aReadStream.ReadL(typePtr,length16);

	//POP aTargetLuid,aTargetURI,aSourceLuid,aSourceURI,aType

	CleanupStack::Pop(5); 

	}

// ===========================================================================

// NSmlDmCmdArgHandler

// ===========================================================================

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

// CNSmlDmResultElement::~CNSmlDmResultElement()

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

EXPORT_C CNSmlDmResultElement::~CNSmlDmResultElement()

	{

	delete iResult;

	delete iMimeType;

	}