/*

* Copyright (c) 2002 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:  XML syncml DTD generator

*

*/

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

// Include

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

#include "XMLSyncMLGenerator.h"

#include "WBXMLGeneratorError.h"

#include "XMLWorkspace.h"

#include "XMLDevInfGenerator.h"

#include "WBXMLDevInfParser.h"

#include "WBXMLParser.h"

#include "smlsyncmltags.h"

#include "smlmetinftags.h"

#include <s32mem.h>

// FOTA : Correlator added after 'Move'

_LIT8( KSyncMLElements, 

	   "<0>|<1>|<2>|<3>|<4>|Add|Alert|Archive|Atomic|Chal|Cmd|CmdID|CmdRef|Copy|Cred|Data|Delete|"

	   "Exec|Final|Get|Item|Lang|LocName|LocURI|Map|MapItem|Meta|MsgID|MsgRef|"

	   "NoResp|NoResults|Put|Replace|RespURI|Results|Search|Sequence|SessionID|"

	   "SftDel|Source|SourceRef|Status|Sync|SyncBody|SyncHdr|SyncML|Target|"

	   "TargetRef|<reserved>|VerDTD|VerProto|NumberOfChanges|MoreData|Field|Filter|Record|FilterType|"

	   "SourceParent|TargetParent|Move|Correlator|Data" );

_LIT8( KSyncMLNamespace, "SYNCML:SYNCML");

_LIT8( KMetInfElements, 

	   "<0>|<1>|<2>|<3>|<4>|Anchor|EMI|Format|FreeID|FreeMem|Last|Mark|MaxMsgSize|Mem|MetInf|Next|"

	   "NextNonce|SharedMem|Size|Type|Version|MaxObjSize|FieldLevel" );

_LIT8( KMetInfNamespace, "syncml:metinf");

// HYBRID 1.2 CHANGE

_LIT8( KDevInfGen, "./devinf" );

// Changes end

_LIT8( KDevInfElements, 

	   "<0>|<1>|<2>|<3>|<4>|CTCap|CTType|DataStore|DataType|DevID|DevInf|DevTyp|DisplayName|DSMem|Ext|"

	   "FwV|HwV|Man|MaxGUIDSize|MaxID|MaxMem|Mod|OEM|ParamName|PropName|Rx|Rx-Pref|"

	   "SharedMem|MaxSize|SourceRef|SwV|SyncCap|SyncType|Tx|Tx-Pref|ValEnum|VerCT|"

	   "VerDTD|Xnam|Xval|UTC|SupportNumberOfChanges|SupportLargeObjs|"

// 1.2 CHANGES: new elements

	   "Property|PropParam|MaxOccur|NoTruncate|Empty|Filter-Rx|FilterCap|FilterKeyword|FieldLevel|SupportHierarchicalSync" );

// changes end

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

// CXMLSyncMLGenerator

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

EXPORT_C void CXMLSyncMLGenerator::CreateWorkspaceL()

	{

	CXMLGenerator::CreateDynamicWorkspaceL();

	// HYBRID 1.2 CHANGE

	CXMLGenerator::SetTranslateTableL(KSyncMLElements());

	}

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

EXPORT_C void CXMLSyncMLGenerator::InitializeL()

	{

	// HYBRID 1.2 CHANGE

	CXMLGenerator::SetTranslateTableL(KSyncMLElements());

	}

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

EXPORT_C Ret_t CXMLSyncMLGenerator::smlStartMessage( SmlSyncHdrPtr_t aContent )

	{

	// HYBRID 1.2 CHANGE

	HBufC8* version=NULL;

	TRAPD(result, version = HBufC8::NewL( KSyncMLNamespace().Length() + aContent->version->Data().Length()));

	if(version)

	    {

    	TPtr8 versionPtr = version->Des();

    	versionPtr = KSyncMLNamespace();

    	versionPtr.Append ( aContent->version->Data() );

    	TRAP(result,CXMLGenerator::SetNamespaceNameL( versionPtr ));

    	delete version;

	    }

	Reset();

	Workspace()->BeginTransaction();

	TRAP(result, doSmlStartMessageL(aContent));

	return HandleResult(result, KNSmlXmlBufferSafeTreshold);

	}

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

EXPORT_C Ret_t CXMLSyncMLGenerator::smlEndMessage( Boolean_t aFinal )

	{

	Workspace()->BeginTransaction();

	TRAPD(result, doSmlEndMessageL(aFinal));

	return HandleResult(result); // No safe treshold as this is end of packet!

	}

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

EXPORT_C Ret_t CXMLSyncMLGenerator::smlStartSync( SmlSyncPtr_t aContent )

	{

	Workspace()->BeginTransaction();

	TRAPD(result, AppendSyncL(aContent));

	return HandleResult(result, KNSmlXmlBufferSafeTreshold);

	}

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

