// Copyright (c) 2008-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 "imageprocessorcallback.h"
#include <imageprocessor/imageprocessor.h>
#include <imageprocessor/imageprocessorobserver.h>

using namespace ImageProcessor;
	
//Free slots allocated to ensure there is enough memory for future callbacks
const TInt KCallbackReserveSlots = 20;

CImageProcessorCallback* CImageProcessorCallback::NewL(CImgProcessor& aImageProcessor,MImgProcessorObserver& aObserver)
	{
	CImageProcessorCallback* self = new (ELeave) CImageProcessorCallback(aImageProcessor,aObserver);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop(self);
	return self;
	}

CImageProcessorCallback::CImageProcessorCallback(CImgProcessor& aImageProcessor,MImgProcessorObserver& aObserver):
   CActive(EPriorityNormal),iProcessor(aImageProcessor),iObserver(aObserver)
	{
	CActiveScheduler::Add(this);
	}

void CImageProcessorCallback::ConstructL()
	{
	iCallbackInfo.ReserveL(KCallbackReserveSlots);
	}

CImageProcessorCallback::~CImageProcessorCallback()
	{
	__ASSERT_ALWAYS(!IsActive(),Cancel());
	iCallbackInfo.Close();
	}

void CImageProcessorCallback::AddCallback(TInt aEventId, TUid aUid, TInt aId, TInt aError)
	{
	TInt err = iCallbackInfo.Append(TCallbackInfo(aEventId, aUid, aId, aError));
	if (err == KErrNoMemory) 
		{
		iCallbackInfo.Reset();
		// try to reserve few slots
		iCallbackInfo.Reserve(KCallbackReserveSlots);
		iCallbackInfo.Append(TCallbackInfo(aEventId, aUid, aId, KErrNoMemory));
		iProcessor.Cancel();
		}
	SelfComplete();
	}

void CImageProcessorCallback::SelfComplete()
	{
	//Only activate if a request is not already outstanding,
	//else it will be activated from RunL()
	if(!IsActive())
		{
		TRequestStatus* request = &iStatus;
		User::RequestComplete(request,KErrNone);
		SetActive();
		}
	}
   
void CImageProcessorCallback::RunL()
	{
	if(iCallbackInfo.Count())
		{
		//Any properies that need to be modified has to be done before the
		//callbacks. The client may delete the Image Processor in the callback
		const TCallbackInfo info(iCallbackInfo[0]);
		iCallbackInfo.Remove(0);
		EnsureSpace();

		//More requests in the queue
		__ASSERT_ALWAYS(!iCallbackInfo.Count(),SelfComplete());

		switch(info.iEventId)
			{
			case CImgProcessor::EEventInitializingComplete:
		   		iObserver.ImageProcessorInitializingComplete(iProcessor, info.iError);
		   		break;

			case CImgProcessor::EEventPreviewInitializingComplete:
				iObserver.ImageProcessorPreviewInitializingComplete(iProcessor, info.iId, info.iError);
		   		break;
		   
			case CImgProcessor::EEventProcessingComplete:
		   		iObserver.ImageProcessingComplete(iProcessor, info.iError);
		   		break;
		   	
			case CImgProcessor::EEventPreviewRenderingComplete:
		   		iObserver.ImageProcessorPreviewRenderingComplete(iProcessor, info.iId, info.iError);
		   		break;
		   	
			default:
		   		iObserver.ImageProcessorEvent(iProcessor, info.iEventId, info.iUid, info.iId);
			}
		}
	}
   
void CImageProcessorCallback::DoCancel()
	{
	}

void CImageProcessorCallback::EnsureSpace()
	{
	const TInt cnt(iCallbackInfo.Count());
   //Ignore error. Just a best effort attempt to ensure enough memory in future
   //Still have some space from granularity	
	iCallbackInfo.Reserve(cnt+KCallbackReserveSlots);
	}

CImageProcessorCallback::TCallbackInfo::TCallbackInfo(TInt aEventId, TUid aUid, TInt aId, TInt aError):
	iEventId(aEventId),
	iUid(aUid),
	iId(aId),
	iError(aError)
	{
	}
//EOF