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

 //

 // System includes

 #include <logwraplimits.h>

 #include <logwrap.h>

 #include <schtask.h>

 // User includes

 #include "SCHCLI.H"

 #include "SchLogger.h"

 #include "SCHEXEC.H"

 #include "SCHLOG.h"

 // Constants

 #define KEllipsis 0x2026

 const TInt KTaskArrayGranularity = 1;

 _LIT(KTaskNameSeparator, ", ");

 //

 // CClientProxy

 //

 CClientProxy::CClientProxy(RFs& aFsSession, CSchLogManager& aLogManager)

 :	iFsSession(aFsSession), 

 	iTasks(CScheduledTask::Offset()),

 	iSchLogManager(aLogManager)

 	{

 	}

 CClientProxy::CClientProxy(RFs& aFsSession, TInt aPriority, CSchLogManager& aLogManager)

 :	iFsSession(aFsSession), 

 	iTasks(CScheduledTask::Offset()),

 	iSchLogManager(aLogManager)

 	{

 	iPriLink.iPriority = aPriority;

 	}

 CClientProxy::~CClientProxy()

 	{

 	LOGSTRING("CClientProxy::~CClientProxy - start");

 	TDblQueIter<CScheduledTask> taskIter(iTasks);

 	taskIter.SetToFirst();

 	CScheduledTask* task;

 	while ((task = taskIter++) != NULL)

 		{

 		RemoveTask(task);

 		}

 	delete iFileName;

 	LOGSTRING("CClientProxy::~CClientProxy - end");

 	} 

 void CClientProxy::ConstructL(const TDesC& aFileName)

 	{

 	iFileName = aFileName.AllocL();

 	}

 CClientProxy* CClientProxy::NewL(RFs& aFsSession, 

 								const TDesC& aFileName, 

 								TInt aPriority,

 								CSchLogManager& aLogManager)

 	{

 	CClientProxy* self = new(ELeave) CClientProxy(aFsSession, aPriority,aLogManager);

 	CleanupStack::PushL(self);

 	self->ConstructL(aFileName);

 	CleanupStack::Pop();

 	return self;

 	}

 CClientProxy* CClientProxy::NewL(RFs& aFsSession, 

 								RReadStream& aStream,

 								CSchLogManager& aLogManager)

 	{

 	CClientProxy* self = new(ELeave) CClientProxy(aFsSession,aLogManager);

 	CleanupStack::PushL(self);

 	aStream >> *self;

 	CleanupStack::Pop();

 	return self;

 	}

 TBool CClientProxy::IsEqual(const TDesC& aFilename, TInt aPriority) const

 	{

 	// Equality here means: same DLL filename, DLL ordinal & priority

 	return ((*iFileName == aFilename) && (iPriLink.iPriority == aPriority));

 	}

 void CClientProxy::AddTask(CScheduledTask& aTask)

 	{

 	LOGSTRING("CClientProxy::AddTask - start");

 	iTasks.Add(aTask);

 	iUsers++;

 	LOGSTRING("CClientProxy::AddTask - end");

 	}

 void CClientProxy::RemoveTask(CScheduledTask* aTask)

 	{

 	LOGSTRING("CClientProxy::RemoveTask - start");

 	iUsers--;

 	aTask->Remove();

 	delete aTask;

 	LOGSTRING("CClientProxy::RemoveTask - end");

 	}

 //

 static void BuildTaskErrorMessage(const CArrayPtr<CScheduledTask>& aTasks, TDes& aErrorMessage)

 //

 //	Establish the names of all the tasks that potentially might fail

 //	when executing the task. This is done *before* actually executing the

 //	tasks as its not possible to discern (at failure time) which tasks

 //	were actually executing (because we don't know at what time the task

 //	executor was spawned).

 //

 	{

 	const TInt count = aTasks.Count();

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

 		{

 		const TDesC& taskName = aTasks.At(i)->Info().iName;

 		if	(aErrorMessage.Length() + taskName.Length() > KLogMaxSubjectLength - KTaskNameSeparator().Length())

 			{

 			// The task name that still needs adding to the subject line (of the

 			// log entry) is too big to fit within KLogCallEventTypeUid characters.

 			// Trim the task name so that it will fit, and append the ellipsis

 			// character to indicate that more tasks were present but unable to be

 			// shown.

 			TInt lengthOfTaskNameToAccept = (KLogMaxSubjectLength - aErrorMessage.Length()) - KTaskNameSeparator().Length();

 			if	(lengthOfTaskNameToAccept <= 0)

 				break;

 			aErrorMessage += taskName.Left(lengthOfTaskNameToAccept);

 			aErrorMessage.Append(KEllipsis);

 			// Exit the 'for' loop as there isn't any more room to hold subsequent

 			// tasks that potentially failed...

 			break;

 			}

 		else

 			{

 			aErrorMessage += taskName;

 			}

 		if	(i<count-1) // not the last taskName

 			{

 			// Append a comma

 			aErrorMessage += KTaskNameSeparator;

 			}

 		}

 	}

 void CClientProxy::ExecuteTasks()

 	{

 	// generate an array of due tasks

 	CArrayPtr<CScheduledTask>* tasks = NULL;

 	TRAPD(err, tasks = DueTasksL());

 	if(err)

 		{

 		iSchLogManager.LogError(err);

 		return;

 		}

 	// Create the task error message, just in case an error occurs

 	TBuf<KLogMaxSubjectLength> errorMessage;

 	BuildTaskErrorMessage(*tasks, errorMessage);

 	TInt error =DoExecuteTasks(*tasks, errorMessage);

 	if(error)

 		iSchLogManager.LogError(errorMessage,error);

 	delete tasks;

 	}

 TInt CClientProxy::DoExecuteTasks(const CArrayPtr<CScheduledTask>& aTasks,

 									const TDesC& aErrorMessage)

 	{

 	// Generate a unique task name

 	TTime timenow;

 	timenow.UniversalTime();

 	TBuf<24> filename; // 20 is the longest decimal char length of a 64-bit number + 4 for extension

 	filename.Format(_L("%Ld.tmp"),timenow.Int64());

 	// Save & perform execution

 	TRAPD(error, DoExecuteTasksL(aTasks, filename, aErrorMessage));

 	if (error != KErrNone)

 		{

 		LOGSTRING2("CClientProxy::ExecuteTasksL - attempted to execute tasks, error was %d", error);

 		// Cleanup the file that was created if the execution fails in any way. Note

 		// that it might not have been created

 		// If a debug build - record error

 		TInt fileDeleteErr=iFsSession.Delete(filename);

 		if (fileDeleteErr != KErrNone)

 			{

 			LOGSTRING2("CClientProxy::DoExecuteTasks - Failed to delete file. Error = %d", fileDeleteErr);

 			}

 		}

 	return error;

 	}

 void CClientProxy::DoExecuteTasksL(const CArrayPtr<CScheduledTask>& aTasks, 

 									const TDesC& aFileName,

 									const TDesC& aErrorMessage)

 	{

 	// Save the tasks to disk

 	SaveTasksToFileL(aTasks, aFileName);

 	// Spawn the task executor active object (deletes itself upon completion)

 	CTaskExecutor* executor = CTaskExecutor::NewLC(aErrorMessage,aFileName,*iFileName,iSchLogManager);

 	executor->ExecuteL();

 	CleanupStack::Pop(executor);

 	// Don't delete executor here as it does it itself once 

 	// the task has finished (delete this in its RunL() )

 	}

 CArrayPtr<CScheduledTask>* CClientProxy::DueTasksL()

 //

 //	Returns a copy of any due tasks

 //

 	{

 	CArrayPtrFlat<CScheduledTask>* tasks = new(ELeave)CArrayPtrFlat<CScheduledTask> (KTaskArrayGranularity);

 	CleanupStack::PushL(tasks);

 	TDblQueIter<CScheduledTask> taskIter(iTasks);

 	taskIter.SetToFirst();

 	CScheduledTask* task;

 	while ((task=taskIter++)!=NULL)

 		{

 		if (task->Due())

 			{

 			tasks->AppendL(task);

 			}

 		}

 	CleanupStack::Pop(tasks);

 	return tasks;

 	}

 CFileStore* CClientProxy::CreateStoreL(const TDesC& aName,TUint aFileMode)

 //

 //	To make the code clearer - called within a trap frame that shouldn't leave anything 

 //	on cleanup stack.

 //

 	{

 	CFileStore* store = CDirectFileStore::CreateLC(iFsSession, aName, aFileMode);

 	CleanupStack::Pop(store);

 	return store;

 	}

 void CClientProxy::SaveTasksToFileL(const CArrayPtr<CScheduledTask>& aTasks, const TDesC& aFileName)

 	{

 	LOGSTRING("CClientProxy::SaveTasksToFileL - start");

 	// Create the file store

 	LOGSTRING("CClientProxy::SaveTasksToFileL - creating store");

 	CFileStore* store = CreateStoreL(aFileName, EFileWrite);

 	CleanupStack::PushL(store);

 	// Save the actual tasks to the store

 	LOGSTRING("CClientProxy::SaveTasksToFileL - saving tasks");

 	SaveTasksL(*store, aTasks);

 	CleanupStack::PopAndDestroy(store);

 	LOGSTRING("CClientProxy::SaveTasksToFileL - end");

 	}

 void CClientProxy::SaveTasksL(CFileStore& aStore, const CArrayPtr<CScheduledTask>& aTasks)

 	{

 	LOGSTRING("CClientProxy::SaveTasksL - start");

 	aStore.SetTypeL(KDirectFileStoreLayoutUid);	

 	// Save the tasks

 	RStoreWriteStream outstream;

 	TStreamId id = outstream.CreateLC(aStore);

 	const TInt count = aTasks.Count();

 	LOGSTRING2("CClientProxy::SaveTasksL - saving %d tasks", count);

 	outstream.WriteInt32L(count);

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

 		{

 		CScheduledTask* task = aTasks.At(i);

 		task->ExternalizeL(outstream);

 		} 

 	outstream.CommitL();

 	CleanupStack::PopAndDestroy(); // outstream

 	aStore.SetRootL(id);							

 	aStore.CommitL();							

 	LOGSTRING("CClientProxy::SaveTasksL - end");

 	}

 void CClientProxy::RemoveDueTasks()

 	{

 	LOGSTRING("CClientProxy::RemoveDueTasks - start");

 	TDblQueIter<CScheduledTask> taskIter(iTasks);

 	taskIter.SetToFirst();

 	CScheduledTask* task;

 	//

 	while ((task=taskIter++)!=NULL)

 		{

 		if (task->Due())

 			{

 			LOGSTRING3("CClientProxy::RemoveDueTasks - found due task %S, %d", &task->Info().iName, task->Info().iTaskId);

 			if	(!task->Info().iRepeat)

 				{

 				LOGSTRING("CClientProxy::RemoveDueTasks - task has no repeats left - it's being removed");

 				RemoveTask(task);

 				}

 			else

 				{

 				LOGSTRING("CClientProxy::RemoveDueTasks - task still has some repeats, setting as 'no longer due'");

 				task->SetDue(EFalse);

 				}

 			}

 		}

 	iReadyToExecute = EFalse;

 	LOGSTRING("CClientProxy::RemoveDueTasks - end");

 	}

 void CClientProxy::TransferTasks(CClientProxy& aTargetClient)

 	{

 	TDblQueIter<CScheduledTask> taskIter(iTasks);

 	taskIter.SetToFirst();

 	CScheduledTask* task;

 	while ((task=taskIter++)!=NULL)

 		{

 		task->Remove();

 		aTargetClient.AddTask(*task);

 		}

 	}

 void CClientProxy::InternalizeL(RReadStream& aReadStream)

 	{

 	LOGSTRING("CClientProxy::InternalizeL - start");

 	HBufC* fileName = HBufC::NewL(aReadStream, KMaxFileName);

 	delete iFileName;

 	iFileName = fileName;

 	//

 	iPriLink.iPriority = aReadStream.ReadInt32L();

 	const TInt count = aReadStream.ReadInt32L();

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

 		{

 		CScheduledTask* task = CScheduledTask::NewLC(aReadStream);

 		AddTask(*task);

 		CleanupStack::Pop(task);

 		}

 	LOGSTRING("CClientProxy::InternalizeL - end");

 	}

 void CClientProxy::ExternalizeL(RWriteStream& aWriteStream) const

 	{

 	LOGSTRING("CClientProxy::ExternalizeL - start");

 	aWriteStream << *iFileName;

 	aWriteStream.WriteInt32L(iPriLink.iPriority);

 	TDblQueIter<CScheduledTask> taskIter(const_cast<CClientProxy*>(this)->iTasks);

 	taskIter.SetToFirst();

 	CScheduledTask* task;

 	// Count tasks

 	TInt count = 0;

 	while ((task=taskIter++)!=NULL)

 		{

 		if(task->Persists())

 			{	

 			count++;

 			}

 		}

 	// Store leading count

 	aWriteStream.WriteInt32L(count);

 	// Store tasks

 	taskIter.SetToFirst();

 	while ((task=taskIter++)!=NULL)

 		{

 		if(task->Persists())

 		  {

 		  aWriteStream << *task;

 		  }

 		}

 	LOGSTRING("CClientProxy::ExternalizeL - end");

 	}

 TDblQueIter<CScheduledTask> CClientProxy::TaskIterator()

 	{

 	return TDblQueIter<CScheduledTask>(iTasks);

 	}