// Copyright (c) 2005-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 "SERVER.H"

 #include "BackGroundCompression.h"

 _LIT(KFbsBgCompThrdName, "FbsBgCompressThread");

 const TInt KFbsBgCompThrdStackSize = 4096;

 CFbsBackgroundCompressionQueueElement::CFbsBackgroundCompressionQueueElement(CBitmapObject* aSrcObj, TBitmapfileCompressionScheme aScheme):

 	iSourceObject(aSrcObj),

 	iCompressionScheme(aScheme)

 	{

 	__ASSERT_DEBUG(aSrcObj->iCompressionQueueElement == NULL, User::Invariant());

 	aSrcObj->iCompressionQueueElement = this;

 	}

 CFbsBackgroundCompressionQueueElement::~CFbsBackgroundCompressionQueueElement()

 	{

 	iLink.Deque();

 	iSourceObject->iCompressionQueueElement = NULL;

 	if (!iMessage.IsNull())

 		iMessage.Complete(KErrNone);

 	}

 void CFbsBackgroundCompressionQueueElement::CompleteOutstandingRequestAndDestroy(TInt aReason)

 	{

 	if (!iMessage.IsNull())

 		iMessage.Complete(aReason);

 	delete this;

 	}

 void CFbsBackgroundCompressionQueueElement::CompleteOutstandingRequest(const CSession2* aSession)

 	{

 	if (!iMessage.IsNull() && iMessage.Session() == aSession)

 		iMessage.Complete(KErrDisconnected);

 	}

 CFbsBackgroundCompression* CFbsBackgroundCompression::NewL(CFbTop& aFbTop)

 	{

 	CFbsBackgroundCompression* self = new(ELeave) CFbsBackgroundCompression(aFbTop);

 	CleanupStack::PushL(self);

 	self->ConstructL();

 	CleanupStack::Pop(self);

 	return self;

 	}

 CFbsBackgroundCompression::CFbsBackgroundCompression(CFbTop& aFbTop):

 	CActive(CActive::EPriorityIdle),

 	iFbTop(aFbTop),

 	iCompressionQueue(_FOFF(CFbsBackgroundCompressionQueueElement, iLink))

 	{

 	CActiveScheduler::Add(this);

 	}

 void CFbsBackgroundCompression::ConstructL()

 	{

 	TThreadCreateInfo threadCreateInfo(KFbsBgCompThrdName, (TThreadFunction)ThreadFunction, KFbsBgCompThrdStackSize, this);

 	threadCreateInfo.SetUseHeap(NULL);

 	threadCreateInfo.SetOwner(EOwnerProcess);

 	threadCreateInfo.SetPaging(TThreadCreateInfo::EUnspecified); //Use the creating process's paging attributes.

 	User::LeaveIfError(iThread.Create(threadCreateInfo));

 	iThreadCreated = ETrue;

 	iThread.SetPriority(EPriorityAbsoluteVeryLow);

 	User::LeaveIfError(iThreadGo.CreateLocal(0));

 	User::LeaveIfError(iThreadMutex.CreateLocal());

 	iThread.Resume();

 	}

 CFbsBackgroundCompression::~CFbsBackgroundCompression()

 	{

 	// destructor should be called only after all sessions with the server have been closed

 	// so there should not be any bitmap objects left

 	__ASSERT_DEBUG(iCompressionQueue.IsEmpty(), User::Invariant());

 	__ASSERT_DEBUG(iBitmapObject == NULL, User::Invariant());

 	if (iThreadCreated)

 		{

 		iThread.Kill(KErrNone);

 		iThread.Close();

 		iThreadGo.Close();

 		iThreadMutex.Close();

 		}

 	}

 TInt CFbsBackgroundCompression::AddToCompressionQueue(CBitmapObject* aSrcObj, TBitmapfileCompressionScheme aScheme, const RMessage2* aMessage)

 	{

 	__ASSERT_DEBUG(aSrcObj != NULL, User::Invariant());

 	CFbsBackgroundCompressionQueueElement* element = new CFbsBackgroundCompressionQueueElement(aSrcObj, aScheme);

 	if (element == NULL)

 		return KErrNoMemory;

 	iCompressionQueue.AddLast(*element);

 	if (!IsActive())

 		{

 		TInt ret = PrepareCompression();

 		if (ret != KErrNone)

 			{

 			delete element;

 			return ret;

 			}

 		SetActive();

 		iThread.Rendezvous(iStatus);

 		iThreadGo.Signal();

 		}

 	if (aMessage != NULL)

 		element->iMessage = *aMessage;

 	return KErrNone;

 	}

 void CFbsBackgroundCompression::RemoveFromCompressionQueue(CBitmapObject* aSrcObj)

 	{

 	__ASSERT_DEBUG(aSrcObj != NULL, User::Invariant());

 	CFbsBackgroundCompressionQueueElement* element = aSrcObj->iCompressionQueueElement;

 	if (element != NULL)

 		{

 		if (iBitmapObject != NULL && iCompressionQueue.IsFirst(element))

 			{

 			iThreadMutex.Wait();

 			iBitmapObject->Close();

 			iBitmapObject = NULL;

 			iThreadMutex.Signal();

 			}

 		delete element;

 		}

 	}

 void CFbsBackgroundCompression::CompleteOutstandingRequests(const CSession2* aSession)

 	{

 	TDblQueIter<CFbsBackgroundCompressionQueueElement> iterator(iCompressionQueue);

 	CFbsBackgroundCompressionQueueElement* element;

 	while ((element = iterator++) != NULL)

 		element->CompleteOutstandingRequest(aSession);

 	}

 void CFbsBackgroundCompression::CompressAll()

 	{

 	if (iBitmapObject != NULL) // check if a compression is in progress

 		{

 		User::WaitForRequest(iStatus);

 		FinalizeCompression(iStatus);

 		TRequestStatus* status = &iStatus;

 		User::RequestComplete(status, KErrCompletion);

 		}

 	while (!iCompressionQueue.IsEmpty())

 		{

 		TInt ret = PrepareCompression();

 		if (ret != KErrNone)

 			{

 			iCompressionQueue.First()->CompleteOutstandingRequestAndDestroy(ret);

 			continue;

 			}

 		TRequestStatus status;

 		iThread.Rendezvous(status);

 		iThreadGo.Signal();

 		User::WaitForRequest(status);

 		FinalizeCompression(status);

 		}

 	}

 TInt CFbsBackgroundCompression::PrepareCompression()

 	{

 	__ASSERT_DEBUG(!iCompressionQueue.IsEmpty(), User::Invariant());

 	__ASSERT_DEBUG(iBitmapObject == NULL, User::Invariant());

 	CFbsBackgroundCompressionQueueElement* element = iCompressionQueue.First();

 	CBitwiseBitmap* srcBmp = element->iSourceObject->Address();

 	CBitmapObject* bmpObj = NULL;

 	TRAPD(ret, bmpObj = iFbTop.CreateBitmapL(srcBmp->SizeInPixels(), srcBmp->DisplayMode(), KUidCFbsBitmapCreation, ETrue));

 	if (ret != KErrNone)

 		return ret;

 	ret = bmpObj->Address()->CopyData(*srcBmp);

 	if (ret != KErrNone)

 		{

 		bmpObj->Close();

 		return ret;

 		}

 	iThreadMutex.Wait();

 	iBitmapObject = bmpObj;

 	iCompressionScheme = element->iCompressionScheme;

 	iThreadMutex.Signal();

 	return KErrNone;

 	}

 void CFbsBackgroundCompression::FinalizeCompression(const TRequestStatus& aStatus)

 	{

 	__ASSERT_DEBUG(!iCompressionQueue.IsEmpty(), User::Invariant());

 	__ASSERT_DEBUG(iBitmapObject != NULL, User::Invariant());

 	iThreadMutex.Wait();

 	CFbsBackgroundCompressionQueueElement* element = iCompressionQueue.First();

 	if (aStatus == KErrNone)

 		{

 		element->iSourceObject->SetCleanBitmap(iBitmapObject);

 		iFbTop.NotifyDirtyBitmap(*element->iSourceObject, NULL);

 		}

 	else

 		{

 		iBitmapObject->Close();

 		}

 	iBitmapObject = NULL;

 	element->CompleteOutstandingRequestAndDestroy(aStatus.Int());

 	iThreadMutex.Signal();

 	}

 void CFbsBackgroundCompression::RunL()

 	{

 	// check if CompressAll() or RemoveFromCompressionQueue() have been called before

 	if (iBitmapObject != NULL)

 		{

 		FinalizeCompression(iStatus);

 		}

 	while (!iCompressionQueue.IsEmpty())

 		{

 		TInt ret = PrepareCompression();

 		if (ret == KErrNone)

 			{

 			SetActive();

 			iThread.Rendezvous(iStatus);

 			iThreadGo.Signal();

 			return;

 			}

 		iCompressionQueue.First()->CompleteOutstandingRequestAndDestroy(ret);

 		}

 	}

 void CFbsBackgroundCompression::DoCancel()

 	{

 	iThread.RendezvousCancel(iStatus);

 	}

 TInt CFbsBackgroundCompression::ThreadFunction(CFbsBackgroundCompression* aSelf)

 	{

 	TBool notDone = ETrue; // to suppress compiler warning

 	// coverity[dead_error_condition]

 	// coverity[loop_condition]

 	while (notDone)

 		{

 		aSelf->iThreadGo.Wait();

 		aSelf->iThreadMutex.Wait();

 		if (aSelf->iBitmapObject != NULL)

 			{

 			TInt ret = aSelf->iBitmapObject->Address()->CompressData(aSelf->iCompressionScheme);

 			RThread::Rendezvous(ret);

 			}

 		else

 			{

 			// bitmap removed from queue before background thread had a chance to compress it

 			RThread::Rendezvous(KErrAbort);

 			}

 		aSelf->iThreadMutex.Signal();

 		}

 	// coverity[dead_error_line]

 	return KErrNone;

 	}