/*

* Copyright (c) 2002 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:  Alert info

*

*/

#include <SyncMLHistory.h>

#include <SyncMLAlertInfo.h>

#include <nsmlconstants.h>

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

// CSmlAlertInfo::NewLC()

// Two phase constructor

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

EXPORT_C CSmlAlertInfo* CSmlAlertInfo::NewLC()

	{

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

	CleanupStack::PushL( self );

	return self;

	}

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

// CSmlAlertInfo::CSmlAlertInfo()

// Constructor

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

EXPORT_C CSmlAlertInfo::CSmlAlertInfo()

: iVendorSpecificInfo( NULL )

	{

	}

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

// CSmlAlertInfo::~CSmlAlertInfo()

// Destructor

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

EXPORT_C CSmlAlertInfo::~CSmlAlertInfo()

	{

	iTaskIds.Reset();

	iTaskIds.Close();

	iTaskSyncTypes.Reset();

	iTaskSyncTypes.Close();

	delete iVendorSpecificInfo;

	}

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

// CSmlAlertInfo::InternalizeL(RReadStream& aStream)

// Reads alert info from given stream

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

EXPORT_C void CSmlAlertInfo::InternalizeL(RReadStream& aStream)

	{

	iErrorCode = aStream.ReadInt32L();

	iJobControl = (CSmlAlertInfo::TJobControl) aStream.ReadInt32L();

	iProtocol = (TSmlUsageType) aStream.ReadInt32L();

	iSessionId = aStream.ReadInt32L();

	iProfile = aStream.ReadInt32L();

	iTransport = aStream.ReadInt32L();

	TInt vendorLength = aStream.ReadInt32L();

	iVendorSpecificInfo = HBufC8::NewL(vendorLength);

	TPtr8 ptrVendor = iVendorSpecificInfo->Des();

	aStream.ReadL( ptrVendor, vendorLength );

	TInt count = aStream.ReadInt32L();

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

		{

		TInt id = aStream.ReadInt32L();

		iTaskIds.AppendL(id);

		TSmlSyncType syncType = ( TSmlSyncType )aStream.ReadInt32L();

		iTaskSyncTypes.AppendL( syncType );

		}

	}

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

// CSmlAlertInfo::ExternalizeL(RWriteStream& aStream) const

// Writes alert info to given stream

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

EXPORT_C void CSmlAlertInfo::ExternalizeL(RWriteStream& aStream) const

	{

	aStream.WriteInt32L(iErrorCode);

	aStream.WriteInt32L((TInt) iJobControl);

	aStream.WriteInt32L((TInt) iProtocol);

	aStream.WriteInt32L(iSessionId);

	aStream.WriteInt32L(iProfile);

	aStream.WriteInt32L(iTransport);

	aStream.WriteInt32L( iVendorSpecificInfo->Length() );

	aStream.WriteL(iVendorSpecificInfo->Des());

	TInt count = iTaskIds.Count();

	aStream.WriteInt32L(count);

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

		{

		aStream.WriteInt32L(iTaskIds[i]);

		aStream.WriteInt32L(iTaskSyncTypes[i]);

		}

	}

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

// CSmlAlertInfo::ErrorCode() const

// Returns error code

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

EXPORT_C TInt CSmlAlertInfo::ErrorCode() const

	{

	return iErrorCode;	

	}

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

// CSmlAlertInfo::JobControl() const

// Returns job control

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

EXPORT_C CSmlAlertInfo::TJobControl CSmlAlertInfo::JobControl() const

	{

	return iJobControl;

	}

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

// CSmlAlertInfo::Protocol() const

// Returns the usage type

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

EXPORT_C TSmlUsageType CSmlAlertInfo::Protocol() const

	{

	return iProtocol;

	}

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

// CSmlAlertInfo::SessionId() const

// Returns the session identifier

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

EXPORT_C TInt CSmlAlertInfo::SessionId() const

	{

	return iSessionId;

	}

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

// CSmlAlertInfo::Profile() const

// Returns the profile identifier

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

EXPORT_C TSmlProfileId CSmlAlertInfo::Profile() const

	{

	return iProfile;

	}

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

// CSmlAlertInfo::Transport() const

// Returns the transport identifier

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

EXPORT_C TSmlTransportId CSmlAlertInfo::Transport() const

	{

	return iTransport;

	}

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

// CSmlAlertInfo::Connection() const

// Returns the connection identifier

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

EXPORT_C TSmlConnectionId CSmlAlertInfo::Connection() const

	{

	return iConnection;

	}

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

// CSmlAlertInfo::TaskIds() const

// Returns reference to task id array

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

EXPORT_C const RArray<TInt>& CSmlAlertInfo::TaskIds() const

	{

	return iTaskIds;

	}

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

// CSmlAlertInfo::TaskIds() const

// Returns reference to sync type array

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

