/*

* Copyright (c) 2002-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:  SyncML Obex plugin for data syncronization

*

*/

// INCLUDE FILES

#include <nsmlsyncalerthandlerif.h>

#include <nsmlconstants.h> 

#include "NSmlObexDSplugin.h"

// CONSTANTS

const TUint KAlertEComInterface = 0x101F9A2C;

// ============================= LOCAL FUNCTIONS ===============================

namespace 

	{

	TInt CompareAlertsByPriorityL( const CImplementationInformation& aP1,

	                               const CImplementationInformation& aP2)

		{

		TInt ret( 0 );

		TInt comp = aP1.OpaqueData().Compare( aP2.OpaqueData() );

		if ( comp > 0 )

			{

			ret = 1;

			}

		else if ( comp < 0 )

			{

			ret = -1;

			}

		return ret;

		}

	}

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

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

// CNSmlObexDSplugin::NewL()

// Two-phased constructor.

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

//

EXPORT_C CNSmlObexDSplugin* CNSmlObexDSplugin::NewL()

    {

    //DBG_BEGIN();

    DBG_FILE( _S8("CNSmlObexDSplugin::NewL: begin") );

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

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

	DBG_FILE( _S8("CNSmlObexDSplugin::NewL: end") );    

    return self;

    }

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

// CNSmlObexDSplugin::CNSmlObexDSplugin()

// C++ default constructor.

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

//

CNSmlObexDSplugin::CNSmlObexDSplugin():

  iPtr( 0, 0),

  iSendPtr( 0, 0 ),

  iConnectionAlive( ETrue )

  	{

	}

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

// CNSmlObexDSplugin::ConstructL()

// Symbian 2nd phase constructor.

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

//

void CNSmlObexDSplugin::ConstructL()

    {

	iZeroPkg = ETrue;

	iObexContent = ENSmlDataSync;

	iState = EIdle;

	iResponseError = KErrNone ;

    // create OBEX object to receive obex transfer

    iObexBufData = CBufFlat::NewL( 10*KBufferSize );

    iObexBufObject = CObexBufObject::NewL( iObexBufData );

	iSessCancelled = ETrue;

	iSessionActive = EFalse;

	iThreadId = TThreadId( 0 );

	/* Needs a new SRCS interface **/

	iBtAddr = TBTDevAddr(0);

	iBtName = KNullDesC().AllocL();

	iServiceTimer = new (ELeave) CPluginServiceTimer( this, KPluginTimeOutValue );

	iServiceTimer->ConstructL();

	CActiveScheduler::Add( iServiceTimer );

	iGetPacketWaiterAo = CNSmlObexPacketWaiterAsync::NewL( iSs, iObexBufData, iObexBufObject ); 	

	CActiveScheduler::Add( iGetPacketWaiterAo );

    }

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

// CNSmlObexDSplugin::AlertLibrary()

// virtual from MNSmlAlertObexPluginContext

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

//

RLibrary& CNSmlObexDSplugin::AlertLibrary()

	{

	return iAlertLib;

	}

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

// CNSmlObexDSplugin::AlertThreadId()

// virtual from MNSmlAlertObexPluginContext

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

//

TThreadId* CNSmlObexDSplugin::AlertThreadId()

	{

	return &iThreadId;

	}

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

// CNSmlObexDSplugin::IsOBEXActive()

// 

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

//

TBool CNSmlObexDSplugin::IsOBEXActive()

    {

	return iSessionActive;

    }

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

// CNSmlObexDSplugin::~CNSmlObexDSplugin()

// Destructor.

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

//

