/*

* 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 CClientSessionData objects

*

*/

#include <s32mem.h>

#include <featmgr.h>

#include <badesca.h> // CDesCArray

#include <nsmlconstants.h>

#include <nsmldebug.h>

#include "NSmlClientAPIUtils.h"

#include "NSmlClientAPIDefs.h"

#include "nsmlsosserverdefs.h"

#include "NSmlTransportHandler.h"

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

//

// CNSmlClientAPIFeatureHandler

//

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

// NSmlClientAPIFeatureHandler::LeaveIfDataSyncNotSupportedL()

// Leaves with KErrNotSupported, if data sync is not supported.

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

//

void NSmlClientAPIFeatureHandler::LeaveIfDataSyncNotSupportedL()

	{

	if ( ! FeatureManager::FeatureSupported( KFeatureIdSyncMlDs ) )

		{

		_DBG_FILE("CNSmlClientAPIFeatureHandler::LeaveIfDataSyncNotSupportedL: NOT SUPPORTED !");

		User::Leave( KErrNotSupported );

		}

	}

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

// NSmlClientAPIFeatureHandler::LeaveIfDevManNotSupportedL()

// Leaves with KErrNotSupported, if device management is not 

// supported.

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

//

void NSmlClientAPIFeatureHandler::LeaveIfDevManNotSupportedL()

	{

	if ( ! FeatureManager::FeatureSupported( KFeatureIdSyncMlDm ) )

		{

		_DBG_FILE("CNSmlClientAPIFeatureHandler::LeaveIfDevManNotSupportedL: NOT SUPPORTED !");

		User::Leave( KErrNotSupported );

		}

	}

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

// NSmlClientAPIFeatureHandler::LeaveIfUsageTypeNotSupportedL(

// Leaves with KErrNotSupported, if the given usage type is 

// not supported.

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

//

void NSmlClientAPIFeatureHandler::LeaveIfUsageTypeNotSupportedL( TSmlUsageType aUsageType )

	{

	switch ( aUsageType )

		{

		case ESmlDataSync:

			NSmlClientAPIFeatureHandler::LeaveIfDataSyncNotSupportedL();

			break;

		case ESmlDevMan:

			NSmlClientAPIFeatureHandler::LeaveIfDevManNotSupportedL();

			break;

		default:

			break;

		}

	}

//

// CClientSessionData

//

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

// CClientSessionData::CClientSessionData()

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

//

CClientSessionData::CClientSessionData() 

	: iDataPtr( 0, NULL, 0)

	{

	}

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

// CClientSessionData::~CClientSessionData()

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

//

CClientSessionData::~CClientSessionData() 

	{

	delete iBuffer;

	iBuffer = NULL;

	}

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

// CClientSessionData::InternalizeL()

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

//

void CClientSessionData::InternalizeL( RReadStream& /*aStream*/ )

	{

	}

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

// CClientSessionData::ExternalizeL()

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

//

void CClientSessionData::ExternalizeL( RWriteStream& /*aStream*/ ) const

	{

	}

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

// CClientSessionData::DataBuffer()

// Returns reference to data buffer

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

//

CBufBase& CClientSessionData::DataBuffer()

    {

    return *iBuffer;

    }

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

// CClientSessionData::ReadIntegersToArrayL()

// Reads integers from iBuffer to aArray.

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

//

void CClientSessionData::ReadIntegersToArrayL( RArray<TInt>& aArray )

	{

	// read data using a stream

    RDesReadStream stream( iDataPtr );

	CleanupClosePushL( stream );

    TInt count = stream.ReadInt8L();

	// append inttegers to array

    for ( TInt i = 0; i < count; ++i )

        {

        aArray.AppendL( stream.ReadInt32L() );

        }

    CleanupStack::PopAndDestroy(); // stream

	}

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

// CClientSessionData::SetBufferSizeL()

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

//

void CClientSessionData::SetBufferSizeL( TInt aSize ) 

	{

	if ( iBuffer )

		{

		ClearDataBuffer();

		}

	iBuffer = CBufFlat::NewL( KDefaultNSmlBufferGranularity );	

	if ( aSize != -1 )

	    {

	    iBuffer->ResizeL( aSize );    

	    }

	}

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

