// Copyright (c) 2006-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 "pbapfoldernodech.h"

#include "pbapfolderclient.h"

#include "pbaperrorreporter.h"

#include "pbapappheader.h"

#include "pbapserver.h"

#include "pbapchview.h"

#include "pbapchexporter.h"

#include "btaccesshostlog.h"

// constants

_LIT(KFolderIch, "ich");

_LIT(KFolderOch, "och");

_LIT(KFolderMch, "mch");

_LIT(KFolderCch, "cch");

CFolderNodeCallHistory::CFolderNodeCallHistory(MVirtualFolderClient& aClient, const TDesC& aFolderName, THistoryType aHistoryType)

: CFolderNode(aClient, aFolderName), iHistoryType(aHistoryType), iPendingExport(ENoExport)

	{

	LOG_FUNC

	}

// must be called by any class that inherits from CFolderNodeCallHistory

void CFolderNodeCallHistory::ConstructL()

	{

	LOG_FUNC

	// create the view for this folder node

	iFolderView = CPbapChView::NewL(iClient.LogClient(), iHistoryType, *this, KLogNullFlags);	

	}

CFolderNodeCallHistory::~CFolderNodeCallHistory()

	{

	LOG_FUNC

	delete iAsyncExporter;

	delete iFolderView;

	delete iReadFolderView;

 	}

void CFolderNodeCallHistory::CancelGet()

	{

	LOG_FUNC

	// cancel any asynchronous export operations and avoid iAsyncExporter is deleted

	// by itself

	CPbapChExporter* tmpExporter = iAsyncExporter;

	iAsyncExporter = NULL;

	delete tmpExporter;

	delete iAppHeader;

	iAppHeader = NULL;		

	}

void CFolderNodeCallHistory::GetComplete()

	{

	LOG_FUNC

	if (iAsyncExporter)

		{

		delete iAsyncExporter;

		iAsyncExporter = NULL;

		}

	}

TInt CFolderNodeCallHistory::DoExport(TExportType aExportType, TInt aHandle)

	{

	LOG_FUNC

	if(iAsyncExporter)

		{

		__ASSERT_DEBUG(EFalse, Panic(EVirtualFolderChExportAlreadyExists));

		return KErrAlreadyExists;

		}

	TInt err = KErrNone;

	if ((aExportType == EExportItem) && (iCallHistoryChanged))

		{

		// the Call History db has been modified since the last get request

		// report precondition failed error to obex until next listing

		// request completes (or new Pbap session initiated)

		iClient.ErrorReporter().SendPreconditionFailedError();

		// error already reported above so don't update error

		delete iAppHeader;

		iAppHeader = NULL;

		}

	else if (iReadyToExport)

		{

		err = StartExport(aExportType, aHandle);

		}

	else

		{

		// views not ready, setup a pending export until they are

		if(iPendingExport != ENoExport)

			{

			__ASSERT_DEBUG(EFalse, Panic(EVirtualFolderExportAlreadyPending));

			return KErrAlreadyExists;

			}

		if (!iFolderView)

			{

			// creating the folder view failed before, try again

			TRAP(err, iFolderView = CPbapChView::NewL(iClient.LogClient(), iHistoryType, *this, KLogNullFlags));

			}

		// setup this export as pending until we are ready to export

		if (err == KErrNone)

			{

			iPendingExport = aExportType;

			iPendingHandle = aHandle;

			}

		}

	return err;	

	}

TInt CFolderNodeCallHistory::DoGetItem(TInt aHandle)

	{

	LOG_FUNC

	return DoExport(EExportItem, aHandle);

	}

TInt CFolderNodeCallHistory::DoGetListing()

	{

	LOG_FUNC

	return DoExport(EExportListing);

	}

TInt CFolderNodeCallHistory::DoGetCount()

	{

	LOG_FUNC

	return DoExport(EExportCount);

	}

