/*

* 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:  Implementation for event/progress notifiers

*

*/

// This define should be moved somewhere else (symbian headers) !!

#ifndef SYNCML_V3

#define SYNCML_V3

#endif

#include <s32mem.h>

#include <SyncMLObservers.h>

#include "NSmlClientAPIDefs.h"

#include "NSmlClientAPIUtils.h"

#include "NSmlClientAPIActiveCallback.h"

#include "nsmlsosserverdefs.h"

#include "NSmlErrorCodeConversion.h"

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

//

// CSmlActiveCallback

//

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

// CSmlActiveCallback::CSmlActiveCallback()

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

//

CSmlActiveCallback::CSmlActiveCallback( RSyncMLSession& aSession )

	: iSession( aSession )

	{

	}

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

// CSmlActiveCallback::~CSmlActiveCallback()

// Destructor.

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

//

CSmlActiveCallback::~CSmlActiveCallback()

	{

	delete iEventCallback; iEventCallback = NULL;

	delete iProgressCallback; iProgressCallback = NULL;

	}

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

// CSmlActiveCallback::SetEventObserverL()

// Sets the event observer and starts event notification.

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

//

void CSmlActiveCallback::SetEventObserverL( MSyncMLEventObserver& aObserver )

	{

	if ( !iEventCallback )

		{

		iEventCallback = CSmlActiveEventCallback::NewL( this );

		}

	iEventCallback->SetObserver( aObserver );

	}

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

// CSmlActiveCallback::SetProgressObserverL()

// Sets the progress observer.

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

//

void CSmlActiveCallback::SetProgressObserverL( MSyncMLProgressObserver& aObserver )

	{

	if ( !iProgressCallback )

		{

		iProgressCallback = CSmlActiveProgressCallback::NewL( this );

		}

	iProgressCallback->SetObserver( aObserver );

	}

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

// CSmlActiveCallback::CancelEvent()

// Cancels event notification.

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

//

void CSmlActiveCallback::CancelEvent()

	{

	if ( iEventCallback )

		{

		iEventCallback->CancelEvent();

		delete iEventCallback; iEventCallback = NULL;

		}

	}

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

// CSmlActiveCallback::CancelProgress()

// Cancels progress notification.

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

//

void CSmlActiveCallback::CancelProgress()

	{

	if ( iProgressCallback )

		{

		iProgressCallback->CancelProgress();

		delete iProgressCallback; iProgressCallback = NULL;

		}

	}

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

// CSmlActiveCallback::SendReceive()

// Makes an asynchronous IPC call to server. Used by event and progress 

// notifier objects.

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

//

void CSmlActiveCallback::SendReceive( TInt aCmd, const TIpcArgs& aArgs, TRequestStatus& aStatus ) const

	{

	iSession.SendReceive( aCmd, aArgs, aStatus );

	}

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

// CSmlActiveCallback::SendReceive()

// Makes a synchronous IPC call to server. Used by event and progress 

// notifier objects.

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

//

void CSmlActiveCallback::SendReceive( TInt aCmd ) const

	{

	iSession.SendReceive( aCmd );

	}

//

// CSmlActiveEventCallback

//

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

// CSmlActiveEventCallback::NewL()

// Two-phase construction.

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

//

CSmlActiveEventCallback* CSmlActiveEventCallback::NewL( const CSmlActiveCallback* aCallback )

	{

	CSmlActiveEventCallback* self = new (ELeave) CSmlActiveEventCallback( aCallback );

	CleanupStack::PushL( self );

	self->ConstructL();

	CleanupStack::Pop(); // self

	return self;

	}

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

// CSmlActiveEventCallback::~CSmlActiveEventCallback()

// Destructor.

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

//

CSmlActiveEventCallback::~CSmlActiveEventCallback()

	{

	Cancel();

	if ( iRequesting )

		{

		CancelEvent();

		}

	delete iBuf;

	iBuf = NULL;

	}

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

// CSmlActiveEventCallback::SetObserver()

// Sets the observer to be notified. Starts requesting events 

// if it is not yet started.

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

//

void CSmlActiveEventCallback::SetObserver( MSyncMLEventObserver& aObserver )

	{

	iObserver = &aObserver;

	if ( !iRequesting )

		{

		iRequesting = ETrue;

		Request();

		}

	}

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

// CSmlActiveEventCallback::CancelEvent()

// Cancels event notification.

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

//

void CSmlActiveEventCallback::CancelEvent()

	{

	DoCancel();

	}

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