// CClientSessionData::ClearDataBuffer()

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

//

void CClientSessionData::ClearDataBuffer() 

	{

	delete iBuffer;

	iBuffer = NULL;

	}

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

// CClientSessionData::DataBuffer()

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

//

TPtr8& CClientSessionData::DataBufferPtr() 

	{

	iDataPtr.Set( iBuffer->Ptr(0) );

	return iDataPtr;

	}

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

// CClientSessionData::PanicIfAlreadyCreated()

// Panics the thread if the given pointer is not NULL, i.e.

// the object has been instantiated. This method is used 

// in session and subsession objects to check that they are not 

// open when the session is opened/created.

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

//

void CClientSessionData::PanicIfAlreadyCreated( CClientSessionData* aPtr )

	{

	if ( aPtr )

		{

		_DBG_FILE("CClientSessionData::PanicIfAlreadyCreated: ALREADY CREATED !");

		User::Panic(KNSmlClientAPIPanic, ESmlClientPanicSessionAlreadyOpen);

		}

	}

//

// CHistoryLogSessionData

//

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

// CHistoryLogSessionData::NewL()

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

//

CHistoryLogSessionData* CHistoryLogSessionData::NewL()

	{

	CHistoryLogSessionData* self = CHistoryLogSessionData::NewLC();

	CleanupStack::Pop();

	return self;

	}

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

// CHistoryLogSessionData::NewLC()

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

//

CHistoryLogSessionData* CHistoryLogSessionData::NewLC()

	{

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

	CleanupStack::PushL( self );

	self->ConstructL();

	return self;

	}

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

// CHistoryLogSessionData::~CHistoryLogSessionData()

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

//

CHistoryLogSessionData::~CHistoryLogSessionData()

	{

	delete iHistoryArray;

	}

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

// CHistoryLogSessionData::InternalizeL()

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

//

void CHistoryLogSessionData::InternalizeL( RReadStream& aStream )

	{

	iHistoryArray->InternalizeL( aStream );

	}

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

// CHistoryLogSessionData::SetProfile()

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

//

void CHistoryLogSessionData::SetProfile( const TSmlProfileId aProfileId )

	{

	iProfileId = aProfileId;

	}

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

// CHistoryLogSessionData::CHistoryLogSessionData()

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

//

CHistoryLogSessionData::CHistoryLogSessionData()

	: iProfileId( KNSmlNullId )

	{

	}

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

// CHistoryLogSessionData::ConstructL()

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

//

void CHistoryLogSessionData::ConstructL()

	{

	iHistoryArray = CNSmlHistoryArray::NewL();

	iHistoryArray->SetOwnerShip( ETrue );

	}

//

// CJobBaseSessionData

//

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

// CJobBaseSessionData::~CJobBaseSessionData()

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

//

CJobBaseSessionData::~CJobBaseSessionData()

	{

	iParams.Close();

	}

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

// CJobBaseSessionData::InternalizeL()

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

//

void CJobBaseSessionData::InternalizeL( RReadStream& aStream )

	{

	// read profile id

	iProfileId = aStream.ReadInt32L();

	}

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

// CJobBaseSessionData::WriteIntegersToBufferL()

// Writes the integers in iParams to iBuffer. If aArray is 

// present, it's count is first written to the buffer (after 

// the values in aArray) and then the integers in aArray.

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

//

void CJobBaseSessionData::WriteIntegersToBufferL( const RArray<TInt>* aArray )

	{

	TInt size = 0;

	if ( aArray )

		{

		size += aArray->Count() * KSizeofTInt32; // size of items

		size += KSizeofTInt8; // count of items

		}

	size += iParams.Count() * KSizeofTInt32;

	SetBufferSizeL( size );

	TPtr8 dataPtr = DataBufferPtr();

	// open stream to iBuffer

	RDesWriteStream stream;

	stream.Open( dataPtr );

	CleanupClosePushL( stream );

	// write integers in iParams

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

		{

		stream.WriteInt32L( iParams[i] );

		}

	// write the count of items in aArray and then the items (if any)

	if ( aArray )

		{

		TInt count = aArray->Count();

		stream.WriteInt8L( count );

		for ( TInt j = 0; j < count; ++j )

			{

			stream.WriteInt32L( (*aArray)[j] );

			}

		}

	CleanupStack::PopAndDestroy(); // stream

	}

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