CNSmlObexDSplugin::~CNSmlObexDSplugin()

    {

	DBG_FILE( _S8("CNSmlObexDSplugin::~CNSmlObexDSplugin(): begin") );

	Disconnect();

	if( iListener )

		{

		iListener->iSessCancelled = iSessCancelled;

		delete iListener;

		iListener = NULL;

		}

	if ( iServerThread )

		{

		//check, if server thread still running.

		if ( iServerThread->ExitType() == EExitPending ) 

			{

			//waiting for the server to finish.

			TRequestStatus serverLogon;

			iServerThread->Logon( serverLogon );

			User::WaitForRequest( serverLogon );

			}

		iServerThread->Close();

		delete iServerThread;

		iServerThread = NULL;

		}

    delete iObexBufData;

    iObexBufData = NULL;

    delete iObexBufObject;

    iObexBufObject = NULL;

	delete iData;

	iData = NULL;

	delete iBtName;

	if ( iAlertLib.Handle() )

		{

		iAlertLib.Close();

		}

	if( iServiceTimer )

		{

		iServiceTimer->Cancel();

		}

	delete iServiceTimer;

	iServiceTimer = NULL;

	if(iGetPacketWaiterAo)

		{

		delete iGetPacketWaiterAo;

		iGetPacketWaiterAo = NULL;

		}

	DBG_FILE( _S8("CNSmlObexDSplugin::~CNSmlObexDSplugin(): end") );

    }

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

// CNSmlObexDSplugin::ErrorIndication( TInt aError )

// 

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

//

#ifdef __NSML_DEBUG__

void CNSmlObexDSplugin::ErrorIndication( TInt aError )

    {

	iZeroPkg = ETrue;

	DBG_FILE_CODE( aError, _S8("CNSmlObexDSplugin::ErrorIndication...") );

	Disconnect();

    }

#else

void CNSmlObexDSplugin::ErrorIndication( TInt /*aError*/ )

    {

	iZeroPkg = ETrue;

	Disconnect();

    }

#endif

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

// CNSmlObexDSplugin::TransportUpIndication()

// 

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

//

void CNSmlObexDSplugin::TransportUpIndication()

    {

	DBG_FILE( _S8("CNSmlObexDSplugin::TransportUpIndication...") );

    }

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

// CNSmlObexDSplugin::TransportDownIndication()

// 

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

//

void CNSmlObexDSplugin::TransportDownIndication()

    {

	DBG_FILE( _S8("CNSmlObexDSplugin::TransportDownIndication...") );

	Disconnect();

    }

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

// CNSmlObexDSplugin::ObexConnectIndication( const TObexConnectInfo& /*aRemoteInfo*/, const TDesC8& /*aInfo*/ )

// 

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

//

