// Copyright (c) 1999-2009 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:

//

#include <e32base.h>

#include <msvstd.h>

#include <msventry.h>

#include <barsread.h>

#include <msvsenderroraction.h>

#include <schsend_panic.h>

//

//

//	TMsvSendErrorAction Implementation

//

//

/**

Default constructor.

*/

EXPORT_C TMsvSendErrorAction::TMsvSendErrorAction()

	{

	Reset();

	}

/*

EXPORT_C TMsvSendErrorAction::TMsvSendErrorAction(const TMsvSendErrorAction& aErrorAction)

	{

	iAction			= aErrorAction.iAction;

	iError			= aErrorAction.iError;

	iMaxRetries		= aErrorAction.iMaxRetries;

	iRetries		= aErrorAction.iRetries;

	iRetrySpacing	= aErrorAction.iRetrySpacing;

	iVersion		= aErrorAction.iVersion;

	}

*/

/**

Sets all member data to default values.

*/

EXPORT_C void TMsvSendErrorAction::Reset()

	{

	iError				= KErrNone;

	SetMaxRetries(3);

	iAction				= ESendActionFail;

	iRetries			= ESendRetriesFixed;

	iRetrySpacing		= ESendRetrySpacingStatic;

	}

/**

Sets the maximum number of retries.

@param aMaxRetries

Maximum number of retries.

@panic ScheduleSend-DLL 21

The maximum number of retries is negative.

*/

EXPORT_C void TMsvSendErrorAction::SetMaxRetries(const TInt16 aMaxRetries)

	{

	__ASSERT_ALWAYS(aMaxRetries >= 0, gPanic(EMaxRetriesMustBePositive));

	iMaxRetries = aMaxRetries;

	}

/**

Gets the maximum number of retries.

@return Maximum number of retries

*/

EXPORT_C TInt16 TMsvSendErrorAction::MaxRetries() const

	{

	return iMaxRetries;

	}

//

//

// CMsvSendErrorActions Implementation

//

//

/**

Allocates and creates a new CMsvSendErrorActions object.

@return New object

*/

EXPORT_C CMsvSendErrorActions* CMsvSendErrorActions::NewL()

	{

	CMsvSendErrorActions* self = CMsvSendErrorActions::NewLC();

	CleanupStack::Pop(self); 

	return self;

	}

/**

Allocates and creates a new CMsvSendErrorActions object.

@return New object

*/