EXPORT_C Ret_t CXMLSyncMLGenerator::smlEndSync()

	{

	Workspace()->BeginTransaction();

	TRAPD(result, EndElementL());

	return HandleResult(result);

	}

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

EXPORT_C Ret_t CXMLSyncMLGenerator::smlAddCmd( SmlAddPtr_t aContent )

	{

	Workspace()->BeginTransaction();

	TRAPD(result, AppendAddCmdL(aContent));

	return HandleResult(result, KNSmlXmlBufferSafeTreshold);

	}

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

EXPORT_C Ret_t CXMLSyncMLGenerator::smlReplaceCmd( SmlReplacePtr_t aContent )

	{

	Workspace()->BeginTransaction();

	TRAPD(result, AppendReplaceCmdL(aContent));

	return HandleResult(result, KNSmlXmlBufferSafeTreshold);

	}

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

EXPORT_C Ret_t CXMLSyncMLGenerator::smlCopyCmd( SmlCopyPtr_t aContent )

	{

	Workspace()->BeginTransaction();

	TRAPD(result, AppendCopyCmdL(aContent));

	return HandleResult(result, KNSmlXmlBufferSafeTreshold);

	}

// FOTA

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

EXPORT_C Ret_t CXMLSyncMLGenerator::smlExecCmd( SmlExecPtr_t aContent )

	{

	Workspace()->BeginTransaction();

	TRAPD(result, AppendExecCmdL(aContent));

	return HandleResult(result, KNSmlXmlBufferSafeTreshold);

	}

// FOTA end

//1.2 CHANGES: Move command

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

EXPORT_C Ret_t CXMLSyncMLGenerator::smlMoveCmd( SmlMovePtr_t aContent )

	{

	Workspace()->BeginTransaction();

	TRAPD(result, AppendMoveCmdL(aContent));

	return HandleResult(result, KNSmlXmlBufferSafeTreshold);

	}

//Changes end

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

EXPORT_C Ret_t CXMLSyncMLGenerator::smlDeleteCmd( SmlDeletePtr_t aContent )

	{

	Workspace()->BeginTransaction();

	TRAPD(result, AppendDeleteCmdL(aContent));

	return HandleResult(result, KNSmlXmlBufferSafeTreshold);

	}

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

EXPORT_C Ret_t CXMLSyncMLGenerator::smlAlertCmd( SmlAlertPtr_t aContent )

	{

	Workspace()->BeginTransaction();

	TRAPD(result, AppendAlertCmdL(aContent));

	return HandleResult(result, KNSmlXmlBufferSafeTreshold);

	}

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

EXPORT_C Ret_t CXMLSyncMLGenerator::smlGetCmd( SmlPutPtr_t aContent )

	{

	Workspace()->BeginTransaction();

	TRAPD(result, AppendGetCmdL(aContent));

	return HandleResult(result, KNSmlXmlBufferSafeTreshold);

	}

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

EXPORT_C Ret_t CXMLSyncMLGenerator::smlPutCmd( SmlPutPtr_t aContent )

	{

	Workspace()->BeginTransaction();

	TRAPD(result, AppendPutCmdL(aContent));

	return HandleResult(result, KNSmlXmlBufferSafeTreshold);

	}

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

EXPORT_C Ret_t CXMLSyncMLGenerator::smlMapCmd( SmlMapPtr_t aContent )

	{

	Workspace()->BeginTransaction();

	TRAPD(result, AppendMapCmdL(aContent));

	return HandleResult(result, KNSmlXmlBufferSafeTreshold);

	}

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

EXPORT_C Ret_t CXMLSyncMLGenerator::smlResultsCmd( SmlResultsPtr_t aContent )

	{

	Workspace()->BeginTransaction();

	TRAPD(result, AppendResultsCmdL(aContent));

	return HandleResult(result, KNSmlXmlBufferSafeTreshold);

	}

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

EXPORT_C Ret_t CXMLSyncMLGenerator::smlStatusCmd( SmlStatusPtr_t aContent )

	{

	Workspace()->BeginTransaction();

	TRAPD(result, AppendStatusCmdL(aContent));

	return HandleResult(result, KNSmlXmlBufferSafeTreshold);

	}

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

EXPORT_C Ret_t CXMLSyncMLGenerator::smlStartAtomic( SmlAtomicPtr_t aContent )

	{

	Workspace()->BeginTransaction();

	TRAPD(result, AppendStartAtomicL(aContent));

	return HandleResult(result, KNSmlXmlBufferSafeTreshold);

	}

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

EXPORT_C Ret_t CXMLSyncMLGenerator::smlEndAtomic()

	{

	Workspace()->BeginTransaction();

	TRAPD(result, AppendEndAtomicL());

	return HandleResult(result, KNSmlXmlBufferSafeTreshold);

	}

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