// CSmlActiveEventCallback::DoCancel()

// Cancels event notification.

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

//

void CSmlActiveEventCallback::DoCancel()

	{

	// cancel request to server

	iCallback->SendReceive( ECmdEventRequestCancel );

	iRequesting = EFalse;

	}

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

// CSmlActiveEventCallback::RunL()

// Processes the data received from server and informs 

// observer. In the end sends the request again so that the 

// observer will be informed as long as it is registered

// to this object.

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

//

void CSmlActiveEventCallback::RunL()

	{

	// check status

	if ( iStatus.Int() == KErrNone )

		{

		// open a readstream to iEventBuf's data

		RDesReadStream readStream( iBufPtr );

		CleanupClosePushL( readStream );

		// read the fist interger in databuffer -> the type of message

		TInt8 type = readStream.ReadInt8L();

		if ( type != ENSmlTypeEvent )

			{

			User::Panic( KNSmlClientAPIPanic, KErrArgument );

			}

		// read data and inform observer

		MSyncMLEventObserver::TEvent event = static_cast<MSyncMLEventObserver::TEvent>( readStream.ReadInt8L() );

		TInt32 id = readStream.ReadInt32L();

		TInt32 error = readStream.ReadInt32L();

		TInt32 additional = readStream.ReadInt32L();

		TNSmlErrorConversion errorconv( error );

		error = errorconv.Convert();		

		CleanupStack::PopAndDestroy(); // readStream

		iObserver->OnSyncMLSessionEvent( event, id, error, additional );

		if ( iRequesting )

			{

			Request();

			}

		}

	else if ( iStatus.Int() == KErrServerTerminated )

		{

		iObserver->OnSyncMLSessionEvent( MSyncMLEventObserver::EServerTerminated, 0, KErrServerTerminated, 0 );

		}

#ifdef __CLIENT_API_MT_

	else

		{

		CActiveScheduler::Stop();

		}

#endif

	}

TInt CSmlActiveEventCallback::RunError ( TInt /*aError*/ )

    {

    	return KErrNone;

    }	

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

// CSmlActiveEventCallback::Request()

// Makes an event request to server.

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

//

void CSmlActiveEventCallback::Request()

	{

	iBufPtr.Zero();

	if ( !IsActive() )

		{

		SetActive();

		}

	if ( iCallback )

		{

		iCallback->SendReceive( ECmdEventRequest, TIpcArgs( &iBufPtr ), iStatus );

		}

	}

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

// CSmlActiveEventCallback::ConstructL()

// Two-phase construction.

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

//

void CSmlActiveEventCallback::ConstructL()

	{

	iBuf = HBufC8::NewL( KNSmlMaxEventMessageLength );

	iBufPtr.Set( iBuf->Des() );

	}

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

// CSmlActiveEventCallback::CSmlActiveEventCallback(

// Contructor.

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

//

CSmlActiveEventCallback::CSmlActiveEventCallback( const CSmlActiveCallback* aCallback )

	: CActive( EPriorityStandard ), iRequesting( EFalse ), iBufPtr( 0, NULL, 0 ), iCallback( aCallback )

	{

	CActiveScheduler::Add( this );

	}

//

// CSmlActiveProgressCallback

//

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

// CSmlActiveProgressCallback::NewL(

// Two-phase construction.

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

//

CSmlActiveProgressCallback* CSmlActiveProgressCallback::NewL( const CSmlActiveCallback* aCallback )

	{

	CSmlActiveProgressCallback* self = new (ELeave) CSmlActiveProgressCallback( aCallback );

	CleanupStack::PushL( self );

	self->ConstructL();

	CleanupStack::Pop(); // self

	return self;

	}

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

// CSmlActiveProgressCallback::~CSmlActiveProgressCallback()

// Destructor.

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

//

CSmlActiveProgressCallback::~CSmlActiveProgressCallback()

	{

	Cancel();

	if ( iRequesting )

		{

		CancelProgress();

		}

	delete iBuf;

	iBuf = NULL;

	}

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

// CSmlActiveProgressCallback::SetObserver()

// Sets the observer to be notified. Starts requesting progress 

// events if it is not yet started.

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

//

void CSmlActiveProgressCallback::SetObserver( MSyncMLProgressObserver& aObserver )

	{

	iObserver = &aObserver;

	if ( !iRequesting )

		{

		iRequesting = ETrue;

		Request();

		}

	}

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