EXPORT_C const RArray<TSmlSyncType>& CSmlAlertInfo::TaskSyncTypes() const

	{

	return iTaskSyncTypes;

	}

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

// CSmlAlertInfo::VendorSpecificInfo() const

// Returns vendor specific information

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

EXPORT_C const TDesC8& CSmlAlertInfo::VendorSpecificInfo() const

	{

	if ( iVendorSpecificInfo )

		{

		return *iVendorSpecificInfo;	

		}

	return KNullDesC8;

	}	

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

// CSmlAlertInfo::CreateSession() const

// Returns whether to create a session

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

EXPORT_C TBool CSmlAlertInfo::CreateSession() const

	{

	if ( iJobControl == EDoNotCreateJob )

		{

		return EFalse;

		}

	return ETrue;

	}

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

// CSmlAlertInfo::Reset()

// Resets alert info to default values

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

EXPORT_C void CSmlAlertInfo::Reset()

	{

	iErrorCode = KErrNone;

	iJobControl = EDoNotCreateJob;

	iProtocol = ESmlDataSync;

	iSessionId = 0;

	iProfile = KNSmlNullId;

	iTransport = 0;

	iTaskIds.Reset();

	iTaskSyncTypes.Reset();

	delete iVendorSpecificInfo;

	iVendorSpecificInfo = NULL;

	}

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

// CSmlAlertInfo::SetErrorCode(TInt aError)

// Sets error code

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

EXPORT_C void CSmlAlertInfo::SetErrorCode(TInt aError)

	{

	iErrorCode = aError;

	}

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

// CSmlAlertInfo::SetJobControl(TJobControl aJobControl)

// Sets job control value

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

EXPORT_C void CSmlAlertInfo::SetJobControl(TJobControl aJobControl)

	{

	iJobControl = aJobControl;

	}

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

// CSmlAlertInfo::SetProtocolType(TSmlUsageType aProtocol)

// Sets usage type

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

EXPORT_C void CSmlAlertInfo::SetProtocolType(TSmlUsageType aProtocol)

	{

	iProtocol = aProtocol;

	}

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

// CSmlAlertInfo::SetSessionId(TInt aId)

// Sets session id

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

EXPORT_C void CSmlAlertInfo::SetSessionId(TInt aId)

	{

	iSessionId = aId;

	}

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

// CSmlAlertInfo::SetProfileId(TSmlProfileId aProfileId)

// Sets profile identifier

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

EXPORT_C void CSmlAlertInfo::SetProfileId(TSmlProfileId aProfileId)

	{

	iProfile = aProfileId;

	}

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

// CSmlAlertInfo::SetTransportId(TSmlTransportId aTransportId)

// Sets transport identifier

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

EXPORT_C void CSmlAlertInfo::SetTransportId(TSmlTransportId aTransportId)

	{

	iTransport = aTransportId;

	}

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

// CSmlAlertInfo::SetConnectionId(TSmlConnectionId aConnectionId)

// Sets connection identifier

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

EXPORT_C void CSmlAlertInfo::SetConnectionId(TSmlConnectionId aConnectionId)

	{

	iConnection = aConnectionId;

	}

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

// CSmlAlertInfo::TaskIds()

// Return reference to Task identifier array

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

EXPORT_C RArray<TInt>& CSmlAlertInfo::TaskIds()

	{

	return iTaskIds;

	}

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

// CSmlAlertInfo::TaskSyncTypes()

// Return reference to Task sync type array

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

EXPORT_C RArray<TSmlSyncType>& CSmlAlertInfo::TaskSyncTypes()

	{

	return iTaskSyncTypes;

	}

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

// CSmlAlertInfo::SetVendorSpecificInfoL(const TDesC8& aVendor)

// Sets vendor specific information

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

EXPORT_C void CSmlAlertInfo::SetVendorSpecificInfoL(const TDesC8& aVendor)

	{

	HBufC8* vendor = aVendor.AllocL();

	delete iVendorSpecificInfo;

	iVendorSpecificInfo = vendor;

	}

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

// SetConfirmation(TBool aConfirmation)

// Sets confirmation to create job

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

EXPORT_C void CSmlAlertInfo::SetConfirmation(TBool aConfirmation )

	{

	if ( aConfirmation )

		{

		iJobControl = ECreateJob;

		}

	else

		{

		iJobControl = EDoNotCreateJob;

		}

	}

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

// CSmlAlertInfo::SetJobControl(TJobControl aJobControl)

// Sets job control value

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

EXPORT_C void CSmlAlertInfo::SetUimode(TInt aUimode)

	{

	iUimode = aUimode;

	}

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

// CSmlAlertInfo::SetJobControl(TJobControl aJobControl)

// Sets job control value

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

EXPORT_C TInt CSmlAlertInfo::GetUimode()

	{

	return iUimode;

	}	

//End of File