EXPORT_C Ret_t CXMLSyncMLGenerator::smlStartSequence( SmlSequencePtr_t aContent )

	{

	Workspace()->BeginTransaction();

	TRAPD(result, AppendStartSequenceL(aContent));

	return HandleResult(result, KNSmlXmlBufferSafeTreshold);

	}

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

EXPORT_C Ret_t CXMLSyncMLGenerator::smlEndSequence()

	{

	Workspace()->BeginTransaction();

	TRAPD(result, AppendEndSequenceL());

	return HandleResult(result, KNSmlXmlBufferSafeTreshold);

	}

// Data chunk functionality

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

EXPORT_C void CXMLSyncMLGenerator::SetTruncate( TBool aEnabled )

	{

	iUseTruncation = aEnabled;

	}

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

EXPORT_C TInt CXMLSyncMLGenerator::ItemIndex() const

	{

	return iItemIndex;

	}

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

EXPORT_C TInt CXMLSyncMLGenerator::DataConsumed() const

	{

	return iDataConsumed;

	}

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

EXPORT_C TBool CXMLSyncMLGenerator::WasTruncated()

	{

	TBool was(iItemWasTruncated);

	iItemWasTruncated = EFalse;

	return was;

	}

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

void CXMLSyncMLGenerator::doSmlStartMessageL( SmlSyncHdrPtr_t aContent )

	{

	BeginDocumentL(KNSmlSyncMLVersion, KNSmlSyncMLPublicId, KNSmlSyncMLUTF8);

	BeginElementL(ESyncML, ETrue);

	AppendSyncHrdL(aContent);

	BeginElementL(ESyncBody, ETrue);

	}

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

void CXMLSyncMLGenerator::doSmlEndMessageL( Boolean_t aFinal )

	{

	if( aFinal )

		{

		BeginElementL(EFinal);

		}

	EndElementL(); // SyncBody

	EndElementL(); // SyncML

	}

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

void CXMLSyncMLGenerator::AppendSyncHrdL( SmlSyncHdrPtr_t aContent )

	{

	BeginElementL(ESyncHdr, ETrue);

	AppendPCDataL(EVerDTD, aContent->version);

	AppendPCDataL(EVerProto, aContent->proto);

	AppendPCDataL(ESessionID, aContent->sessionID);

	AppendPCDataL(EMsgID, aContent->msgID);

	AppendTargetL(aContent->target);

	AppendSourceL(aContent->source);

	AppendPCDataL(ERespURI, aContent->respURI);

	if( aContent->flags & SmlNoResp_f )

		{

		BeginElementL(ENoResp);

		}

	AppendCredL(aContent->cred);

	AppendMetaL(aContent->meta);

	EndElementL(); // ESyncHdr

	}

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

void CXMLSyncMLGenerator::DoAppendTargetL( SmlTargetPtr_t aContent )

	{

	AppendPCDataL(ELocURI, aContent->locURI);

	AppendPCDataL(ELocName, aContent->locName);

	AppendFilterL(aContent->filter); //1.2 CHANGES: Filter support

	}

//1.2 CHANGES: source & Target separated

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

void CXMLSyncMLGenerator::DoAppendSourceL( SmlSourcePtr_t aContent )

	{

	AppendPCDataL(ELocURI, aContent->locURI);

	AppendPCDataL(ELocName, aContent->locName);

	}

//Changes end

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

void CXMLSyncMLGenerator::AppendTargetL( SmlTargetPtr_t aContent )

	{

	if( !aContent )

		{

		return;

		}

	BeginElementL(ETarget, ETrue);

	DoAppendTargetL(aContent);

	EndElementL(); // ETarget

	}

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

void CXMLSyncMLGenerator::AppendSourceL( SmlSourcePtr_t aContent )

	{

	if( !aContent )

		{

		return;

		}

	BeginElementL(ESource, ETrue);

	DoAppendSourceL(aContent);	//1.2 CHANGES: Source & Target separated

	EndElementL(); // ETarget

	}

//1.2 CHANGES: Source & Target parent

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

void CXMLSyncMLGenerator::DoAppendSourceOrTargetParentL( SmlSourceOrTargetParentPtr_t aContent )

	{

	AppendPCDataL(ELocURI, aContent->locURI);

	}

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

void CXMLSyncMLGenerator::AppendSourceParentL( SmlSourceParentPtr_t aContent )

	{

	if( !aContent )

		{

		return;

		}

	BeginElementL(ESourceParent, ETrue);

	DoAppendSourceOrTargetParentL(aContent);

	EndElementL(); // ESourceParent

	}

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

