/*

* 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 of common client api.

*

*/

// INCLUDE FILES

#include <e32base.h>

#include <s32mem.h>

#include <eikdll.h>

#include <f32file.h>

#include <ecom.h>

#include <implementationinformation.h>

#include <featmgr.h>

#include <SyncMLClient.h>

#include <nsmlconstants.h>

#include <nsmldebug.h>

#include <nsmldsconstants.h>

#include "NSmlClientAPIDefs.h"

#include "NSmlClientAPIUtils.h"

#include "NSmlClientAPIActiveCallback.h"

#include "nsmlsosserverdefs.h"

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

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

// LaunchServerL()

// Launches the server.

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

//

TInt LaunchServerL()

	{	

	_DBG_FILE("SyncML Client API LaunchServerL(): begin");

	TInt res = KErrNone;

	// DLL launch

	RProcess server;

	res = server.Create(KServerExeName, KNullDesC);

	// Loading failed.

	User::LeaveIfError( res );

	TRequestStatus status;

	server.Rendezvous(status);

	if (status != KRequestPending)

		{

		server.Kill(0);		// abort startup

		server.Close();

		return KErrGeneral;   // status can be KErrNone: don't return status.Int()

		}

	else

		{

		server.Resume();	// logon OK - start the server

		}

	User::WaitForRequest(status);

	server.Close();

	_DBG_FILE("SyncML Client API LaunchServerL(): end");

	return status.Int();

	}

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

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

// RSyncMLSession::RSyncMLSession()

// Constructor.

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

//

EXPORT_C RSyncMLSession::RSyncMLSession()

	: RSessionBase(), iData( NULL ), iEventCallback( NULL )

	{

	}

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

// RSyncMLSession::OpenL()

// Opens sync session.

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

//

EXPORT_C void RSyncMLSession::OpenL()

	{

	_DBG_FILE("RSyncMLSession::OpenL(): begin");

	CClientSessionData::PanicIfAlreadyCreated( iData );

	const TVersion KServerVersion( KNSmlSOSServerVersionMajor, KNSmlSOSServerVersionMinor, 0 );

	TInt res = KErrNone;

	res = CreateSession( KSOSServerName, KServerVersion, KDefaultMessageSlots );

	if ( res != KErrNone )

		{

		res = LaunchServerL();

		User::LeaveIfError( res );

		res = CreateSession( KSOSServerName, KServerVersion, KDefaultMessageSlots );

		}

	User::LeaveIfError( res );

	CleanupClosePushL( *this ); // if leave occures, Close is called by cleanup

	// init feature manager and data

	FeatureManager::InitializeLibL();

	iData = new (ELeave) CClientSessionData;

	CleanupStack::Pop(); // this

	_DBG_FILE("RSyncMLSession::OpenL(): end");

	}

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

// RSyncMLSession::RequestEventL()

// Begins notifing the given observer of sync events.

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

//

EXPORT_C void RSyncMLSession::RequestEventL( MSyncMLEventObserver& aEventObserver )

	{

	_DBG_FILE("RSyncMLSession::RequestEventL(): begin");

	if ( !iEventCallback )

		{

		// callback not yet created, create

		iEventCallback = new (ELeave) CSmlActiveCallback( *this );

		}

	iEventCallback->SetEventObserverL( aEventObserver );

	_DBG_FILE("RSyncMLSession::RequestEventL(): end");

	}

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

// RSyncMLSession::CancelEvent()

// Cancels event notification.

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

//

EXPORT_C void RSyncMLSession::CancelEvent()

	{

	_DBG_FILE("RSyncMLSession::CancelEvent(): begin");

	if ( iEventCallback )

		{

		iEventCallback->CancelEvent();

		}

	_DBG_FILE("RSyncMLSession::CancelEvent(): end");

	}

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

// RSyncMLSession::RequestProgressL()

// Begins notifing the given observer of sync progress.

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

//

EXPORT_C void RSyncMLSession::RequestProgressL( MSyncMLProgressObserver& aProgressObserver )

	{

	_DBG_FILE("RSyncMLSession::RequestProgressL(): begin");

	if ( !iEventCallback )

		{

		// callback not yet created, create

		iEventCallback = new (ELeave) CSmlActiveCallback( *this );

		}

	iEventCallback->SetProgressObserverL( aProgressObserver );

	_DBG_FILE("RSyncMLSession::RequestProgressL(): end");

	}

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

// RSyncMLSession::CancelProgress()

// Cancels progress notification.

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

//

EXPORT_C void RSyncMLSession::CancelProgress()

	{

	_DBG_FILE("RSyncMLSession::CancelProgress(): begin");

	if ( iEventCallback )

		{

		iEventCallback->CancelProgress();

		}

	_DBG_FILE("RSyncMLSession::CancelProgress(): end");

	}

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

// RSyncMLSession::CurrentJobL()

// Fetches the id and usage type of currently running job.

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

//