TInt CFolderNodeCallHistory::DoGetFolder()

	{

	LOG_FUNC

	return DoExport(EExportFolder);

	}

 void CFolderNodeCallHistory::HandleExportComplete(TInt aError)

 	{

 	LOG_FUNC

 	if (aError == KErrNotFound && iAppHeader->Operation() == EPullVCard)

 		{

 		// must report not found to client if attempting to pull a vCard which

 		// doesnot exist

 		iClient.ErrorReporter().SendNotFoundError();

 		}

 	else if (aError && iCallHistoryChanged)

 		{

 		iClient.ErrorReporter().SendPreconditionFailedError();

 		}

 	else if (aError)

 		{

 		// error occured during export report service unavailable error to obex 

 		iClient.ErrorReporter().SendServiceUnavailableError();

 		}

  	// a successful listing request allows the ch entries to be pulled again

 	// after the database has been modified

 	if (aError == KErrNone && iAppHeader->Operation() == EPullVCardListing)

 		{

 		iCallHistoryChanged = EFalse;

 		}

	delete iAppHeader;

	iAppHeader = NULL;

 	}

void CFolderNodeCallHistory::CancelPendingExport(TInt err)

	{

	LOG_FUNC

	if (iPendingExport != ENoExport)

		{

		// complete the export with an error

		HandleExportComplete(err);

		// pending export done

		iPendingExport = ENoExport;

		}

	}

TInt CFolderNodeCallHistory::StartExport(TExportType aExportType, TInt aHandle)

	{

	LOG_FUNC

	if(iAsyncExporter)

		{

		__ASSERT_DEBUG(EFalse, Panic(EVirtualFolderChExportAlreadyExists));

		return KErrAlreadyExists;

		}

	if(iReadyToExport == EFalse)

		{

		__ASSERT_DEBUG(EFalse, Panic(EVirtualFolderNotReadyToExport));

		return KErrNotReady;

		}

	if(!iFolderView)

		{

		__ASSERT_DEBUG(EFalse, Panic(EVirtualFolderIncompleteViews));

		return KErrNotFound;

		}

	TInt err = KErrNone;

	switch(aExportType)

		{

		case EExportItem:

			// aHandle is decremented here as the PBAP handles for call histories start at 1 and our event index starts at 0

			TRAP(err, iAsyncExporter = CPbapChSingleItemExporter::NewL(iClient, *this, *iFolderView, aHandle - 1, iAppHeader->VCardVersion(), iAppHeader->Filter()));			

			break;

		case EExportListing:

			TRAP(err, iAsyncExporter = CPbapChListingExporter::NewL(iClient, *this, *iFolderView, iReadFolderView, iAppHeader->ListStartOffset(), iAppHeader->MaxListCount()));

			break;

		case EExportCount:

			TRAP(err, iAsyncExporter = CPbapChCountExporter::NewL(iClient, *this, *iFolderView, iReadFolderView));

			break;

		case EExportFolder:

			TRAP(err, iAsyncExporter = CPbapChItemExporter::NewL(iClient, *this, *iFolderView, iReadFolderView, iAppHeader->ListStartOffset(), iAppHeader->MaxListCount(), iAppHeader->VCardVersion(), iAppHeader->Filter()));

			break;

		case ENoExport:

			// nothing to do

			break;

		default:

			break;			

		}

	return err;

	}

// From MPbapChViewObserver.

