// 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 "caltestlib.h"

#include <calentryview.h>

#include <calinstance.h>

#include <calinstanceview.h>

#include <caldataexchange.h>

#include <caldataformat.h>

#include <calsession.h>

#include <calcalendarinfo.h>

#include <calprogresscallback.h>

#include <e32test.h>

#include <consolealarmalertservermain.h>

#include <e32math.h>

#include <caliterator.h>

#include <s32file.h>

#include <ecom/ecom.h>

#include <caldataformat.h>

#include <calinstance.h>

#include <s32mem.h>

#include <e32std.h>

#ifdef __WINS__

const TUid KServerUid2 = {0x1000008D};

const TUid KServerUid3 = {0x101F502A};

_LIT(KConsoleAlarmAlertServerImg, "ConsoleAlarmAlertServer");	

#endif // __WINS__

_LIT(KCalTestLibRefCountChunkName, "CalTestLibRefCount");

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

 * Constructor/Destructor

 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

EXPORT_C CCalTestLibrary* CCalTestLibrary::NewLC(TBool aDelFileFlag)

	{

	CCalTestLibrary* self = new (ELeave) CCalTestLibrary(aDelFileFlag);

	CleanupStack::PushL(self);

	self->BaseConstructL();

	return (self);

	}

EXPORT_C CCalTestLibrary* CCalTestLibrary::NewL(TBool aDelFileFlag)

	{

	CCalTestLibrary* self = NewLC(aDelFileFlag);

	CleanupStack::Pop(self);

	return (self);

	}

// protected

EXPORT_C CCalTestLibrary::CCalTestLibrary(TBool aDelFileFlag) : iDelFileFlag(aDelFileFlag)

	{

	TTime now;

	now.UniversalTime();

	iSeed = now.Int64();

	}

// protected

EXPORT_C void CCalTestLibrary::BaseConstructL()

	{

	#if __WINS__

		StartAlarmServerL();

	#endif

	User::LeaveIfError(iFs.Connect());

	if (iChunkMutex.OpenGlobal(KCalTestLibMutex) != KErrNone)

		{

		User::LeaveIfError(iChunkMutex.CreateGlobal(KCalTestLibMutex)) ;

		}

	TInt createChunkError = iChunk.CreateGlobal(KCalTestLibRefCountChunkName, sizeof(TInt), sizeof(TInt));

	iChunk.OpenGlobal(KCalTestLibRefCountChunkName, EFalse);

	iRefCount = reinterpret_cast<TInt*>(iChunk.Base());

	TBool refExists = ETrue;

	if (createChunkError != KErrAlreadyExists)

		{

		refExists = EFalse;	

		}

	OpenCalendarSessionL(refExists);

	iFilesToDel = new(ELeave) CDesCArrayFlat(5);

	User::LeaveIfError(iPIMTestServer.Connect());

	SetTimeZoneL(KDefaultTimeZone);

	iTestRegister = CTestRegister::NewL();

	User::LeaveIfError(iAlarmServer.Connect());

	}

void CCalTestLibrary::OpenCalendarSessionL(TBool aRefCountExists)

	{

	iChunkMutex.Wait();

	iSession = CCalSession::NewL();

	if (aRefCountExists)

		{

		++*iRefCount;

		}

	else

		{

		*iRefCount = 1;

		}

	iChunkMutex.Signal();

	}

void CCalTestLibrary::CloseCalendarSession(TBool aWaitForAgendaToClose)

	{

	iChunkMutex.Wait();

	iSubCalSessions.ResetAndDestroy();

	delete iSession;

	iSession = NULL;	

	if (iRefCount && (--*iRefCount <= 0) && aWaitForAgendaToClose)

		{

		WaitForAgendaServerClose();

		}

	iChunkMutex.Signal();

	}

EXPORT_C void CCalTestLibrary::WaitForAgendaServerClose()

	{

	// This is the last time we are closing the cal test library	

	// So wait for the agenda server process to finish

	// Make sure any ecom sessions are destroyed before waiting for the agenda server to close

	REComSession::FinalClose();

	// the name of the agenda server process includes its uid like this [10003a5b]

	TFindProcess findProcess(_L("*[10003a5b]*"));

	TFullName fullName;

	TInt findProcessResult = findProcess.Next(fullName);

	if (findProcessResult == KErrNone)

		{

		// find the latest agenda server process

		while (findProcessResult == KErrNone)

			{

			findProcessResult = findProcess.Next(fullName);

			}

		// the agenda server process is running so wait 

		RProcess process;

		if (process.Open(fullName) == KErrNone)

			{

			RTimer timeoutTimer;

			timeoutTimer.CreateLocal();

			TRequestStatus timeoutTimerStatus;

			timeoutTimer.After(timeoutTimerStatus, 10000000); // 10 seconds

			TRequestStatus processStatus;

			process.Logon(processStatus); // ask for a callback when the process ends

			User::WaitForRequest(processStatus, timeoutTimerStatus);

			if (timeoutTimerStatus.Int() == KRequestPending)

				{

				// the process ended so cancel the timeout timer

				timeoutTimer.Cancel();

				User::WaitForRequest(timeoutTimerStatus);

				}

			else if (processStatus.Int() == KRequestPending)

				{

				process.LogonCancel(processStatus);

				User::WaitForRequest(processStatus);

				}

			process.Close();

			}

		}

	}