EXPORT_C void RSyncMLSession::CurrentJobL( TSmlJobId& aJobId, TSmlUsageType& aUsageType ) const

	{

	_DBG_FILE("RSyncMLSession::CurrentJobL(): begin");

	TPckgBuf<TInt> jobId( aJobId );

	TPckgBuf<TInt> usageType( (TInt)aUsageType );

	User::LeaveIfError( SendReceive( ECmdJobListCurrent, TIpcArgs( &jobId, &usageType ) ) );

	aJobId = jobId();

	aUsageType = (TSmlUsageType) usageType();

	_DBG_FILE("RSyncMLSession::CurrentJobL(): end");

	}

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

// RSyncMLSession::ListQueuedJobsL()

// List the jobs that are currently in server's job queue.

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

//

EXPORT_C void RSyncMLSession::ListQueuedJobsL( RArray<TSmlJobId>& aArray, TSmlUsageType aType ) const

	{

	_DBG_FILE("RSyncMLSession::ListQueuedJobsL(): begin");

	// check that usage type is supported

	NSmlClientAPIFeatureHandler::LeaveIfUsageTypeNotSupportedL( aType );

	ReceiveArrayL( aArray, ECmdJobListStart, ECmdJobListNext, aType );

	_DBG_FILE("RSyncMLSession::ListQueuedJobsL(): end");

	}

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

// RSyncMLSession::ListProfilesL()

// List the profiles of given usage type.

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

//

EXPORT_C void RSyncMLSession::ListProfilesL( RArray<TSmlProfileId>& aArray, TSmlUsageType aType ) const

	{

	_DBG_FILE("RSyncMLSession::ListProfilesL(): begin");

	// check that usage type is supported

	NSmlClientAPIFeatureHandler::LeaveIfUsageTypeNotSupportedL( aType );

	ReceiveArrayL( aArray, ECmdProfileListStart, ECmdProfileListNext, aType );

	_DBG_FILE("RSyncMLSession::ListProfilesL(): end");

	}

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

// RSyncMLSession::ListTransportsL()

// Lists the transports available. Uses FeatureManager to find out

// which transports are at use.

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

//

EXPORT_C void RSyncMLSession::ListTransportsL( RArray<TSmlTransportId>& aTransportIds ) const

	{

	_DBG_FILE("RSyncMLSession::ListTransportsL(): begin");

	aTransportIds.Reset();

	//Checking if internet transport type is supported

	if ( FeatureManager::FeatureSupported( KFeatureIdSyncMlDsOverHttp  ) )

		{

	    aTransportIds.AppendL( KUidNSmlMediumTypeInternet.iUid );

		}

	// if obex is supported, see which obex transports are supported

	if ( FeatureManager::FeatureSupported( KFeatureIdSyncMlObex ) )

		{

		// bluetooth

		if ( FeatureManager::FeatureSupported( KFeatureIdBt ) )

			{

			aTransportIds.AppendL( KUidNSmlMediumTypeBluetooth.iUid );

			}

		}

	_DBG_FILE("RSyncMLSession::ListTransportsL(): end");

	}

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

// RSyncMLSession::ListDataProvidersL()

// Lists the DS adapters available. Uses ECom services 

// for the task.

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

//

EXPORT_C void RSyncMLSession::ListDataProvidersL( RArray<TSmlDataProviderId>& aDataProviderIds ) const

	{

	_DBG_FILE("RSyncMLSession::ListDataProvidersL(): begin");

	// check that ds sync is supported

	NSmlClientAPIFeatureHandler::LeaveIfDataSyncNotSupportedL();

	aDataProviderIds.Reset();

	RImplInfoPtrArray implArray;

	CleanupStack::PushL( PtrArrCleanupItemRArr( CImplementationInformation, &implArray ) );

	TUid ifUid = { KNSmlDSInterfaceUid };

	REComSession::ListImplementationsL( ifUid, implArray );

	// append adapter id's to the given array

	for ( TInt i = 0; i < implArray.Count(); i++ )

		{

		CImplementationInformation* implInfo = implArray[i];

		aDataProviderIds.AppendL( implInfo->ImplementationUid().iUid );

		}

	REComSession::FinalClose();

	CleanupStack::PopAndDestroy(); // implArray

	_DBG_FILE("RSyncMLSession::ListDataProvidersL(): end");

	}

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

// RSyncMLSession::DeleteProfileL()

// Deletes the given profile.

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

//

EXPORT_C void RSyncMLSession::DeleteProfileL( TSmlProfileId aId )

	{

	_DBG_FILE("RSyncMLSession::DeleteProfileL(): begin");

    TIpcArgs args( aId );

    User::LeaveIfError( SendReceive( ECmdProfileDelete, args ) );

	_DBG_FILE("RSyncMLSession::DeleteProfileL(): end");

	}

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

// RSyncMLSession::ListProtocolVersionsL()

// Returns the default supported protocol for given usage type. 

// On return, aVersions array includes all the protocol 

// versions supported.

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

//