void CFolderNodeCallHistory::CallHistoryViewReady(TInt aError)

	{

	LOG_FUNC

	if(aError != KErrNone)

		{

		__ASSERT_DEBUG(EFalse, Panic(EVirtualFolderIncompleteViews));

		}

	// assume we are ready to export unless we determine otherwise

	iReadyToExport = ETrue;

	// make sure that we have all the view required to be able to export

	if ((aError == KErrNone) && (iHistoryType == EMissed) && (!iReadFolderView))

		{

		// create view of read missed events, used to determine the number of unread events

		TRAP(aError, iReadFolderView  = CPbapChView::NewL(iClient.LogClient(), iHistoryType, *this, KLogEventRead));

		if (aError == KErrNone)

			{

			// we will be notified again when the read missed events view is ready so wait for

			// that notification before we are ready to export

			iReadyToExport = EFalse;

			}

		else

			{

			// log error but still allow exports to take place, they will just not include the

			// new unread event count in any export

			LOG1(_L("Failed to create read missed call view, error: %d"), aError);

			}

		}

	else if (aError != KErrNone)

		{

		if (iReadFolderView)

			{

			// log error but still allow exports to take place, they will just not include the

			// new unread event count in any export

			LOG1(_L("Failed to create read missed call view, error: %d"), aError);

			delete iReadFolderView;

			iReadFolderView = NULL;

			}

		else

			{

			// log error and attempt to create views again on next export

			LOG1(_L("Failed to create folder call history view, error: %d"), aError);

			delete iFolderView;

			iFolderView = NULL;

			iReadyToExport = EFalse;

			CancelPendingExport(aError);

			}

		}

	// check for any pending exports

	if ((iReadyToExport) && (iPendingExport != ENoExport))

		{

		aError = StartExport(iPendingExport, iPendingHandle);

		if (aError != KErrNone)

			{

			// complete the export with an error

			HandleExportComplete(aError);

			}

		// pending export done

		iPendingExport = ENoExport;

		}

	}

void CFolderNodeCallHistory::CallHistoryChangeNotification(TBool aViewReady)

	{

	LOG_FUNC

	// Force the PCE to issue a PullvCardListing before we will respond to another

	// PullvCardEntry request for this folder

	iCallHistoryChanged = ETrue;

	// check to see if there is an export in progress

	if (iAsyncExporter)

		{

		// cancel the export and report error according to the error reporting

		// scheme for modified/deleted handles

		CancelGet();

		}

	// the view may need refreshing after a change and therefore we are ready to 

	// export if the view is ready to use. If not, then we will get notification

	// via the CallHistoryViewReady callback

	iReadyToExport = aViewReady;

	}

//

// CFolderNodeIch

//

/*static*/ CFolderNodeIch* CFolderNodeIch::NewL(MVirtualFolderClient& aClient)

	{

	LOG_STATIC_FUNC

	CFolderNodeIch* self = new (ELeave) CFolderNodeIch(aClient);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

CFolderNodeIch::CFolderNodeIch(MVirtualFolderClient& aClient)

: CFolderNodeCallHistory(aClient, KFolderIch(), EIncoming)

	{

	LOG_FUNC

	}	

//

// CFolderNodeOch

//

/*static*/ CFolderNodeOch* CFolderNodeOch::NewL(MVirtualFolderClient& aClient)

	{

	LOG_STATIC_FUNC

	CFolderNodeOch* self = new (ELeave) CFolderNodeOch(aClient);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

CFolderNodeOch::CFolderNodeOch(MVirtualFolderClient& aClient)

: CFolderNodeCallHistory(aClient, KFolderOch(), EOutgoing)

	{

	LOG_FUNC

	}

//

// CFolderNodeMch

//

/*static*/ CFolderNodeMch* CFolderNodeMch::NewL(MVirtualFolderClient& aClient)

	{

	LOG_STATIC_FUNC

	CFolderNodeMch* self = new (ELeave) CFolderNodeMch(aClient);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

CFolderNodeMch::CFolderNodeMch(MVirtualFolderClient& aClient)

: CFolderNodeCallHistory(aClient, KFolderMch(), EMissed)

	{

	LOG_FUNC

	}

//

// CFolderNodeCch

//

/*static*/ CFolderNodeCch* CFolderNodeCch::NewL(MVirtualFolderClient& aClient)

	{

	LOG_STATIC_FUNC

	CFolderNodeCch* self = new (ELeave) CFolderNodeCch(aClient);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

CFolderNodeCch::CFolderNodeCch(MVirtualFolderClient& aClient)

: CFolderNodeCallHistory(aClient, KFolderCch(), ECombined)

	{

	LOG_FUNC

	}