EXPORT_C void CCalTestLibrary::CloseAgendaServer()

	{

	delete iDataExchange;

	iDataExchange = NULL;

	delete iIter;

	iIter = NULL;;

	delete iInstanceView;

	iInstanceView = NULL;;

	delete iEntryView;

	iEntryView = NULL;;

	CloseCalendarSession();

	}

EXPORT_C void CCalTestLibrary::ConnectAgendaServerL()

	{

	if (!iSession)

		{

		OpenCalendarSessionL();		

		}

	}

EXPORT_C CCalTestLibrary::~CCalTestLibrary()

	{

	// Delete created files

	if(iDelFileFlag && iFilesToDel)

		{

		for(TInt i = 0; i < iFilesToDel->Count(); ++i)

			{

			TRAP_IGNORE(iSession->DeleteCalFileL((*iFilesToDel)[i]));

			}

		// Empty the file list:

		iFilesToDel->Reset();

		}

	delete iFilesToDel;

	delete iDataExchange;

	iPIMTestServer.Close();

	delete iIter;

	delete iInstanceView;

	delete iEntryView;

	delete iTestRegister;

	iFs.Close();

	if (iChunkMutex.IsHeld())

		{

		iChunkMutex.Signal();

		}

	CloseCalendarSession();

	iChunkMutex.Close();

	iChunk.Close();

	iAlarmServer.Close();

	}

EXPORT_C CTestRegister& CCalTestLibrary::TestRegister()

	{

	return *iTestRegister;

	}

#if __WINS__

EXPORT_C void CCalTestLibrary::StartAlarmServerL()

	{

	TInt findProcessResult(KErrNone);

	// the name of the console alarm alert server process includes its uid like this [101F502A]

	_LIT(KAlarmServerUIDMatch, "*[101F502A]*");

	TFindProcess findProcess(KAlarmServerUIDMatch);

	TFullName fullName;

	findProcessResult = findProcess.Next(fullName);

	if (findProcessResult != KErrNone)

		{

		// The console alarm alert server process is not running. Start it

		const TUidType serverUid(KNullUid, KServerUid2, KServerUid3);

		RProcess alarmAlertServer;

		User::LeaveIfError(alarmAlertServer.Create(KConsoleAlarmAlertServerImg, KNullDesC, serverUid));

		TRequestStatus stat;

		alarmAlertServer.Rendezvous(stat);

		if (stat != KRequestPending)

			{

			alarmAlertServer.Kill(0);

			}

		else

			{

			alarmAlertServer.Resume();	// logon OK - start the server

			}

		alarmAlertServer.Close();

		User::WaitForRequest(stat);

		TInt result = stat.Int();

		if(result != KErrNone && result != KErrAlreadyExists)

			{

			User::LeaveIfError(result);	

			}

		}

	}

#endif // __WINS__

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

 * Implementation of MCalProgressCallBack interface

 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

void CCalTestLibrary::Progress(TInt /*aPercentageCompleted*/)

	{

	}

void CCalTestLibrary::Completed(TInt aError)

	{

	CActiveScheduler::Stop();

	iCompletedError = aError;

	}

TBool CCalTestLibrary::NotifyProgress()

	{

	return (EFalse);

	}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

 * File handling

 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

EXPORT_C RFs& CCalTestLibrary::FileSession()

	{

	return (iFs);

	}

EXPORT_C void CCalTestLibrary::RegisterCalFileL(const TDesC& aFileName)

	{

	TInt pos=-1;

	if(iDelFileFlag)

		{

		if(iFilesToDel->Find(aFileName,pos)!=0) 

			{

			iFilesToDel->AppendL(aFileName);

			}

		}

	}

EXPORT_C void CCalTestLibrary::CreateFileL(const TDesC& aFileName)

	{

	iSession->CreateCalFileL(aFileName);

	TInt pos=-1;

	if(iDelFileFlag)

		{

		if(iFilesToDel->Find(aFileName, pos)!=0)	

			{

			iFilesToDel->AppendL(aFileName);

			}

		}

	}