EXPORT_C TSmlProtocolVersion RSyncMLSession::ListProtocolVersionsL( TSmlUsageType aUsageType, RArray<TSmlProtocolVersion>& aVersions ) const

	{

	_DBG_FILE("RSyncMLSession::ListProtocolVersionsL(): begin");

	// check that given usage type is supported

	NSmlClientAPIFeatureHandler::LeaveIfUsageTypeNotSupportedL( aUsageType );

	TSmlProtocolVersion defaultVersion( ESmlVersion1_1_2 );

	switch ( aUsageType )

		{

		case ESmlDataSync:

			defaultVersion = ESmlVersion1_2;

			aVersions.AppendL( ESmlVersion1_2 );

			break;

		case ESmlDevMan:

		if(!FeatureManager::FeatureSupported( KFeatureIdSyncMlDm112  ))

		{

			defaultVersion = ESmlVersion1_2;

			aVersions.AppendL( ESmlVersion1_2 );

		}

		else

		{

			defaultVersion = ESmlVersion1_1_2;

		}

			break;

		default:

			break;

		}

	// both dm and ds support 1.1.2

	aVersions.AppendL( ESmlVersion1_1_2 );

	_DBG_FILE("RSyncMLSession::ListProtocolVersionsL(): end");

	return defaultVersion;

	}

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

// RSyncMLSession::Close()

// Closes the session.

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

//

EXPORT_C void RSyncMLSession::Close()

	{

	_DBG_FILE("RSyncMLSession::Close(): begin");

	// uninitialize feature manager

	FeatureManager::UnInitializeLib();

	delete iEventCallback;

	iEventCallback = NULL;

	delete iData;

	iData = NULL;

	// close session	

	RSessionBase::Close();

	_DBG_FILE("RSyncMLSession::Close(): end");

	}

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

// RSyncMLSession::ReceiveArrayL()

// Private utility method for receiving arrays of integers.

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

//

void RSyncMLSession::ReceiveArrayL( RArray<TInt>& aArray, TInt aStart, TInt aNext, TInt aUsageType ) const

	{

	_DBG_FILE("RSyncMLSession::ReceiveArrayL(): begin");

	aArray.Reset();

	iData->SetBufferSizeL( KNSmlMaxIntFetchCount*KSizeofTInt32 + KSizeofTInt8 );

	TPtr8& dataPtr = iData->DataBufferPtr();

	// IPC

    TIpcArgs args( &dataPtr, aUsageType );

    TInt err = SendReceive( aStart, args );

	if ( err == KErrNone || err == KErrOverflow )

		{

		iData->ReadIntegersToArrayL( aArray ); // integers to array

		while ( err == KErrOverflow )

			{

			dataPtr.Zero();

			// new IPC

			args.Set( 0, &dataPtr );

		    err = SendReceive( aNext, args );

		    if ( err == KErrNone || err == KErrOverflow )

		    	{

				iData->ReadIntegersToArrayL( aArray ); // integers to array

		    	}

			}

		}

	User::LeaveIfError( err );

	_DBG_FILE("RSyncMLSession::ReceiveArrayL(): end");

	}

//

// RSyncMLSettings ( Not Supported )

//

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

// RSyncMLSettings::OpenL()

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

//

EXPORT_C void RSyncMLSettings::OpenL( RSyncMLSession& )

	{

	User::Leave( KErrNotSupported );

	}

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

// RSyncMLSettings::GetValueL()

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

//

EXPORT_C TInt RSyncMLSettings::GetValueL( TSmlGlobalSetting ) const

	{

	User::Leave( KErrNotSupported );

	return 0;

	}

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

// RSyncMLSettings::SetValueL()

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

//

EXPORT_C void RSyncMLSettings::SetValueL( TSmlGlobalSetting, TInt )

	{

	User::Leave( KErrNotSupported );

	}

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

// RSyncMLSettings::Close()

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

//

EXPORT_C void RSyncMLSettings::Close()

	{

	}

//

// RSyncMLHistoryLog

//

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

// RSyncMLHistoryLog::RSyncMLHistoryLog()

// Constructor.

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

//

EXPORT_C RSyncMLHistoryLog::RSyncMLHistoryLog()

	: RSubSessionBase(), iData( NULL )

	{

	}

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

// RSyncMLHistoryLog::OpenL()

// Opens history log sub-session.

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

//

EXPORT_C void RSyncMLHistoryLog::OpenL( RSyncMLSession& aSession, TSmlProfileId aProfileId )

	{

	_DBG_FILE("RSyncMLHistoryLog::OpenL(): begin");

	CClientSessionData::PanicIfAlreadyCreated( iData );

	CHistoryLogSessionData* data = CHistoryLogSessionData::NewLC();

	TPckgBuf<TInt> dataSize;

	TIpcArgs args( &dataSize, aProfileId );

	// open the sub-session

	User::LeaveIfError( CreateSubSession( aSession, ECmdHistoryLogOpen, args ) );

	data->SetProfile( aProfileId );

	iData = data;

	CleanupStack::Pop(); // data

	CleanupClosePushL( *this ); // if leave occures, Close is called by cleanup