void CNSmlObexDSplugin::ObexConnectIndication  (const TObexConnectInfo& /*aRemoteInfo*/, const TDesC8& /*aInfo*/)

    {

	_DBG_FILE("CNSmlObexDSplugin::ObexConnectIndication [w43 20.10.2003]");	

	TInt err( KErrNone );

	iStopped = EFalse;

	iStartTimer = ETrue;

    TSockAddr addr; 

    if ( iObexServer && iMediaType == ESrcsMediaBT )

        {

        iObexServer->RemoteAddr( addr );

        TRfcommSockAddr btAddr( addr ); 

        iBtAddr = btAddr.BTAddr();

        TInt nameError( KErrNone );

        TRAP( nameError, BluetoothNameByAddressL( addr ) );

        if ( nameError )

            {

            iResponseError = ConvertError( nameError ) ; 

			_DBG_FILE("CNSmlObexDSplugin::ObexConnectIndication [Error in getting Bluetooth Name]") ;

            }

        }

    if (iResponseError == KErrNone)

	    {

	      if(!iGetPacketWaiterAo)

	    	{

	    	TRAP_IGNORE (iGetPacketWaiterAo = CNSmlObexPacketWaiterAsync::NewL( iSs,

		   																		iObexBufData,

		   																		iObexBufObject ) ) ;

		   	CActiveScheduler::Add( iGetPacketWaiterAo );

			iGetPacketWaiterAo->SetObexServer(iObexServer) ; // Added for setting the server

	    	}

		if( iListener )

			{

			_DBG_FILE("delete iListener");	

			delete iListener;

			iListener = NULL;

			}

		err = iSs.Connect();

		if( err == KErrNotFound )

			{

			// obexcommserver was not running, creating one into a new thread

			if (iServerThread)

				{

				iServerThread->Close();

				delete iServerThread;

				iServerThread = NULL;

				}

			iServerThread = new RThread();

			if ( iServerThread )

				{

				RSemaphore signal;

				signal.CreateLocal(0);

				err = iServerThread->Create( _L("ObexCommServerThread"),

											 CreateServerL,

											 1024*6,

											 KMinHeapSize,

											 KMinHeapSize*320,

											 &signal );

				if ( err == KErrNone )

					{

					iServerThread->Resume();

					signal.Wait();

					err = iSs.Connect();

					}

				signal.Close();

				}

			else

				{

				err = KErrNoMemory;

				}

			}

		if( err == KErrNone )

			{

			iSessCancelled = EFalse;

			iListener = new CDisListener( iSs, this );

			if (!iListener)

				{

				err = KErrNoMemory;

				}

			if( err == KErrNone )

				{

				iListener->ListenDisconnect();

				DBG_FILE( _S8("CNSmlObexDSplugin iServiceTimer->StopTimer()") );

				iServiceTimer->Cancel();

				iServiceTimer->StopTimer();

				}

			}

			if ( err )

			  {

			  iConnectionAlive = EFalse;

			  }

			else

			  {

			  iConnectionAlive = ETrue;

			  }

	    iResponseError = ConvertError( err );

	    DBG_FILE_CODE( iResponseError, _S8("CNSmlObexDSplugin::ObexConnectIndication [Error]..") );	

		}

    }

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

// CNSmlObexDSplugin::ObexDisconnectIndication( const TDesC8& /*aInfo*/ )

// 

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

//

void CNSmlObexDSplugin::ObexDisconnectIndication( const TDesC8& /*aInfo*/ )

    {

	_DBG_FILE("CNSmlObexDSplugin::ObexDisconnectIndication");

	Disconnect();

	}

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

// CNSmlObexDSplugin::PutRequestIndication()

// 

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

//

void CNSmlObexDSplugin::PutRequestIndication ()

    {

	_DBG_FILE("CNSmlObexDSplugin::PutRequestIndication");

	iState = EIdle;

	if ( iObexBufObject )

		{

		iObexBufData->Reset();

		iObexBufObject->Reset();

		}

	if( iStopped )

		{

		_DBG_FILE("CNSmlObexDSplugin service unavailable");

		iObexServer->RequestIndicationCallback(NULL);

		}

	else 

		{

		_DBG_FILE("CNSmlObexDSplugin::PutRequestIndication - END [service available]");		

		iObexServer->RequestIndicationCallback(iObexBufObject);		

		}	

    }

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

// CNSmlObexDSplugin::PutPacketIndication()

// 

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

//

TInt CNSmlObexDSplugin::PutPacketIndication()

    {

	_DBG_FILE("CNSmlObexDSplugin::PutPacketIndication");

	TInt bytes( this->iObexBufObject->BytesReceived() );

	DBG_FILE_CODE( bytes, _S8("reveived bytes") );

	if( iStopped )

		{

		_DBG_FILE("CNSmlObexDSplugin service unavailable");

		return KErrIrObexRespServiceUnavail;

		}

	return KErrNone;

    }

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

// CNSmlObexDSplugin::PutCompleteIndication()

// 

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

//