EXPORT_C void CCalTestLibrary::ReplaceFileL(const TDesC& aFileName)

	{

	TRAPD(err, CreateFileL(aFileName));

	if (err == KErrAlreadyExists)

		{

		DeleteFileL(aFileName);

		CreateFileL(aFileName);

		}

	else

		{

		User::LeaveIfError(err);

		}

	}

EXPORT_C void CCalTestLibrary::OpenFileL(const TDesC& aFileName, TBool aDelFileFlag) 

	{

	delete iDataExchange;

	iDataExchange = NULL;

	delete iIter;

	iIter = NULL;	

	delete iEntryView;

	iEntryView = NULL;

	delete iInstanceView;

	iInstanceView = NULL;

	CloseCalendarSession(EFalse);

	OpenCalendarSessionL();

	iSession->OpenL(aFileName);

	TInt pos=-1;

	if( iDelFileFlag && aDelFileFlag )

		{

		if( iFilesToDel->Find(aFileName, pos)!=0 )

			{

			iFilesToDel->AppendL(aFileName);

			}

		}

	}

EXPORT_C void CCalTestLibrary::DeleteFileL(const TDesC& aFileName, TBool aIsCalFile)

	{

	if (!iSession) // some tests call CloseAgendaServer

		{

		OpenCalendarSessionL();	

		}

	if (aIsCalFile)

		{

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

		    {

		    CCalCalendarInfo* info = iSubCalSessions[i]->CalendarInfoL();

		    HBufC* fileName = info->FileNameL().AllocLC();

		    delete info;

		    iSubCalSessions[i]->DeleteCalFileL(*fileName);

		    CleanupStack::PopAndDestroy(fileName);

		    }

		iSession->DeleteCalFileL(aFileName);

		TInt indx=-1;

		if(iDelFileFlag)

			{

			if(iFilesToDel->Find(aFileName, indx)==0)

				{

				iFilesToDel->Delete(indx,1);

				}

			}

		}

		else

			{

			iPIMTestServer.DeleteFileL(aFileName);

			}

	}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

 * Session and Views handling

 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

EXPORT_C CCalSession& CCalTestLibrary::GetSession()

	{

	// the pointyer is never NULL because the object is created in NewL...

	return (*iSession);

	}

EXPORT_C CCalEntryView& CCalTestLibrary::AsynCGetEntryViewL()

	{

	//The caller should expect the completion in their RunL

	if (!iEntryView)

		{

		iEntryView = CCalEntryView::NewL(*iSession, *this);

		}

	return (*iEntryView);

	}

EXPORT_C CCalInstanceView& CCalTestLibrary::AsynCGetInstanceViewL()

	{

	if (!iInstanceView)

		{

		iInstanceView = CCalInstanceView::NewL(*iSession, *this);

		}

	return (*iInstanceView);

	}

EXPORT_C CCalInstanceView& CCalTestLibrary::SynCGetInstanceViewL()

	{

	if (!iInstanceView)

		{

		iInstanceView = CCalInstanceView::NewL(*iSession);

		}

	return (*iInstanceView);

	}

EXPORT_C CCalEntryView& CCalTestLibrary::SynCGetEntryViewL()

	{

	if (!iEntryView)

		{

		iEntryView = CCalEntryView::NewL(*iSession);

		}

	return (*iEntryView);

	}

EXPORT_C void CCalTestLibrary::DeleteViews()

	{

	delete iInstanceView;

	iInstanceView = NULL;

	delete iEntryView;

	iEntryView = NULL;

	delete iIter;

	iIter = NULL;

	delete iDataExchange;

	iDataExchange = NULL;

	}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

 * Entry handling

 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

EXPORT_C CCalEntry* CCalTestLibrary::CreateCalEntryL(CCalEntry::TType aType, HBufC8*& aUid)

	{

	HBufC8* uid = NULL;

	if (aUid)

		{

		uid = aUid;

		}

	else

		{

		uid = HBufC8::NewLC(255);

		TPtr8 uidP = uid->Des();

		RandomText8(uidP);

		}

	CCalEntry* entry = CCalEntry::NewL(aType, uid, CCalEntry::EMethodAdd, 0);

	if (!aUid)

		{

		CleanupStack::Pop(uid);

		}

	aUid = uid;

	return (entry);

	}

EXPORT_C void CCalTestLibrary::SetEntryStartAndEndTimeL(CCalEntry* aEntry, const TTime& aStartTime, const TTime& aEndTime, TInt aYear)

	{