// Copyright (c) 1997-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 "smspdel.h"
#include "smspmain.h"

#include "smsuset.h"

#include <exterror.h>
#include "SmsuTimer.h"
#include "smspqueue.h"


/**
 *  Creates new CSmsStoreRead instance
 *  
 *  @param aSmsComm		reference to the MSmsComm class
 *  @param aSmsSettings	reference to the TSmsSettings class
 *  @param aSmsMessaging	reference to the RMobileSmsMessaging class
 */
CSmsPDUDelete* CSmsPDUDelete::NewL(const TSmsSettings& aSmsSettings,
								   RMobileSmsMessaging& aSmsMessaging
								   )
	{
	LOGSMSPROT1("CSmsPDUDelete::NewL()");

	CSmsPDUDelete* smsPduDelete =
		new(ELeave) CSmsPDUDelete(aSmsSettings,aSmsMessaging);
	CleanupStack::PushL(smsPduDelete);
	smsPduDelete->ConstructL();
	CleanupStack::Pop();
	return smsPduDelete;
	} // CSmsPDUDelete::NewL


/**
 *  Constructor
 *  
 *  @param aSmsComm		reference to the MSmsComm class
 *  @param aSmsSettings	reference to the TSmsSettings class
 *  @param aSmsMessaging	reference to the RMobileSmsMessaging class
 */
CSmsPDUDelete::CSmsPDUDelete(const TSmsSettings& aSmsSettings,
							 RMobileSmsMessaging& aSmsMessaging)
  : CSmsuActiveBase(KSmsSessionPriority),
	iState(ESmsPDUDeleteIdle),
	iSmsSettings(aSmsSettings),
	iSmsMessaging(aSmsMessaging)
	{
	// NOP
	} // CSmsPDUDelete::CSmsPDUDelete


/**
 *  Creates instance to the class CSmsuTimeout
 */
void CSmsPDUDelete::ConstructL()
	{
	LOGSMSPROT1("CSmsPDUDelete::ConstructL()");

	ConstructTimeoutL();
	} // CSmsPDUDelete::ConstructL


/**
 *  Starts CSmsPDUDelete active object
 *  Calls private methd OpenStore
 *  
 *  @param aStatus     Reguest status
 *  @param aStoreIndex Index to the store to be read
 */
void CSmsPDUDelete::Start(CArrayFix<TGsmSmsSlotEntry>& aLocationArray, TRequestStatus& aStatus)
	{
	LOGSMSPROT1("CSmsPDUDelete::Start()");

	__ASSERT_DEBUG(iState==ESmsPDUDeleteIdle,SmspPanic(KSmspPanicUnexpectedState));

	Queue(aStatus);

	iLocationArray=&aLocationArray;
	iState=ESmsPDUDeleteOpeningStore;
	OpenStore();
	} // CSmsPDUDelete::Start


/**
 *  Called by Active Scheduler
 *  
 *  Deletes slots giving in array. Opens new store if store change
 */
void CSmsPDUDelete::DoRunL()
	{
    LOGSMSPROT2("CSmsPDUDelete::RunL [iStatus=%d]", iStatus.Int());

	switch (iState)
		{
		case ESmsPDUDeleteOpeningStore:
			{
			//
			// If the store was opened, then delete the PDU...
			//
			if (iStatus.Int() == KErrNone)
				{
				DeletePDU();
				}
			}
			break;

		case ESmsPDUDeleteDeletingPDU:
			{
			//
			// If deleting the PDU returned not found, then this is a valid
			// result so assume KErrNone.
			//
			if (iStatus.Int() == KErrNotFound  ||
				iStatus.Int() == KErrGsmSMSInvalidMemoryIndex)
				{
				iStatus = KErrNone;
				}

			//
			// If the delete was successful (or assumed to be) then remove
			// it from the list. If the next one is the on a different store,
			// then change stores, otherwise delete it.
			//
			if (iStatus.Int() == KErrNone)
				{
				iLocationArray->Delete(0);

				if (iLocationArray->Count() > 0)
					{
					if (iLocationArray->At(0).iStore != iCurrentStore)
						{
						OpenStore();
						}
					else
						{
						DeletePDU();
						}
					}
				}
			}
			break;

		default:
			{
			SmspPanic(KSmspPanicUnexpectedState);
			}
			break;
		}

	//
	// DoRunL() will now return to CSmsuActiveBase which if the object
	// is not active, will call Complete().
	//
	} // CSmsPDUDelete::DoRunL