// CJobBaseSessionData::AddParamL()

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

//

void CJobBaseSessionData::AddParamL( const TInt aParam )

	{

	iParams.AppendL( aParam );

	}

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

// CJobBaseSessionData::SetIdentifier()

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

//

void CJobBaseSessionData::SetIdentifier( const TSmlJobId aJobId )

	{

	iJobId = aJobId;

	}

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

// CJobBaseSessionData::SetProfile()

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

//

void CJobBaseSessionData::SetProfile( const TSmlProfileId aProfileId )

	{

	iProfileId = aProfileId;

	}

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

// CJobBaseSessionData::CJobBaseSessionData()

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

//

CJobBaseSessionData::CJobBaseSessionData()

	: iJobId( KNSmlNullId )

	{

	}

//

// CDataSyncJobSessionData

//

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

// CDataSyncJobSessionData::CDataSyncJobSessionData()

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

//

CDataSyncJobSessionData::CDataSyncJobSessionData()

	: CJobBaseSessionData()

	{

	}

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

// CDataSyncJobSessionData::~CDataSyncJobSessionData()

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

//

CDataSyncJobSessionData::~CDataSyncJobSessionData()

	{

	iTasks.Close();

	}

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

// CDataSyncJobSessionData::InternalizeL()

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

//

void CDataSyncJobSessionData::InternalizeL( RReadStream& aStream )

	{

	// base class internalization first

	CJobBaseSessionData::InternalizeL( aStream );

	// read count and the task ids

	TInt count = aStream.ReadInt8L();

	for ( TInt i = 0; i < count; ++i )

		{

		iTasks.AppendL( aStream.ReadInt32L() );

		}

	}

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

// CDataSyncJobSessionData::SetTasksL()

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

//

void CDataSyncJobSessionData::SetTasksL( const RArray<TInt>& aTasks )

	{

	iTasks.Reset();

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

		{

		iTasks.AppendL( aTasks[i] );

		}

	}

//

// CDevManJobSessionData

//

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

// CDevManJobSessionData::CDevManJobSessionData()

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

//

CDevManJobSessionData::CDevManJobSessionData()

	: CJobBaseSessionData()

	{

	}

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

// CDevManJobSessionData::~CDevManJobSessionData()

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

//

CDevManJobSessionData::~CDevManJobSessionData()

	{

	}

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

// CDevManJobSessionData::InternalizeL()

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

//

void CDevManJobSessionData::InternalizeL( RReadStream& aStream )

	{

	CJobBaseSessionData::InternalizeL( aStream );

	}

//

// CProfileBaseSessionData

//

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

// CProfileBaseSessionData::CProfileBaseSessionData()

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

//

CProfileBaseSessionData::CProfileBaseSessionData()

	: iSanAction( ESmlConfirmSync ), iCreatorId( KNSmlNullId ), iProfileId( KNSmlNullId ), 

	iOpenMode( ESmlOpenReadWrite ), iDeleteAllowed ( ETrue ),iProfileLocked ( EFalse )

	{

	}

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

// CProfileBaseSessionData::~CProfileBaseSessionData()

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

//

CProfileBaseSessionData::~CProfileBaseSessionData()

	{

	delete iUserName;

	delete iPassword;

	delete iDisplayName;

	delete iServerPassword;

	delete iServerId;

	}

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

// CProfileBaseSessionData::InternalizeL()

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

//

void CProfileBaseSessionData::InternalizeL( RReadStream& aStream )

	{

	iDisplayName = HBufC::NewL( aStream, aStream.ReadInt32L() );

	iUserName = HBufC8::NewL( aStream, aStream.ReadInt32L() );

	iPassword = HBufC8::NewL( aStream, aStream.ReadInt32L() );

	iServerId = HBufC8::NewL( aStream, aStream.ReadInt32L() );

	iSanAction = static_cast<TSmlServerAlertedAction>( aStream.ReadInt8L() );

	iCreatorId = aStream.ReadInt32L();