/*
* 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;
	}