// CSmlActiveProgressCallback::CancelProgress()

// Cancels progress notification.

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

//

void CSmlActiveProgressCallback::CancelProgress()

	{

	DoCancel();

	}

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

// CSmlActiveProgressCallback::DoCancel()

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

//

void CSmlActiveProgressCallback::DoCancel()

	{

	// cancel request to server

	iCallback->SendReceive( ECmdProgressRequestCancel );

	iRequesting = EFalse;

	}

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

// CSmlActiveProgressCallback::RunL()

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

//

void CSmlActiveProgressCallback::RunL()

	{

	// check status

	if ( iStatus.Int() == KErrNone )

		{

		// open a readstream to iEventBuf's data

		RDesReadStream readStream( iBufPtr );

		CleanupClosePushL( readStream );

		// read the fist interger in databuffer -> the type of message

		TInt8 type = readStream.ReadInt8L();

		if ( type != ENSmlTypeProgressEvent )

			{

			User::Panic( KNSmlClientAPIPanic, KErrArgument );

			}

		// check which progress event was received, and notify observer

		TNSmlProgressEventType eventType = (TNSmlProgressEventType)readStream.ReadInt8L();

		switch( eventType )

			{

			case ENSmlSyncError:

				NotifyErrorL( readStream );

				break;

			case ENSmlSyncProgress:

				NotifyProgressL( readStream );

				break;

			case ENSmlModifications:

				NotifyModificationsL( readStream );

				break;

			default:

				User::Panic( KNSmlClientAPIPanic, KErrArgument );

				break;

			}

		CleanupStack::PopAndDestroy(); // readStream

		if ( iRequesting )

			{

			Request();

			}

		}

#ifdef __CLIENT_API_MT_

	else

		{

		CActiveScheduler::Stop();

		}

#endif

	}

TInt CSmlActiveProgressCallback::RunError ( TInt /*aError*/ )

    {

    	return KErrNone;

    }	

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

// CSmlActiveProgressCallback::Request()

// Sends asynchronous progress event request to server.

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

//

void CSmlActiveProgressCallback::Request()

	{

	iBufPtr.Zero();

	if ( !IsActive() )

		{

		SetActive();

		}

	if ( iCallback )

		{

		iCallback->SendReceive( ECmdProgressRequest, TIpcArgs( &iBufPtr ), iStatus );

		}

	}

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

// CSmlActiveProgressCallback::ConstructL()

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

//

void CSmlActiveProgressCallback::ConstructL()

	{

	iBuf = HBufC8::NewL( KNSmlMaxProgressMessageLength );

	iBufPtr.Set( iBuf->Des() );

	}

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

// CSmlActiveProgressCallback::CSmlActiveProgressCallback()

// Contructor.

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

//

CSmlActiveProgressCallback::CSmlActiveProgressCallback( const CSmlActiveCallback* aCallback )

	: CActive( EPriorityStandard ), iRequesting( EFalse ), iBufPtr( 0, NULL, 0 ), iCallback( aCallback )

	{

	CActiveScheduler::Add( this );

	}

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

// CSmlActiveProgressCallback::NotifyErrorL()

// Reads progress error related data and notifies observer.

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

//

void CSmlActiveProgressCallback::NotifyErrorL( RReadStream& aStream ) const

	{

	TInt8 errorLevel = aStream.ReadInt8L();

	TInt32 error = aStream.ReadInt32L();

	TInt32 taskId = aStream.ReadInt32L();

	TInt32 info1 = aStream.ReadInt32L();

	TInt32 info2 = aStream.ReadInt32L();

	TNSmlErrorConversion errorconv( error );

	error = errorconv.Convert();

	iObserver->OnSyncMLSyncError( (MSyncMLProgressObserver::TErrorLevel)errorLevel, error, taskId, info1, info2 );

	}

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

// CSmlActiveProgressCallback::NotifyProgressL()

// Reads progress event related data and notifies observer.

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

//

void CSmlActiveProgressCallback::NotifyProgressL( RReadStream& aStream ) const

	{

	TInt8 status = aStream.ReadInt8L();

	TInt32 info1 = aStream.ReadInt32L();

	TInt32 info2 = aStream.ReadInt32L();

	iObserver->OnSyncMLSyncProgress( (MSyncMLProgressObserver::TStatus)status, info1, info2 );

	}

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

// CSmlActiveProgressCallback::NotifyModificationsL()

// Reads progress information of modifications and notifies 

// observer.

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

//