/*

* Copyright (c) 2004 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:  DS server alert handler

*

*/

// INCLUDE FILES

//system includes

#include <s32mem.h>

#include <SyncMLDef.h>

#include <implementationproxy.h>	// TImplementationProxy definition

#include <nsmlconstants.h>

#include <nsmldebug.h>

#include <nsmlunicodeconverter.h>

#include <NSmlPrivateAPI.h>

#include "WBXMLSyncMLParser.h"

#include "WBXMLParser.h"

#include "WBXMLParserError.h"

#include "smlmetinfdtd.h"

#include "NSmlURI.h"

#include "nsmldsalert.h"

#include "nsmldssettings.h"

// ================= MEMBER FUNCTIONS =======================

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

// CNSmlDSAlert::CNSmlDSAlert()

// Constructor

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

//

CNSmlDSAlert::CNSmlDSAlert()

    {

	}

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

// CNSmlDSAlert::NewL()

// Creates new instance of CNSmlDSAlert. 

// Does not leave instance pointer to CleanupStack.

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

//

CNSmlDSAlert* CNSmlDSAlert::NewL()

    {

	CNSmlDSAlert* self = new (ELeave) CNSmlDSAlert();

	return self;

    }

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

// CNSmlDSAlert::~CNSmlDSAlert()

// Destructor

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

//

CNSmlDSAlert::~CNSmlDSAlert()

    {

	}

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

// CNSmlDSAlert::StartSync( const TDesC8& aSyncMLMessage, TInt aTransport, TBTDevAddr aBTAddress,

//    						const TDesC& aBTName, MNSmlAlertObexPluginContext* aPluginContext )

// Both standards supported (1.1 and 1.2)

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

//

	TNSmlAlertResult CNSmlDSAlert::StartSyncL(

    const TDesC8& aSyncMLMessage,

    TInt aTransport,

    TBTDevAddr /* aBTAddress */,

    const TDesC& /* aBTName */,

    MNSmlAlertObexPluginContext* /* aPluginContext */)

 	{

	DBG_FILE(_S8("CNSmlDSAlert::StartSync begins"));

	// Handling 1.2 Notification package

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

	TSmlProtocolVersion protocol(ESmlVersion1_2);

	if ( ! Is12Package( aSyncMLMessage ) )

		{

		// Handling 1.1 Package0

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

		TRAPD( parseErr, ParseMessageL( aSyncMLMessage ) );

		if ( ( parseErr != KErrNone ) || (iPacketShouldGoToMdo) )

			{

			// It may be MDO package

			return TNSmlAlertResult( ENSmlErrNotConsumed );

			}

		protocol = ESmlVersion1_1_2;

		}

	RNSmlPrivateAPI privateApi;

	TRAPD(openErr, privateApi.OpenL());

	if ( openErr != KErrNone )

		{

		return ENSmlErrUndefined;

		}

	const TUid transportId = { aTransport };

	TRAPD(connErr, privateApi.SendL(aSyncMLMessage, ESmlDataSync, 

	        protocol, transportId ));

	if ( connErr != KErrNone )

		{

		privateApi.Close();

		return ENSmlErrUndefined;

		}

	privateApi.Close();

	return ENSmlErrNone;

	}

//

//  Private member functions

//

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

// CNSmlDSAlert::Is12Package( const TDesC8& aTriggerMessage ) const

// 

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

TBool CNSmlDSAlert::Is12Package( const TDesC8& aTriggerMessage ) const

	{

	if ( aTriggerMessage.Length() > KNSmlDSAlertVersionPos )

		{

		TInt version;

		version = ((TUint8) aTriggerMessage[ KNSmlDSAlertVersionPos ]) << 8;

		version |= (TUint8) aTriggerMessage[ KNSmlDSAlertVersionPos + 1 ];

		version = version >> 6;

		if ( version == KNSmlDSAlertVersion )

			{

			return ETrue;

			}

		}

	return EFalse;

	}

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

// CNSmlDSAlert::ParseMessageL( const TDesC8& aSyncMLMessage )

// 

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