/**
 *  private method for opening the store where slot is saved
 */
void CSmsPDUDelete::OpenStore()
	{
	LOGSMSPROT1("CSmsPDUDelete::OpenStore()");

	//
	// Open the SMS Store for the first PDU...
	//
	if (iLocationArray->Count() > 0)
		{
		//
		// Close it first, just in case it was left open...
		//
		iSmsStorage.Close();

		//
		// Now open the store...
		//
		TInt  ret;
		
		ret = iSmsStorage.Open(iSmsMessaging, iLocationArray->At(0).iStore);
		if (ret == KErrNone)
			{
			iCurrentStore = iLocationArray->At(0).iStore;
			}

		//
		// Complete this object to allow correct flow through DoRunL()
		// and Complete() if needed.
		//			
		iState = ESmsPDUDeleteOpeningStore;

		CompleteMyself(ret);
		}
	} // CSmsPDUDelete::OpenStore


/**
 *  private method for deleting slot from the store
 */
void CSmsPDUDelete::DeletePDU()
	{
	LOGSMSPROT1("CSmsPDUDelete::DeletePDU()");

	//
	// Delete the first entry in the list...
	//
	if (iLocationArray->Count() > 0)
		{
		iSmsStorage.Delete(iStatus, iLocationArray->At(0).iIndex);

		iState = ESmsPDUDeleteDeletingPDU;

		TimedSetActive(iSmsSettings.Timeout());
		}
	} // CSmsPDUDelete::DeletePDU


/**
 *  Called by Active Scheduler
 */
void CSmsPDUDelete::DoCancel()
	{
	LOGSMSPROT1("CSmsPDUDelete::DoCancel()");

	TimedSetActiveCancel();

	switch (iState)
		{
		case ESmsPDUDeleteOpeningStore:
			{
			//
			// Will never happen as CompleteMyself() was used...
			//
			}
			break;

		case ESmsPDUDeleteDeletingPDU:
			{
			iSmsStorage.CancelAsyncRequest(EMobilePhoneStoreDelete);
			}
			break;

		default:
			{
			SmspPanic(KSmspPanicUnexpectedState);
			}
		}

	//
	// Handle completion of this Active Object. Note that the object
	// may well still be active at this point...
	//
	if (TimedOut())
		{
		Complete(KErrTimedOut);
		}
	else
		{
		Complete(KErrCancel);
		}
	} // CSmsPDUDelete::DoCancel


/**
 *  Completes this object
 */
void CSmsPDUDelete::Complete(TInt aStatus)
	{
	LOGSMSPROT1("CSmsPDUDelete::Complete()");

	//
	// Only close the SMS Storage if the object is not active (and it may be
	// if the operation was cancelled). Otherwise it will be closed on
	// destruction.
	//
	if (!IsActive())
		{
		iSmsStorage.Close();
		}

	//
	// Resets slot array...
	//
	iLocationArray->Reset();

	//
	// Call the base function to perform the actual complete...
	//
	CSmsuActiveBase::Complete(aStatus);

	//
	// This active object has completed...
	//
	iState = ESmsPDUDeleteIdle;
	} // CSmsPDUDelete::Complete


/**
 *  Destructor
 */
CSmsPDUDelete::~CSmsPDUDelete()
	{
	Cancel();
	iSmsStorage.Close();
	} // CSmsPDUDelete::~CSmsPDUDelete