EXPORT_C CMsvSendErrorActions* CMsvSendErrorActions::NewLC()

	{

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

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

//

//	CMsvSendErrorActions Constructor

//

CMsvSendErrorActions::CMsvSendErrorActions()

	{

	iDefault.Reset();

	}

void CMsvSendErrorActions::ConstructL()

	{

	iErrors = new (ELeave) CArrayFixFlat<TMsvSendErrorAction>(1);

	}

/**

Destructor.

*/

EXPORT_C CMsvSendErrorActions::~CMsvSendErrorActions()

	{

	delete iErrors;

	}

EXPORT_C void CMsvSendErrorActions::Reset()

	{

	iDefault.Reset();

	iErrors->Reset();

	}

/**

Adds a TMsvSendErrorAction object. 

If a TMsvSendErrorAction already exists in the collection for the same error, 

then it is replaced by aAction.

@param aErrorAction

Error action to add.

@leave Any error code but KErrNone and KErrNotFound

We tried to delete the error action if it already exists and 

RemoveSendErrorAction() returned an error.

@leave KErrAlreadyExists

A duplicate was found when inserting the error action in the array.

*/

EXPORT_C void CMsvSendErrorActions::AddSendErrorActionL(const TMsvSendErrorAction& aErrorAction)

	{

	//Delete the error if it already exists.

	TInt error = RemoveSendErrorAction(aErrorAction.iError);

	if (error != KErrNone && error != KErrNotFound)

		{

		User::Leave(error);

		}

	TInt offSet = _FOFF(TMsvSendErrorAction, iError);

	TKeyArrayFix key(offSet, ECmpTInt);

	//Insert the error action into the array of errors sorted by iError.

	//No duplicates allowed

	iErrors->InsertIsqL(aErrorAction, key);

	}

/**

Gets an error action for a specified error.

@param aError

Error to find.

@param aErrorAction

On return, the corresponding TMsvSendErrorAction.

@return KErrNotFound if there is no corresponding TMsvSendErrorAction 

for aError.

*/

EXPORT_C TInt CMsvSendErrorActions::GetSendErrorAction(const TInt aError, TMsvSendErrorAction& aErrorAction) const

	{

	TInt index = 0;

	TInt error = Find(aError, index);

	if (error == KErrNone)

		{

		aErrorAction = iErrors->At(index);

		}

	return error;

	}

/*

	Find

	Returns the index of the TMsvSendErrorAction in iErrors where

	TMsvSendErrorAction::iError == aError.

	Return KErrNotFound if the aError is not found in iErrors

*/

TInt CMsvSendErrorActions::Find(const TInt aError, TInt& aIndex) const

	{

	TMsvSendErrorAction tempAction;

	tempAction.iError = aError;

	TInt offSet = _FOFF(TMsvSendErrorAction, iError);

	TKeyArrayFix key(offSet, ECmpTInt);

	TInt found = iErrors->FindIsq(tempAction, key, aIndex);

	if (found != 0) //Not Found

		{

		return KErrNotFound;

		}

	return KErrNone;

	}

/**

Removes an error action.

@param aError

Error to remove.

@return KErrNotFound if there is no corresponding TMsvSendErrorAction for 

aError

*/

EXPORT_C TInt CMsvSendErrorActions::RemoveSendErrorAction(const TInt aError)

	{

	TInt index = 0;

	const TInt error = Find(aError, index);

	if (error == KErrNone)

		{

		iErrors->Delete(index);

		}

	return error;

	}

/**

Restores the object from a resource. 

The resource must be of type SEND_ERROR_ACTIONS.

@param aReader

Resource reader at appropriate resource.

@leave AddSendErrorActionL()

*/

EXPORT_C void CMsvSendErrorActions::RestoreFromResourceL(TResourceReader& aReader)

	{

	iErrors->Reset();

	RestoreErrorActionL(aReader, 1, ETrue);

	TInt actionTotal = aReader.ReadInt16();

	RestoreErrorActionL(aReader, actionTotal, EFalse);

	}

void CMsvSendErrorActions::RestoreErrorActionL(TResourceReader& aReader, TInt aActionCount, const TBool aDefault)

	{

	while (aActionCount--)

		{

		TInt actionFlags = aReader.ReadInt8();

		TMsvSendErrorAction errorAction;

		errorAction.iAction = (TMsvSendAction) (actionFlags & KActionMask);

		errorAction.iRetries = (TMsvSendRetries) (actionFlags & KRetriesMask);

		errorAction.iRetrySpacing = (TMsvSendRetrySpacing) (actionFlags & KRetrySpacingMask);

		errorAction.SetMaxRetries((TInt16) aReader.ReadInt16());

		TInt errorCount = aReader.ReadInt16();

		while (errorCount--)

			{

			errorAction.iError = aReader.ReadInt32();

			aDefault ? SetDefault(errorAction) : AddSendErrorActionL(errorAction);

			}

		}

	}

/**

Gets the object's array of error-actions.

@return The object's array of error-actions

*/

EXPORT_C const CArrayFixFlat<TMsvSendErrorAction>& CMsvSendErrorActions::Errors() const

	{

	return *iErrors;

	}

/**

Sets the object to an array of error-actions.

@param aErrors

Array to use.

@leave AddSendErrorActionL()

*/

EXPORT_C void CMsvSendErrorActions::SetErrorsL(const CArrayFixFlat<TMsvSendErrorAction>& aErrors)

	{

	iErrors->Reset();

	const TInt count = aErrors.Count();

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

		{

		AddSendErrorActionL(aErrors[i]);

		}

	}

/**

Gets the default error-action.

The default is used if a specified error-action is not found for the error.

@return Default error-action

*/

EXPORT_C const TMsvSendErrorAction& CMsvSendErrorActions::Default() const

	{

	return iDefault;

	}

/**

Sets the default error-action.

@param aAction

Default error-action.

*/

EXPORT_C void CMsvSendErrorActions::SetDefault(const TMsvSendErrorAction& aAction)

	{

	iDefault = aAction;

	}