void CNSmlDSAlert::ParseMessageL( const TDesC8& aSyncMLMessage )

    {

	DBG_FILE(_S8("CNSmlDSAlert::ParseMessageL begins"));

    CWBXMLSyncMLDocHandler* docHandler = CWBXMLSyncMLDocHandler::NewL( this );

	CleanupStack::PushL( docHandler );

	CWBXMLParser* parser = CWBXMLParser::NewL();

	CleanupStack::PushL( parser );

	parser->SetDocumentHandler( docHandler );

	parser->SetExtensionHandler( docHandler );

	RDesReadStream readStream;

	readStream.Open( aSyncMLMessage );

	CleanupClosePushL ( readStream );

	parser->SetDocumentL( readStream );

	TWBXMLParserError ret = KWBXMLParserErrorOk;

	while ( ret == KWBXMLParserErrorOk )

		{

	    ret = parser->ParseL();

		}

	CleanupStack::PopAndDestroy( 3 ); //readStream, parser, docHandler

	DBG_FILE(_S8("CNSmlDSAlert::ParseMessageL ends"));

	}

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

// CNSmlDSAlert::PCDATAToUnicodeLC( const SmlPcdata_t& aPcdata, HBufC*& aUnicodeData ) const

// Converts data in Pcdata structure (used by xml parser)

// to Unicode 

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

void CNSmlDSAlert::PCDATAToUnicodeLC( const SmlPcdata_t& aPcdata, HBufC*& aUnicodeData ) const

	{

	if ( !aPcdata.content )

		{

		aUnicodeData = NULL;

		aUnicodeData = HBufC::NewLC( 0 );

		}

	TPtr8 pcdata( (TUint8*) aPcdata.content, aPcdata.length, aPcdata.length );

	TrimRightSpaceAndNull( pcdata );

	NSmlUnicodeConverter::HBufC16InUnicodeLC( pcdata, aUnicodeData );    

	}

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

// CNSmlDSAlert::TrimRightSpaceAndNull( TDes8& aDes ) const

// Trims right spaces and zero terminator (NULL) 

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

void CNSmlDSAlert::TrimRightSpaceAndNull( TDes8& aDes ) const

	{

	aDes.TrimRight();

	if ( aDes.Length() > 0 )

		{

		if ( aDes[aDes.Length() - 1] == NULL )

			{

			aDes.SetLength( aDes.Length() - 1 );

			}	

		}

	}

//

// Callback functions implementation

//

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

// CNSmlDSAlert::smlAlertCmdFuncL

// Alert command from server.  

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

Ret_t CNSmlDSAlert::smlAlertCmdFuncL( SmlAlertPtr_t /*aAlert*/ )

	{

	return 0;

	}

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

// CNSmlDSAlert::smlGetCmdFuncL

// Get command from server

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

Ret_t CNSmlDSAlert::smlGetCmdFuncL( SmlGetPtr_t /*aContent*/ )

	{

	return 0;

	}

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

// CNSmlDSAlert::smlPutCmdFuncL

// Put command from server

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

Ret_t CNSmlDSAlert::smlPutCmdFuncL( SmlPutPtr_t /*aContent*/ )

	{

	return 0;

	}

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

// CNSmlDSAlert::smlResultsCmdFuncL

// Results command from server

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

Ret_t CNSmlDSAlert::smlResultsCmdFuncL( SmlResultsPtr_t /*aContent*/ )

	{

	return 0;

	}

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

// CNSmlDSAlert::smlStatusCmdFuncL

// Status command from server

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

Ret_t CNSmlDSAlert::smlStatusCmdFuncL( SmlStatusPtr_t /*aContent*/ )

	{

	return 0;

	}

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

// CNSmlDSAlert::smlStartMessageFuncL

// SyncHdr from server

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

Ret_t CNSmlDSAlert::smlStartMessageFuncL( SmlSyncHdrPtr_t aSyncHdr )

	{

	if ( !aSyncHdr || !aSyncHdr->source || !aSyncHdr->source->locURI  ) 

		{

		User::Leave( KErrGeneral );

		}

    if ( ( aSyncHdr->meta ) &&

		 ( aSyncHdr->meta->content ) &&

         ( aSyncHdr->meta->contentType == SML_PCDATA_EXTENSION ) && 

         ( aSyncHdr->meta->extension == SML_EXT_METINF ) )

        {

        SmlMetInfMetInf_t* metInf;

        metInf = (SmlMetInfMetInf_t*) aSyncHdr->meta->content;

        if ( metInf->emi )

            {

            TPtr8 emi( ( TUint8* ) metInf->emi->data->content,

                       metInf->emi->data->length,

                       metInf->emi->data->length );

            TrimRightSpaceAndNull( emi );

            if ( emi.Match(KMdoAgentSupportedVersion) != KErrNotFound )

                {

                // the sync message should go to mdo, instead of ds

                iPacketShouldGoToMdo = ETrue;

                return 0;

                }

            }

        }

  	return 0;

	}

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

// CNSmlDSAlert::smlEndMessageFuncL