void CNSmlObexDSplugin::PutCompleteIndication () 

    {

	_DBG_FILE("CNSmlObexDSplugin::PutCompleteIndication");

	DBG_FILE_CODE( iResponseError, _S8("CNSmlObexDSplugin::PutCompleteIndication...iResponseError...") );

	if (iResponseError == KErrNone) 

		{

		if ( !iConnectionAlive )

		  	{

			_DBG_FILE("CNSmlObexDSplugin::PutCompleteIndication - connection not alive!");

			iResponseError = KErrServerBusy ;  

		  	}

		if (iResponseError == KErrNone)  

			{

			TInt err( KErrNone );

			err = CheckMimeType();

			_DBG_FILE("CNSmlObexDSplugin After CheckMimeType");

			if( err == KErrNone )

				{

				if ( iObexBufData->Size() > KNSmlLocalSyncWorkspaceSize )

				    {

				    _DBG_FILE("CNSmlObexDSplugin: Received package too large!");

					iResponseError = KErrIrObexRespReqEntityTooLarge ;

					}

				if (iResponseError == KErrNone) 

					{

					if ( iZeroPkg )

						{

						_DBG_FILE("CNSmlObexDSplugin..Forwarding Zero Pkg");

						DBG_DUMP((void*)iObexBufData->Ptr(0).Ptr(), iObexBufData->Size(), _S8("Zero Pkg") );

						#ifdef __NSML_DEBUG__

						_DBG_FILE("CNSmlObexDSplugin..Zero Pkg: CWbxml2XmlConverter::ConvertL() begin");

						CWbxml2XmlConverter* c = NULL;

						TRAP( err, c = CWbxml2XmlConverter::NewL() );

						if (c)

							{

							TRAP( err, c->ConvertL(iObexBufData->Ptr(0).Ptr(), iObexBufData->Size()) );

							DBG_DUMP((void*)c->Document().Ptr(), c->Document().Length(), _S8("Zero Pkg (XML)") );

							delete c;

							}

						_DBG_FILE("CNSmlObexDSplugin..Zero Pkg: CWbxml2XmlConverter::ConvertL() end");

						#endif // __NSML_DEBUG__

						TRAP( err, err = ForwardZeroPkgL( iObexContent ) );

						iResponseError = err ;

						iZeroPkg = EFalse;

						}

					else

						{

						_DBG_FILE("CNSmlObexDSplugin..SetReceivedPacket");

						DBG_DUMP((void*)iObexBufData->Ptr(0).Ptr(), iObexBufData->Size(), _S8("CNSmlObexDSplugin SetReceivedPacket") );

						#ifdef __NSML_DEBUG__

						_DBG_FILE("CNSmlObexDSplugin..SetReceivedPacket: CWbxml2XmlConverter::ConvertL() begin");

						CWbxml2XmlConverter* c = NULL;

						TRAP( err, c = CWbxml2XmlConverter::NewL() );

						if (c)

							{

							TRAP( err, c->ConvertL(iObexBufData->Ptr(0).Ptr(), iObexBufData->Size()) );

							DBG_DUMP((void*)c->Document().Ptr(), c->Document().Length(), _S8("SetReceivedPacket (XML)") );

							delete c;

							}

						_DBG_FILE("CNSmlObexDSplugin..SetReceivedPacket: CWbxml2XmlConverter::ConvertL() end");

						#endif // __NSML_DEBUG__

						if( !iStopped )

							{

							this->iObexBufObject->BytesReceived();

							this->iSs.SetReceivedPacket( this->iObexBufData->Ptr( 0 ) );

							}

						else

							{

							err = KErrAccessDenied;

							iResponseError = err ; 

							}

						}

					}

				}

			else if ( err == KErrNotSupported )

			    {

		    	_DBG_FILE("CNSmlObexDSplugin: Mimetype not supported!");

			    iResponseError = KErrIrObexRespUnsupMediaType;

			    }

			else

				{

				iResponseError = ConvertError( err );

				}

			if (iResponseError != KErrNone) 

				{

				iObexServer->RequestCompleteIndicationCallback(ERespNotAcceptable);

				}

			else

				{

				iObexServer->RequestCompleteIndicationCallback(ERespSuccess);

				}

			}		

		}			

	}

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