void CXMLSyncMLGenerator::AppendTargetParentL( SmlTargetParentPtr_t aContent )

	{

	if( !aContent )

		{

		return;

		}

	BeginElementL(ETargetParent, ETrue);

	DoAppendSourceOrTargetParentL(aContent);

	EndElementL(); // ETargetParent

	}

//Changes end

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

void CXMLSyncMLGenerator::AppendCredL( SmlCredPtr_t aContent )

	{

	if( !aContent )

		{

		return;

		}

	BeginElementL(ECred, ETrue);

	AppendMetaL(aContent->meta);

	AppendPCDataL(EData, aContent->data);

	EndElementL(); // ECred

	}

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

void CXMLSyncMLGenerator::AppendSyncL( SmlSyncPtr_t aContent )

	{

	BeginElementL(ESync, ETrue);

	AppendPCDataL(ECmdID, aContent->cmdID);

	if( aContent->flags & SmlNoResp_f )

		{

		BeginElementL(ENoResp);

		}

	AppendCredL(aContent->cred);

	AppendTargetL(aContent->target);

	AppendSourceL(aContent->source);

	AppendMetaL(aContent->meta);

	AppendPCDataL(ENumberOfChanges, aContent->noc);

	}

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

void CXMLSyncMLGenerator::DoAppendGenericCmdL( SmlGenericCmdPtr_t aContent, Flag_t aMask )

	{

	AppendPCDataL(ECmdID, aContent->cmdID);

	if( (aContent->flags & SmlNoResp_f) & aMask )

		{

		BeginElementL(ENoResp);

		}

	if( (aContent->flags & SmlArchive_f) & aMask )

		{

		BeginElementL(EArchive);

		}

	if( (aContent->flags & SmlSftDel_f) & aMask )

		{

		BeginElementL(ESftDel);

		}

	AppendCredL(aContent->cred);

	AppendMetaL(aContent->meta);

	AppendItemListL(aContent->itemList);

	}

// FOTA

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

void CXMLSyncMLGenerator::DoAppendExecCmdL( SmlExecPtr_t aContent, Flag_t aMask )

	{

	AppendPCDataL(ECmdID, aContent->cmdID);

	if( (aContent->flags & SmlNoResp_f) & aMask )

		{

		BeginElementL(ENoResp);

		}

	if( (aContent->flags & SmlArchive_f) & aMask )

		{

		BeginElementL(EArchive);

		}

	if( (aContent->flags & SmlSftDel_f) & aMask )

		{

		BeginElementL(ESftDel);

		}

	AppendCredL(aContent->cred);

	AppendMetaL(aContent->meta);

	AppendPCDataL(ECorrelator, aContent->correlator);

	AppendItemL(aContent->item);

	}

// FOTA end

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

void CXMLSyncMLGenerator::AppendAddCmdL( SmlAddPtr_t aContent )

	{

	BeginElementL(EAdd, ETrue);

	DoAppendGenericCmdL(aContent, SmlNoResp_f);

	EndElementL(); // EAdd

	}

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

void CXMLSyncMLGenerator::AppendReplaceCmdL( SmlReplacePtr_t aContent )

	{

	BeginElementL(EReplace, ETrue);

	DoAppendGenericCmdL(aContent, SmlNoResp_f);

	EndElementL(); // EReplace

	}

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

void CXMLSyncMLGenerator::AppendCopyCmdL( SmlCopyPtr_t aContent )

	{

	BeginElementL(ECopy, ETrue);

	DoAppendGenericCmdL(aContent, SmlNoResp_f);

	EndElementL(); // ECopy

	}

// FOTA

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

void CXMLSyncMLGenerator::AppendExecCmdL( SmlExecPtr_t aContent )

	{

	BeginElementL(EExec, ETrue);

	DoAppendExecCmdL(aContent, SmlNoResp_f);

	EndElementL(); // EExec

	}

// FOTA end

//1.2 CHANGES: Move command

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

void CXMLSyncMLGenerator::AppendMoveCmdL( SmlMovePtr_t aContent )

	{

	BeginElementL(EMove, ETrue);

	DoAppendGenericCmdL(aContent, SmlNoResp_f);

	EndElementL(); // EMove

	}

//Changes end

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

void CXMLSyncMLGenerator::AppendDeleteCmdL( SmlDeletePtr_t aContent )

	{

	BeginElementL(EDelete, ETrue);

	DoAppendGenericCmdL(aContent, SmlNoResp_f|SmlArchive_f|SmlSftDel_f);

	EndElementL(); // EDelete

	}

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

void CXMLSyncMLGenerator::AppendAlertCmdL( SmlAlertPtr_t aContent )	

	{

	BeginElementL(EAlert, ETrue);

	AppendPCDataL(ECmdID, aContent->cmdID);

	if( aContent->flags & SmlNoResp_f )