// End of SyncML message was reached

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

Ret_t CNSmlDSAlert::smlEndMessageFuncL( Boolean_t /*aFinal*/ )

	{

	return 0;

	}

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

// CNSmlDSAlert::smlStartSyncFuncL

// Sync command from server

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

Ret_t CNSmlDSAlert::smlStartSyncFuncL( SmlSyncPtr_t /*aContent*/ )

	{

	return 0;

	}

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

// CNSmlDSAlert::smlEndSyncFuncL

// End of Sync command was reached

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

Ret_t CNSmlDSAlert::smlEndSyncFuncL()

	{

	return 0;

	}

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

// CNSmlDSAlert::smlStartAtomicFuncL

// Atomic command from server, Atomic is not supported

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

Ret_t CNSmlDSAlert::smlStartAtomicFuncL( SmlAtomicPtr_t /*aContent*/ )

	{

	return 0;

	}

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

// CNSmlDSAlert::smlEndAtomicFuncL

// End of Atomic command was reached, Atomic is not supported

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

Ret_t CNSmlDSAlert::smlEndAtomicFuncL()

	{

	return 0;

	}

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

// CNSmlDSAlert::smlStartSequenceFuncL

// Sequence command from server, Sequence is not supported

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

Ret_t CNSmlDSAlert::smlStartSequenceFuncL( SmlSequencePtr_t /*aContent*/ )

	{

	return 0;

	}

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

// CNSmlDSAlert::smlEndSequenceFuncL

// 

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

Ret_t CNSmlDSAlert::smlEndSequenceFuncL()

	{

	return 0;

	}

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

// CNSmlDSAlert::smlAddCmdFuncL

// 

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

Ret_t CNSmlDSAlert::smlAddCmdFuncL( SmlAddPtr_t /*aContent*/ )

	{

	return 0;

	}

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

// CNSmlDSAlert::smlCopyCmdFuncL

// 

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

Ret_t CNSmlDSAlert::smlCopyCmdFuncL( SmlCopyPtr_t /*aContent*/)

	{

	return 0;

	}

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

// CNSmlDSAlert::smlDeleteCmdFuncL

// 

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

Ret_t CNSmlDSAlert::smlDeleteCmdFuncL( SmlDeletePtr_t /*aContent*/ )

	{

	return 0;

	}

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

// CNSmlDSAlert::smlExecCmdFuncL

// 

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

Ret_t CNSmlDSAlert::smlExecCmdFuncL( SmlExecPtr_t /*aContent*/ )

	{

	return 0;

	}

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

// CNSmlDSAlert::smlMapCmdFuncL

// 

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

Ret_t CNSmlDSAlert::smlMapCmdFuncL( SmlMapPtr_t /*aContent*/ )   

	{

	return 0;

	}

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

// CNSmlDSAlert::smlReplaceCmdFuncL

// 

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

Ret_t CNSmlDSAlert::smlReplaceCmdFuncL( SmlReplacePtr_t /*aContent*/ )

	{

	return 0;

	}

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

// CNSmlDSAlert::smlSearchCmdFuncL

// 

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

Ret_t CNSmlDSAlert::smlSearchCmdFuncL( SmlSearchPtr_t /*aContent*/ )

	{

	return 0;

	}

//1.2 CHANGES: Move command

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

// CNSmlDSAlert::smlMoveCmdFuncL

// 

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

Ret_t CNSmlDSAlert::smlMoveCmdFuncL( SmlMovePtr_t /*aContent*/ )

	{

	return 0;

	}

//Changes end

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

// Implementationproxy for ECOM

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

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

// Constants for implementation proxy

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

#ifndef IMPLEMENTATION_PROXY_ENTRY

#define IMPLEMENTATION_PROXY_ENTRY(aUid, aFuncPtr)	{{aUid},(aFuncPtr)}

#endif

const TImplementationProxy ImplementationTable[] = 

    {

		IMPLEMENTATION_PROXY_ENTRY(KNSmlDSAlertImplUid, CNSmlDSAlert::NewL)

    };

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

// TImplementationProxy* ImplementationGroupProxy

// Implementation proxy

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

EXPORT_C const TImplementationProxy* ImplementationGroupProxy( TInt& aTableCount )

    {

	_DBG_FILE("CNSmlDSAlert::ImplementationGroupProxy(): begin");

    aTableCount = sizeof( ImplementationTable ) / sizeof( TImplementationProxy );

	_DBG_FILE("CNSmlDSAlert::ImplementationGroupProxy(): end");

    return ImplementationTable;

	}

//  End of File