--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/mmplugins/cameraplugins/source/testcamera/TestCamera.cpp	Tue Feb 02 01:56:55 2010 +0200
@@ -0,0 +1,1564 @@
+// Copyright (c) 2002-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 <w32std.h>
+#include <ecom/ecom.h>
+#include <ecom/implementationproxy.h>
+#include <f32file.h> 
+#include "TestCamera.h"
+#include "test_advanced_settings.h"
+#include "test_snapshot.h"
+#include "test_image_processing.h"
+#include "TestCameraUids.hrh"
+#include <ecam.h>
+
+//
+// Main stuff
+//
+// 
+// 2nd stage ConstructL calls called by framework
+//
+CTestCamera* CTestCamera::NewL()
+	{
+	FileDependencyUtil::CheckFileDependencyL();
+   	CTestCamera* self = new(ELeave) CTestCamera;
+	CleanupStack::PushL(self);
+	self->ConstructL();
+	CleanupStack::Pop(self);
+	return self;
+	}
+
+void CTestCamera::Construct2L(MCameraObserver& aObserver,TInt aCameraIndex)
+	{
+	iObserver = &aObserver;
+	iCameraIndex = aCameraIndex;
+	}
+	
+void CTestCamera::Construct2DupL(MCameraObserver& aObserver,TInt aCameraHandle)
+	{
+	iObserver = &aObserver;
+	iCameraHandle = aCameraHandle;
+	}
+
+void CTestCamera::ConstructL()	
+	{
+	
+	TInt err;
+	TRAP(err, iScreenDev = CFbsScreenDevice::NewL(_L(""),EColor16MA));
+	if (err == KErrNotSupported)
+		{
+		TRAP(err, iScreenDev = CFbsScreenDevice::NewL(_L(""),EColor16M));
+		}
+	if (err == KErrNotSupported)
+		{
+		TRAP(err, iScreenDev = CFbsScreenDevice::NewL(_L(""),EColor64K));
+		}
+	if (err == KErrNotSupported)
+		{
+		TRAP(err, iScreenDev = CFbsScreenDevice::NewL(_L(""),EColor4K));
+		}
+	if (err == KErrNotSupported)
+		{
+		TRAP(err, iScreenDev = CFbsScreenDevice::NewL(_L(""),EColor256));
+		}
+	if (err == KErrNotSupported)
+		{
+		iScreenDev = CFbsScreenDevice::NewL(_L(""),EColor16MAP);
+		}		
+	else
+		{
+		User::LeaveIfError(err);		
+		}
+
+	User::LeaveIfError(iScreenDev->CreateContext(iScreenGc));
+	User::LeaveIfError(iImageSizes.Append( TSize(640, 480) )); // VGA
+	User::LeaveIfError(iImageSizes.Append( TSize(160, 120) )); // QQVGA
+	iInfo.iNumImageSizesSupported = iImageSizes.Count();
+	iStillImageSize = iImageSizes[1]; // Defaults to QQVGA
+
+	User::LeaveIfError(iVideoFrameSizes.Append( TSize(176, 144) )); // QCIF
+	User::LeaveIfError(iVideoFrameSizes.Append( TSize(128, 96) ));  // subQCIF
+	iInfo.iNumVideoFrameSizesSupported = iVideoFrameSizes.Count();
+	User::LeaveIfError(iVideoFrameRates.Append( 10.00 ));
+	User::LeaveIfError(iVideoFrameRates.Append(  5.00 ));
+	User::LeaveIfError(iVideoFrameRates.Append(  1.00 ));
+	iInfo.iNumVideoFrameRatesSupported = iVideoFrameRates.Count();
+	iVideoFrameRate = iVideoFrameRates[0];
+	// Still image used as view finder source if not defined otherwise
+	iStillImage = new(ELeave) CFbsBitmap;
+	User::LeaveIfError(iStillImage->Create(iStillImageSize, KViewFinderDisplayMode));
+	iStillImageDev = CFbsBitmapDevice::NewL(iStillImage);
+	User::LeaveIfError(iStillImageDev->CreateContext(iStillImageGc));
+	iStillImageGc->SetPenColor(KRgbBlack);
+	iStillImageGc->SetPenSize(TSize(KFrameFeatureBorderThickness, KFrameFeatureBorderThickness));
+	iStillImageGc->SetBrushColor(KRgbWhite);
+	iStillImageGc->SetFaded(ETrue);
+	iVideoPreparedLast = EFalse;
+	iTimer = CPeriodic::NewL(CActive::EPriorityHigh);
+	}
+
+
+void CTestCamera::Construct2L(MCameraObserver2& aObserver,TInt aCameraIndex,TInt aPriority)
+	{
+	iObserver2 = &aObserver;
+	iCameraIndex = aCameraIndex;
+	iPriority = aPriority;
+	}
+	
+void CTestCamera::Construct2DupL(MCameraObserver2& aObserver,TInt aCameraHandle)
+	{
+	iObserver2 = &aObserver;
+	iCameraHandle = aCameraHandle;
+	}
+	
+
+CTestCamera::CTestCamera():
+	iStillImageFormat(KInitialViewFinderFormat),
+	iReserveAsync(CActive::EPriorityStandard),
+	iPowerOnAsync(CActive::EPriorityStandard),
+	iImageCaptureAsync(CActive::EPriorityStandard),
+	iVideoCaptureAsync(CActive::EPriorityStandard),
+	iHandleEventAsync(CActive::EPriorityStandard),
+	iHandleEvent2Async(CActive::EPriorityStandard),	
+	iFrameBuffer1(iVideoFrame1),
+	iFrameBuffer2(iVideoFrame2),
+	iFrameCameraBuffer1(iVideoFrame1),
+	iFrameCameraBuffer2(iVideoFrame2),
+	iContrast(0),
+	iBrightness(0),
+	iImgProcBrightness(0),
+	iImgProcContrast(0),
+	iVideoCaptureActive(EFalse),
+	iImageCaptureActive(EFalse),
+	iVideoPreparedLast(EFalse),
+	iVideoCapturePrepared(EFalse),
+	iImageCapturePrepared(EFalse),
+	iECamEvent(KNullUid, KErrNone),
+	iECamEvent2(KNullUid, KErrNone, 0),
+	iAdvSettingsImpl(NULL),
+	iSnapshotImpl(NULL),
+	iImgProcImpl(NULL),
+	iDriveMode(KDefaultDriveMode),
+	iBurstImages(KBurstImages)
+	{
+	TCallBack reserveCallBack(ReserveCallBack,this);
+	iReserveAsync.Set(reserveCallBack);
+	TCallBack powerOnCallBack(PowerOnCallBack,this);
+	iPowerOnAsync.Set(powerOnCallBack);
+	TCallBack imageCaptureCallBack(ImageCaptureCallBack,this);
+	iImageCaptureAsync.Set(imageCaptureCallBack);
+	TCallBack videoCaptureCallBack(VideoCaptureCallBack,this);
+	iVideoCaptureAsync.Set(videoCaptureCallBack);
+	TCallBack handleEventCallBack(HandleEventCallBack,this);
+	iHandleEventAsync.Set(handleEventCallBack);
+	TCallBack handleEvent2CallBack(HandleEvent2CallBack,this);
+	iHandleEvent2Async.Set(handleEvent2CallBack);
+
+	iInfo.iHardwareVersion.iMajor = 0;
+	iInfo.iHardwareVersion.iMinor = 0;
+	iInfo.iHardwareVersion.iBuild = 0;
+	iInfo.iSoftwareVersion.iMajor = 0;
+	iInfo.iSoftwareVersion.iMinor = 0;
+	iInfo.iSoftwareVersion.iBuild = 0;
+	iInfo.iOrientation = TCameraInfo::EOrientationOutwards;
+
+	iInfo.iOptionsSupported = 0;
+	iInfo.iOptionsSupported |= TCameraInfo::EViewFinderDirectSupported;
+	iInfo.iOptionsSupported |= TCameraInfo::EViewFinderBitmapsSupported;
+	iInfo.iOptionsSupported |= TCameraInfo::EImageCaptureSupported;
+	iInfo.iOptionsSupported |= TCameraInfo::EVideoCaptureSupported;
+	iInfo.iOptionsSupported |= TCameraInfo::EContrastSupported;
+	iInfo.iOptionsSupported |= TCameraInfo::EBrightnessSupported;
+	iInfo.iOptionsSupported |= TCameraInfo::EViewFinderClippingSupported;
+
+	iInfo.iFlashModesSupported = 0; // Bitfield of TFlash values
+	iInfo.iExposureModesSupported = 0; // Bitfield of TExposure values
+	iInfo.iWhiteBalanceModesSupported = 0; // Bitfield of TWhiteBalance values
+
+	iInfo.iMinZoom = KMinTestCameraZoom;
+	// KMinTestCameraZoom is zero or negative
+	// note the algorithm for creating of zoom factor
+	iInfo.iMinZoomFactor = TReal32(1)/TReal32(1 << -KMinTestCameraZoom);
+	iInfo.iMaxZoom = KMaxTestCameraZoom;
+	iInfo.iMaxZoomFactor = 1 << KMaxTestCameraZoom;
+
+	iInfo.iMaxDigitalZoom = KMaxTestCameraDigitalZoom;
+	iInfo.iMaxDigitalZoomFactor = KMaxTestCameraDigitalZoomFactor;
+
+	iInfo.iImageFormatsSupported = 0;
+	iInfo.iImageFormatsSupported |= EFormatFbsBitmapColor4K;
+	iInfo.iImageFormatsSupported |= EFormatFbsBitmapColor64K;
+	iInfo.iImageFormatsSupported |= EFormatFbsBitmapColor16M;
+
+	iInfo.iVideoFrameFormatsSupported = 0;
+	iInfo.iVideoFrameFormatsSupported |= EFormatFbsBitmapColor4K;
+	iInfo.iVideoFrameFormatsSupported |= EFormatFbsBitmapColor64K;
+	iInfo.iVideoFrameFormatsSupported |= EFormatFbsBitmapColor16M;
+	iInfo.iMaxFramesPerBufferSupported = 1;
+	iInfo.iMaxBuffersSupported = 2;
+	
+	iScreenRect = TRect(TPoint(0,0), TPoint(0,0));
+	
+	iEventError = KErrNone;
+	}
+	
+CTestCamera::~CTestCamera()
+	{
+	delete iTimer;
+	delete iStillImage;
+	delete iStillImageGc;
+	delete iStillImageDev;
+	delete iVideoFrame1;
+	delete iVideoFrameGc1;
+	delete iVideoFrameDev1;
+	delete iVideoFrame2;
+	delete iVideoFrameGc2;
+	delete iVideoFrameDev2;
+	delete iViewFinderBitmapGc;
+	delete iViewFinderBitmapDev;
+	delete iViewFinderBitmap;
+	delete iDSA;
+	delete iScreenGc;
+	delete iScreenDev;
+	delete iGc;
+	delete iDev;
+	delete iImage;
+	delete iAdvSettingsImpl;
+	delete iSnapshotImpl;
+	delete iImgProcImpl;
+	iImageSizes.Reset();
+	iVideoFrameSizes.Reset();
+	iVideoFrameRates.Reset();
+	}
+
+void CTestCamera::CameraInfo(TCameraInfo& aInfo) const
+	{
+	aInfo = iInfo;
+	}
+
+void CTestCamera::Reserve()
+	{
+	iReserved = ETrue;
+	iReserveAsync.CallBack();
+	}
+
+void CTestCamera::Release()
+	{
+	iReserved = EFalse;
+	iTimer->Cancel();
+	}
+
+void CTestCamera::PowerOn()
+	{
+	if (!iReserved || iPowerOn)
+		{
+		iPowerOnAsync.CallBack();
+		return;
+		}
+
+	iPowerOn = ETrue;
+	TCallBack callback(TimerCallBack,this);
+	iTimer->Start(0,TInt(TReal32(1000000) / iVideoFrameRate), callback);
+	iPowerOnAsync.CallBack();
+	}
+
+void CTestCamera::PowerOff()
+	{
+	iPowerOn = EFalse;
+	iTimer->Cancel();
+	}
+
+TInt CTestCamera::Handle()
+	{
+	return 0;
+	}
+
+void CTestCamera::SetZoomFactorL(TInt aZoomFactor)
+	{
+	// it is equivalent to comparing with iInfo members as they are initialised with the same constants
+	// if (aZoomFactor < iInfo.iMinZoom || aZoomFactor > iInfo.iMaxZoom)
+	if (aZoomFactor < KMinTestCameraZoom || aZoomFactor > KMaxTestCameraZoom)
+		{
+		User::Leave(KErrNotSupported);	
+		}
+
+	iZoom = aZoomFactor;
+	}
+
+TInt CTestCamera::ZoomFactor() const
+	{
+	// default value is 0
+	return iZoom;
+	}
+
+void CTestCamera::SetDigitalZoomFactorL(TInt aDigitalZoomFactor)
+	{
+	CheckReserveAndPowerL();
+	// it is equivalent to comparing with iInfo member as it is initialised with the same constant
+	// if (aDigitalZoomFactor < 0 || aDigitalZoomFactor > iInfo.iMaxDigitalZoom)
+	if (aDigitalZoomFactor < 0 || aDigitalZoomFactor > KMaxTestCameraDigitalZoom)
+		{
+		User::Leave(KErrNotSupported);	
+		}
+
+	iDigitalZoom = aDigitalZoomFactor;
+	}
+
+TInt CTestCamera::DigitalZoomFactor() const
+	{
+	// default value is 0
+	return iDigitalZoom;
+	}
+
+void CTestCamera::SetContrastL(TInt aContrast)
+	{
+	CheckReserveAndPowerL();
+
+	iContrast = Min(Max(aContrast,-100),100);
+	}
+
+TInt CTestCamera::Contrast() const
+	{
+	return iContrast;
+	}
+
+void CTestCamera::SetBrightnessL(TInt aBrightness)
+	{
+	CheckReserveAndPowerL();
+
+	iBrightness = Min(Max(aBrightness,-100),100);
+	}
+
+TInt CTestCamera::Brightness() const
+	{
+	return iBrightness;
+	}
+
+void CTestCamera::SetFlashL(TFlash aFlash)
+	{
+	CheckReserveAndPowerL();
+
+	if (aFlash != EFlashNone)
+		{
+		User::Leave(KErrNotSupported);	
+		}
+	}
+
+CCamera::TFlash CTestCamera::Flash() const
+	{
+	return EFlashNone;
+	}
+
+void CTestCamera::SetExposureL(TExposure aExposure)
+	{
+	CheckReserveAndPowerL();
+
+	if (aExposure != EExposureAuto)
+		{
+		User::Leave(KErrNotSupported);
+		}
+	}
+
+CCamera::TExposure CTestCamera::Exposure() const
+	{
+	return EExposureAuto;
+	}
+
+void CTestCamera::SetWhiteBalanceL(TWhiteBalance aWhiteBalance)
+	{
+	CheckReserveAndPowerL();
+
+	if (aWhiteBalance != EWBAuto)
+		{
+		User::Leave(KErrNotSupported);
+		}
+	}
+
+CCamera::TWhiteBalance CTestCamera::WhiteBalance() const
+	{
+	return EWBAuto;
+	}
+
+void CTestCamera::StartViewFinderDirectL(RWsSession& aWs,CWsScreenDevice& aScreenDevice,RWindowBase& aWindow,TRect& aScreenRect)
+	{
+	TRect emptyRect;
+	StartViewFinderDirectL(aWs,aScreenDevice,aWindow,aScreenRect,emptyRect);
+	}
+
+void CTestCamera::StartViewFinderDirectL(RWsSession& aWs,CWsScreenDevice& aScreenDevice,RWindowBase& aWindow,TRect& aScreenRect,TRect& aClipRect)
+	{
+	if (!iReserved)
+		{
+		User::Leave(KErrInUse);		
+		}
+		
+	if (!iPowerOn || iViewFinderActive)
+		{
+		User::Leave(KErrNotReady);	
+		}
+
+	iScreenRect = aScreenRect;
+	iClipRect = aClipRect;
+
+	delete iDSA;
+	iDSA = NULL;
+	iViewFinderActive = EFalse;
+	iDSA = CDirectScreenAccess::NewL(aWs,aScreenDevice,aWindow,*this);
+	iDSA->StartL();
+	iViewFinderActive = ETrue;
+	iDSA->Gc()->SetOrigin(); // Set Origin to top left of screen (0,0)
+
+	if (!iClipRect.IsEmpty())
+		{
+		iDSA->Gc()->SetClippingRect(iClipRect);	
+		}
+	}
+
+void CTestCamera::StartViewFinderBitmapsL(TSize& aSize)
+	{
+	TRect emptyRect;
+	StartViewFinderBitmapsL(aSize,emptyRect);
+	}
+
+void CTestCamera::StartViewFinderBitmapsL(TSize& aSize, TRect& aClipRect)
+	{
+	if (!iReserved)
+		{
+		User::Leave(KErrInUse);
+		}
+	if (!iPowerOn || iViewFinderActive)
+		{
+		User::Leave(KErrNotReady);
+		}
+
+	iViewFinderActive = ETrue;
+	iScreenRect = TRect(TPoint(0,0), aSize);
+	iClipRect = aClipRect;
+	iClipRect.Intersection(iScreenRect);
+
+	delete iViewFinderBitmapGc;
+	iViewFinderBitmapGc = NULL;
+	delete iViewFinderBitmapDev;
+	iViewFinderBitmapDev = NULL;
+	delete iViewFinderBitmap;
+	iViewFinderBitmap = NULL;
+
+	iViewFinderBitmap = new(ELeave) CFbsBitmap;
+	if (!iClipRect.IsEmpty())
+		{
+		User::LeaveIfError(iViewFinderBitmap->Create(iClipRect.Size(), KViewFinderDisplayMode));		
+		}
+	else
+		{
+		User::LeaveIfError(iViewFinderBitmap->Create(aSize, KViewFinderDisplayMode));		
+		}
+	iViewFinderBitmapDev = CFbsBitmapDevice::NewL(iViewFinderBitmap);
+	User::LeaveIfError(iViewFinderBitmapDev->CreateContext(iViewFinderBitmapGc));
+	}
+	
+void CTestCamera::StartViewFinderL(TFormat aImageFormat,TSize& aSize)
+       {
+       TRect emptyRect;
+       StartViewFinderL(aImageFormat,aSize,emptyRect);
+       }
+	
+void CTestCamera::StartViewFinderL(TFormat aImageFormat,TSize& /*aSize*/,TRect& aClipRect)	
+       {
+     	if(!iReserved)
+     		{
+     		User::Leave(KErrInUse);
+     		}
+		if(!iPowerOn || iViewFinderActive)
+			{
+			User::Leave(KErrNotReady);
+			}
+		
+		iViewFinderActive = ETrue;
+		iClipRect = aClipRect;
+		if(!(aImageFormat & iInfo.iImageFormatsSupported))
+			{
+			 User::Leave(KErrNotSupported);
+			}
+       }
+       
+
+void CTestCamera::StopViewFinder()
+	{
+	iViewFinderActive = EFalse;
+	delete iDSA;
+	iDSA = NULL;
+
+	delete iViewFinderBitmapGc;
+	iViewFinderBitmapGc = NULL;
+	delete iViewFinderBitmapDev;
+	iViewFinderBitmapDev = NULL;
+	delete iViewFinderBitmap;
+	iViewFinderBitmap = NULL;
+	}
+
+TBool CTestCamera::ViewFinderActive() const
+	{
+	return iViewFinderActive;
+	}
+
+void CTestCamera::SetViewFinderMirrorL(TBool aMirror)
+	{
+	if (aMirror)
+		{
+		User::Leave(KErrNotSupported);	
+		}
+	}
+
+TBool CTestCamera::ViewFinderMirror() const
+	{
+	return EFalse;
+	}
+
+void CTestCamera::PrepareImageCaptureL(TFormat aImageFormat,TInt aSizeIndex)
+	{
+	if (!iReserved)
+		{
+		User::Leave(KErrInUse);
+		}
+		
+	if (!iPowerOn || iVideoCaptureActive || iImageCaptureActive)
+		{
+		User::Leave(KErrNotReady);
+		}
+		
+
+	if (!(aImageFormat & iInfo.iImageFormatsSupported) || aSizeIndex < 0
+		|| aSizeIndex >= iInfo.iNumImageSizesSupported)
+		{
+		User::Leave(KErrNotSupported);
+		}
+
+	iVideoPreparedLast = EFalse;
+
+	if (iImageCapturePrepared
+		&& iStillImageSize == iImageSizes[aSizeIndex]
+		&& iStillImageFormat == aImageFormat)
+		{
+		return;
+		}
+
+	iStillImageSize = iImageSizes[aSizeIndex];
+	iStillImageFormat = aImageFormat;
+
+	TDisplayMode displayMode = ENone;
+	switch (iStillImageFormat)
+		{
+		case EFormatFbsBitmapColor4K :
+			displayMode = EColor4K;
+			break;
+		case EFormatFbsBitmapColor64K :
+			displayMode = EColor64K;
+			break;
+		case EFormatFbsBitmapColor16M :
+			displayMode = EColor16M;
+			break;
+		default :
+			User::Leave(KErrNotSupported);
+			break;
+		}
+
+	delete iStillImageGc;
+	iStillImageGc = NULL;
+	delete iStillImageDev;
+	iStillImageDev = NULL;
+	delete iStillImage;
+	iStillImage = NULL;
+
+	iStillImage = new(ELeave) CFbsBitmap;
+	User::LeaveIfError(iStillImage->Create(iStillImageSize, displayMode));
+	iStillImageDev = CFbsBitmapDevice::NewL(iStillImage);
+	User::LeaveIfError(iStillImageDev->CreateContext(iStillImageGc));
+	iStillImageGc->SetPenColor(KRgbBlack);
+	iStillImageGc->SetPenSize(TSize(KFrameFeatureBorderThickness, KFrameFeatureBorderThickness));
+	iStillImageGc->SetBrushColor(KRgbWhite);
+	iStillImageGc->SetFaded(ETrue);
+	iImageCapturePrepared = ETrue;
+	}
+
+void CTestCamera::PrepareImageCaptureL(TFormat /*aImageFormat*/,TInt /*aSizeIndex*/,const TRect& /*aClipRect*/)
+	{
+	User::Leave(KErrNotSupported);
+	}
+
+void CTestCamera::CaptureImage()
+	{
+	if (!iReserved)
+		{
+		iStillCaptureErr = KErrInUse;
+		}
+		
+	if (!iPowerOn || iImageCaptureActive || iVideoCaptureActive || !iImageCapturePrepared)
+		{
+		iStillCaptureErr = KErrNotReady;
+		}
+
+	if (iStillCaptureErr == KErrNone)
+		{
+		TRAP(iStillCaptureErr,DoCaptureImageL());
+		}
+
+	if (iStillCaptureErr == KErrNone)
+		{
+		iImageCaptureActive = ETrue;
+		}
+	else
+		{
+		iImageCaptureAsync.CallBack();
+		}
+	}
+
+void CTestCamera::DoCaptureImageL()
+	{
+	delete iGc;
+	iGc = NULL;
+	delete iDev;
+	iDev = NULL;
+	delete iImage;
+	iImage = NULL;
+
+	CFbsBitmap* image = new(ELeave) CFbsBitmap;
+	CleanupStack::PushL(image);
+	User::LeaveIfError(image->Create(iStillImageSize, iStillImage->DisplayMode()));
+	CFbsBitmapDevice* dev = CFbsBitmapDevice::NewL(image);
+	CleanupStack::PushL(dev);
+	CFbsBitGc* gc = NULL;
+	User::LeaveIfError(dev->CreateContext(gc));
+	CleanupStack::Pop(dev);
+	CleanupStack::Pop(image);
+
+	iImage = image;
+	iDev = dev;
+	iGc = gc;
+	}
+
+void CTestCamera::CancelCaptureImage()
+	{
+	iImageCaptureActive = EFalse;
+	}
+
+void CTestCamera::EnumerateCaptureSizes(TSize& aSize,TInt aSizeIndex,TFormat aFormat) const
+	{
+	if (aSizeIndex < 0 || aSizeIndex >= iInfo.iNumImageSizesSupported ||
+		!(aFormat & iInfo.iImageFormatsSupported) )
+		{
+		aSize = TSize(0,0);
+		}
+	else
+		{
+		aSize = iImageSizes[aSizeIndex];
+		}
+	}
+
+void CTestCamera::PrepareVideoCaptureL(TFormat aFormat,TInt aSizeIndex,TInt aRateIndex,TInt aBuffersToUse,TInt aFramesPerBuffer)
+	{
+	if (!iReserved)
+		{
+		User::Leave(KErrInUse);
+		}
+		
+	if (!iPowerOn || iVideoCaptureActive || iImageCaptureActive)
+		{
+		User::Leave(KErrNotReady);
+		}
+
+	if (!(aFormat & iInfo.iVideoFrameFormatsSupported) 
+		|| aSizeIndex < 0 || aSizeIndex >= iInfo.iNumVideoFrameSizesSupported
+		|| aRateIndex < 0 || aRateIndex >= iInfo.iNumVideoFrameRatesSupported
+		|| aBuffersToUse != 2 || aFramesPerBuffer != 1)
+		{
+		User::Leave(KErrNotSupported);
+		}
+
+	iVideoPreparedLast = ETrue;
+
+	if (iVideoCapturePrepared 
+		&& iVideoFrameSize == iVideoFrameSizes[aSizeIndex]
+		&& iVideoFrameFormat == aFormat)
+		{
+		return;
+		}
+
+	TDisplayMode displayMode = ENone;
+	switch (aFormat)
+		{
+		case EFormatFbsBitmapColor4K :
+			displayMode = EColor4K;
+			break;
+		case EFormatFbsBitmapColor64K :
+			displayMode = EColor64K;
+			break;
+		case EFormatFbsBitmapColor16M :
+			displayMode = EColor16M;
+			break;
+		default :
+			User::Leave(KErrNotSupported);
+			break;
+		}
+
+	iVideoFrameSize = iVideoFrameSizes[aSizeIndex];
+	iVideoFrameRate = iVideoFrameRates[aRateIndex];
+	iVideoFrameFormat = aFormat;
+	iBuffersInUse = aBuffersToUse;
+
+	delete iVideoFrameGc1;
+	iVideoFrameGc1 = NULL;
+	delete iVideoFrameDev1;
+	iVideoFrameDev1 = NULL;
+	delete iVideoFrame1;
+	iVideoFrame1 = NULL;
+
+	delete iVideoFrameGc2;
+	iVideoFrameGc2 = NULL;
+	delete iVideoFrameDev2;
+	iVideoFrameDev2 = NULL;
+	delete iVideoFrame2;
+	iVideoFrame2 = NULL;
+
+	iVideoFrame1 = new(ELeave) CFbsBitmap;
+	User::LeaveIfError(iVideoFrame1->Create(iVideoFrameSize, displayMode));
+	iVideoFrameDev1 = CFbsBitmapDevice::NewL(iVideoFrame1);
+	User::LeaveIfError(iVideoFrameDev1->CreateContext(iVideoFrameGc1));
+	iVideoFrameGc1->SetPenColor(KRgbBlack);
+	iVideoFrameGc1->SetPenSize(TSize(KFrameFeatureBorderThickness, KFrameFeatureBorderThickness));
+	iVideoFrameGc1->SetBrushColor(KRgbWhite);
+	iVideoFrameGc1->SetFaded(ETrue);
+
+	if (iBuffersInUse == 2)
+		{
+		iVideoFrame2 = new(ELeave) CFbsBitmap;
+		User::LeaveIfError(iVideoFrame2->Create(iVideoFrameSize, displayMode));
+		iVideoFrameDev2 = CFbsBitmapDevice::NewL(iVideoFrame2);
+		User::LeaveIfError(iVideoFrameDev1->CreateContext(iVideoFrameGc2));
+		iVideoFrameGc2->SetPenColor(KRgbBlack);
+		iVideoFrameGc2->SetPenSize(TSize(KFrameFeatureBorderThickness, KFrameFeatureBorderThickness));
+		iVideoFrameGc2->SetBrushColor(KRgbWhite);
+		iVideoFrameGc2->SetFaded(ETrue);		
+		}
+
+	iVideoCapturePrepared = ETrue;
+	}
+
+void CTestCamera::PrepareVideoCaptureL(TFormat /*aFormat*/,TInt /*aSizeIndex*/,TInt /*aRateIndex*/,TInt /*aBuffersToUse*/,TInt /*aFramesPerBuffer*/,const TRect& /*aClipRect*/)
+	{
+	User::Leave(KErrNotSupported);
+	}
+
+void CTestCamera::StartVideoCapture()
+	{
+	if (!iReserved)
+		{
+		iVideoCaptureErr = KErrInUse;
+		}
+		
+	if (!iPowerOn || iImageCaptureActive || iVideoCaptureActive || !iVideoCapturePrepared)
+		{
+		iVideoCaptureErr = KErrNotReady;
+		}
+		
+	if (iVideoCaptureErr == KErrNone)
+		{
+		iVideoCaptureActive = ETrue;
+		}
+		
+	else
+		{
+		iVideoCaptureAsync.CallBack();
+		}
+	}
+
+void CTestCamera::StopVideoCapture()
+	{
+	iVideoCaptureActive = EFalse;
+	iFrameIndex = 0;
+	iElapsedTime = 0;
+	}
+
+TBool CTestCamera::VideoCaptureActive() const
+	{
+	return iVideoCaptureActive;
+	}
+
+void CTestCamera::EnumerateVideoFrameSizes(TSize& aSize,TInt aSizeIndex,TFormat aFormat) const
+	{
+	if (aSizeIndex < 0 || aSizeIndex >= iInfo.iNumVideoFrameSizesSupported ||
+		!(aFormat & iInfo.iVideoFrameFormatsSupported))
+		{
+		aSize = TSize(0,0);
+		}
+	else
+		{
+		aSize = iVideoFrameSizes[aSizeIndex];
+		}
+	}
+
+void CTestCamera::EnumerateVideoFrameRates(TReal32& aRate,TInt aRateIndex,TFormat aFormat,TInt aSizeIndex,TExposure aExposure) const
+	{
+	if (aRateIndex < 0 || aRateIndex >= iInfo.iNumVideoFrameRatesSupported ||
+		aSizeIndex < 0 || aSizeIndex >= iInfo.iNumVideoFrameSizesSupported ||
+		!(aFormat & iInfo.iVideoFrameFormatsSupported) ||
+		(!(aExposure & iInfo.iExposureModesSupported) && aExposure != CCamera::EExposureAuto))
+		{
+		aRate = 0.0;
+		}
+	else
+		{
+		aRate = iVideoFrameRates[aRateIndex];
+		}
+	}
+
+void CTestCamera::GetFrameSize(TSize& aSize) const
+	{
+	aSize = iVideoFrameSize;
+	}
+
+TReal32 CTestCamera::FrameRate() const
+	{
+	return iVideoFrameRate;
+	}
+
+TInt CTestCamera::BuffersInUse() const
+	{
+	return iBuffersInUse;
+	}
+
+TInt CTestCamera::FramesPerBuffer() const
+	{
+	return 1;
+	}
+
+void CTestCamera::SetJpegQuality(TInt /*aQuality*/)
+	{
+	}
+
+TInt CTestCamera::JpegQuality() const
+	{
+	return 0;
+	}
+
+TAny* CTestCamera::CustomInterface(TUid aInterface)
+	{
+	TAny* ptrIface = NULL;
+	TRAPD(error,CustomInterfaceL(ptrIface, aInterface));
+	
+	if(error == KErrNone)
+		{
+		switch(aInterface.iUid)
+			{
+			// advanced settings interface pointers
+			case KECamMCameraAdvancedSettingsUidValue:
+				{
+				return static_cast<MCameraAdvancedSettings*>(ptrIface);
+				}
+			case KECamMCameraAdvancedSettings2UidValue:
+				{
+				return static_cast<MCameraAdvancedSettings2*>(ptrIface);			
+				}
+			case KECamMCameraAdvancedSettings3UidValue:
+				{
+				return static_cast<MCameraAdvancedSettings3*>(ptrIface);
+				}
+			
+			// snapshot interface pointers	
+			case KECamMCameraSnapshotUidValue:
+				{
+				return static_cast<MCameraSnapshot*>(ptrIface);
+				}
+				
+			// preset interface pointers	
+			case KECamMCameraPresetsUidValue:
+				return static_cast<MCameraPresets*>(ptrIface);
+				
+			// image processing interface pointers
+			case KECamMCameraImageProcessingUidValue:
+				{
+				return static_cast<MCameraImageProcessing*>(ptrIface);
+				}
+				
+			case KECamMCameraImageProcessing2UidValue:
+				{
+				return static_cast<MCameraImageProcessing2*>(ptrIface);
+				}
+				
+			default:
+				return NULL;
+			}
+		}
+	else
+		{
+		return NULL;		
+		}
+	}
+
+void CTestCamera::CustomInterfaceL(TAny*& aIface, TUid aInterface)
+	{
+	switch(aInterface.iUid)
+		{
+		// advanced settings interface pointers
+		case KECamMCameraAdvancedSettingsUidValue:
+			{
+			iAdvSettingsImpl = CTestCamAdvSet::NewL(*this);
+			aIface = static_cast<MCameraAdvancedSettings*>(iAdvSettingsImpl);
+			break;
+			}
+		case KECamMCameraAdvancedSettings2UidValue:
+			{
+			iAdvSettingsImpl = CTestCamAdvSet::NewL(*this);
+			aIface = static_cast<MCameraAdvancedSettings2*>(iAdvSettingsImpl);			
+			break;
+			}
+		case KECamMCameraAdvancedSettings3UidValue:
+			{
+			iAdvSettingsImpl = CTestCamAdvSet::NewL(*this);
+			aIface = static_cast<MCameraAdvancedSettings3*>(iAdvSettingsImpl);
+			break;
+			}
+		
+		// snapshot interface pointers	
+		case KECamMCameraSnapshotUidValue:
+			{
+			iSnapshotImpl = CTestCamSnapshot::NewL(*this);
+			aIface = static_cast<MCameraSnapshot*>(iSnapshotImpl);
+			break;
+			}
+		// preset interface pointers	
+		case KECamMCameraPresetsUidValue:
+			{
+			aIface = static_cast<MCameraPresets*>(CTestCamPresets::NewL(*this));
+			break;
+			}
+			
+		// image processing interface pointers
+		case KECamMCameraImageProcessingUidValue:
+			{
+			iImgProcImpl = CTestCamImgProc::NewL(*this);	
+			aIface = static_cast<MCameraImageProcessing*>(iImgProcImpl);
+			break;
+			}
+			
+		case KECamMCameraImageProcessing2UidValue:
+			{
+			iImgProcImpl = CTestCamImgProc::NewL(*this);	
+			aIface = static_cast<MCameraImageProcessing2*>(iImgProcImpl);
+			break;
+			}
+			
+		default:
+			aIface = NULL;
+		}
+	}
+
+void CTestCamera::AbortNow(RDirectScreenAccess::TTerminationReasons /*aReason*/)
+	{
+	iViewFinderActive = EFalse;
+	}
+
+void CTestCamera::Restart(RDirectScreenAccess::TTerminationReasons /*aReason*/)
+	{
+	TRAPD(error,iDSA->StartL());
+	if (error != KErrNone)
+		{
+		return;
+		}
+	iDSA->Gc()->SetOrigin(); // Set Origin to top left of screen (0,0)
+
+	if (!iClipRect.IsEmpty())
+		{
+		iDSA->Gc()->SetClippingRect(iClipRect);
+		}
+	else
+		{
+		iDSA->Gc()->CancelClippingRect();
+		}
+
+	iViewFinderActive = ETrue;
+	}
+
+TInt CTestCamera::TimerCallBack(TAny* aThis)
+	{
+	static_cast<CTestCamera*>(aThis)->FrameReady();
+	return KErrNone;
+	}
+
+void CTestCamera::FrameReady()
+	{
+	if (iVideoPreparedLast)
+		{
+		iVideoFramePos.iX += KFramePosIncrement;
+		iVideoFramePos.iY += KFramePosIncrement;
+
+		if (iVideoFramePos.iX >= iVideoFrameSize.iWidth)
+			{
+			iVideoFramePos.iX = 0;
+			}
+			
+		if (iVideoFramePos.iY >= iVideoFrameSize.iHeight)
+			{
+			iVideoFramePos.iY = 0;
+			}
+		}
+	else
+		{
+		iStillImagePos.iX += KFramePosIncrement;
+		iStillImagePos.iY += KFramePosIncrement;
+
+		if (iStillImagePos.iX >= iStillImageSize.iWidth)
+			{
+			iStillImagePos.iX = 0;
+			}
+			
+		if (iStillImagePos.iY >= iStillImageSize.iHeight)
+			{
+			iStillImagePos.iY = 0;
+			}
+		}
+
+	if (iImageCaptureActive)
+		{
+		if (!iImageCapturePrepared)
+			{
+			iImageCaptureActive = EFalse;
+			if (iObserver2)
+				{
+				iObserver2->ImageBufferReady(iFrameCameraBuffer1,KErrNotReady);
+				}
+			else
+				{
+				iObserver->ImageReady(NULL,NULL,KErrNotReady);
+				}
+			}
+		else
+			{
+			if(iDriveMode == CCamera::CCameraAdvancedSettings::EDriveModeBurst)
+				{
+				for (TInt index =0; index < iBurstImages -1; index++)
+					{
+					if(iSnapshotImpl != NULL)
+						{
+						if(iSnapshotImpl->iSnapshotActive)
+							{
+							GetFrame(*(iSnapshotImpl->iSnapshotImageGc), iStillImagePos);
+							iSnapshotImpl->ServiceBurstImageSnapshot(*(iSnapshotImpl->iSnapshotImageGc));
+							}
+						}
+					
+					GetImgProcessedFrame(*iStillImageGc, iStillImagePos);
+					ServiceBurstImageCapture(*iStillImageGc);
+					}
+				}
+				
+			// normal case, single shot and last image from burst mode
+			if(iSnapshotImpl != NULL)
+				{
+				if(iSnapshotImpl->iSnapshotActive)
+					{
+					GetFrame(*iSnapshotImpl->iSnapshotImageGc, iStillImagePos);
+					iSnapshotImpl->ServiceSnapshot(*(iSnapshotImpl->iSnapshotImageGc));
+					}
+				}
+				
+			GetImgProcessedFrame(*iStillImageGc, iStillImagePos);
+			ServiceImageCapture(*iStillImageGc);	
+							
+			if (iVideoPreparedLast)
+				{
+				GetFrame(*iVideoFrameGc1, iVideoFramePos);
+				if (iViewFinderActive)
+					{
+					ServiceViewFinder(iVideoFrame1);
+					}	
+				}
+			else
+				{
+				if (iViewFinderActive)
+					{
+					ServiceViewFinder(iStillImage);
+					}
+				}
+			}
+		}
+
+	else if (iVideoCaptureActive)
+		{
+		if (!iVideoCapturePrepared)
+			{
+			iVideoCaptureActive = EFalse;
+			if (iObserver2)
+				{
+				iObserver2->VideoBufferReady(iFrameCameraBuffer1,KErrNotReady);
+				}
+			else
+				{
+				iObserver->FrameBufferReady(NULL,KErrNotReady);
+				}
+			}
+		else
+			{
+			if (iObserver2)
+				{
+				if (iFrameCameraBuffer1.iAvailable)
+					{
+					GetFrame(*iVideoFrameGc1, iVideoFramePos);
+					ServiceVideo(1);
+					if (iViewFinderActive)
+						{
+						ServiceViewFinder(iVideoFrame1);
+						}
+					}
+				else if (iFrameCameraBuffer2.iAvailable && iBuffersInUse == 2)
+					{
+					GetFrame(*iVideoFrameGc2, iVideoFramePos);
+					ServiceVideo(2);
+					if (iViewFinderActive)
+						{
+						ServiceViewFinder(iVideoFrame2);
+						}
+					}
+				}
+			else
+				{
+				if (iFrameBuffer1.iAvailable)
+					{
+					GetFrame(*iVideoFrameGc1, iVideoFramePos);
+					ServiceVideo(1);
+					if (iViewFinderActive)
+						{
+						ServiceViewFinder(iVideoFrame1);
+						}
+					}
+				else if (iFrameBuffer2.iAvailable && iBuffersInUse == 2)
+					{
+					GetFrame(*iVideoFrameGc2, iVideoFramePos);
+					ServiceVideo(2);
+					if (iViewFinderActive)
+						{
+						ServiceViewFinder(iVideoFrame2);
+						}
+					}
+				}
+			}
+	}
+
+	else if (iViewFinderActive)
+		{
+		if (iVideoPreparedLast)
+			{
+			GetFrame(*iVideoFrameGc1, iVideoFramePos);
+			ServiceViewFinder(iVideoFrame1);
+			}
+			else
+			{
+			GetFrame(*iStillImageGc, iStillImagePos);
+			ServiceViewFinder(iStillImage);
+			}
+		}
+	}
+
+void CTestCamera::GetFrame(CFbsBitGc& aGc, TPoint& aPos) const
+	{
+	TInt black = (100 - iContrast) * 127 / 200;
+	TInt white = ((100 + iContrast) * 128 / 200) + 127;
+
+	const TInt brightAdjust = iBrightness * 255 / 100;
+	black += brightAdjust;
+	white += brightAdjust;
+
+	black = Min(Max(black,0),255);
+	white = Min(Max(white,0),255);
+
+	aGc.SetFadingParameters(TUint8(black),TUint8(white));
+	aGc.Clear();
+	aGc.DrawRect(TRect(aPos,TSize(KFrameFeatureSize,KFrameFeatureSize)));
+	}
+	
+void CTestCamera::GetImgProcessedFrame(CFbsBitGc& aGc, TPoint& aPos) const
+	{
+	TInt contrast = iContrast;
+	TInt brightness = iBrightness;
+	
+	if(iImgProcImpl != NULL)
+		{
+		for(TInt index=0; index<iImgProcImpl->iActiveTransformations.Count(); index++)
+			{
+			switch(iImgProcImpl->iActiveTransformations[index].iUid)
+				{
+				case KUidECamEventImageProcessingAdjustBrightnessUidValue:
+					{
+					brightness = iImgProcBrightness;
+					break;
+					}
+				case KUidECamEventImageProcessingAdjustContrastUidValue:
+					{
+					contrast = iImgProcContrast;
+					break;
+					}
+				default:
+					{
+					break;
+					}
+				}
+			}
+		}
+	
+	TInt black = (100 - contrast) * 127 / 200;
+	TInt white = ((100 + contrast) * 128 / 200) + 127;
+
+	const TInt brightAdjust = brightness * 255 / 100;
+	black += brightAdjust;
+	white += brightAdjust;
+
+	black = Min(Max(black,0),255);
+	white = Min(Max(white,0),255);
+
+	aGc.SetFadingParameters(TUint8(black),TUint8(white));
+	aGc.Clear();
+	aGc.DrawRect(TRect(aPos,TSize(KFrameFeatureSize,KFrameFeatureSize)));
+	}
+	
+void CTestCamera::ServiceVideo(TInt aBufferNum)
+	{
+	iFrameIndex++;
+	iElapsedTime = iElapsedTime.Int64() + (TInt64(1000000) / TInt64(iVideoFrameRate));
+
+	if (aBufferNum == 1)
+		{
+		if (iObserver2)
+			{
+			iFrameCameraBuffer1.iIndexOfFirstFrameInBuffer = iFrameIndex;
+			iFrameCameraBuffer1.iElapsedTime = iElapsedTime;
+			iFrameCameraBuffer1.iAvailable = EFalse;
+			}
+		else
+			{
+			iFrameBuffer1.iIndexOfFirstFrameInBuffer = iFrameIndex;
+			iFrameBuffer1.iElapsedTime = iElapsedTime;
+			iFrameBuffer1.iAvailable = EFalse;
+			}
+			
+		if (iObserver2)
+			{
+			iObserver2->VideoBufferReady(iFrameCameraBuffer1,KErrNone);
+			}
+		else
+			{
+			iObserver->FrameBufferReady(&iFrameBuffer1,KErrNone);
+			}
+		}
+	else if (aBufferNum == 2)
+		{
+		if (iObserver2)
+			{
+			iFrameCameraBuffer2.iIndexOfFirstFrameInBuffer = iFrameIndex;
+			iFrameCameraBuffer2.iElapsedTime = iElapsedTime;
+			iFrameCameraBuffer2.iAvailable = EFalse;
+			}
+		else
+			{
+			iFrameBuffer2.iIndexOfFirstFrameInBuffer = iFrameIndex;
+			iFrameBuffer2.iElapsedTime = iElapsedTime;
+			iFrameBuffer2.iAvailable = EFalse;
+			}
+			
+		if (iObserver2)
+			{
+			iObserver2->VideoBufferReady(iFrameCameraBuffer2,KErrNone);
+			}
+		else
+			{
+			iObserver->FrameBufferReady(&iFrameBuffer2,KErrNone);
+			}
+		}
+	}
+
+void CTestCamera::ServiceViewFinder(CFbsBitmap* aSourceFrame)
+	{
+	if (iDSA)
+		{
+		iDSA->Gc()->DrawBitmap(iScreenRect,aSourceFrame);
+		iDSA->ScreenDevice()->Update();
+		}
+	else if (iViewFinderBitmap)
+		{
+		if (iViewFinderBitmapGc)
+			{
+			if (!iClipRect.IsEmpty())
+				{
+				TReal32 xRatio = static_cast<TReal32>(aSourceFrame->SizeInPixels().iWidth) / 
+								 static_cast<TReal32>(iClipRect.Size().iWidth);
+
+				TReal32 yRatio = static_cast<TReal32>(aSourceFrame->SizeInPixels().iHeight) / 
+								 static_cast<TReal32>(iClipRect.Size().iHeight);
+
+				TRect sourceRect(TPoint(static_cast<TInt>(xRatio*iClipRect.iTl.iX),
+										static_cast<TInt>(yRatio*iClipRect.iTl.iY)),
+								 TPoint(static_cast<TInt>(xRatio*iClipRect.iBr.iX),
+										static_cast<TInt>(yRatio*iClipRect.iBr.iY)));
+
+				TRect destRect(TPoint(0,0), iClipRect.Size());
+
+				iViewFinderBitmapGc->DrawBitmap(destRect,
+												aSourceFrame,
+												sourceRect);
+				}
+			else
+				{
+				TRect destRect(TPoint(0,0), iViewFinderBitmap->SizeInPixels());
+				iViewFinderBitmapGc->DrawBitmap(destRect, aSourceFrame);
+				}
+				
+			if (iObserver2)
+				{
+				iObserver2->ViewFinderReady(iFrameCameraBuffer1,KErrNone);
+				}
+			else
+				{
+				iObserver->ViewFinderFrameReady(*iViewFinderBitmap);
+				}
+		
+			}
+		}
+	else
+		{
+		iScreenGc->DrawBitmap(iClipRect,aSourceFrame);
+		iScreenDev->Update();
+		}
+	}
+
+void CTestCamera::ServiceImageCapture(const CFbsBitGc& aSourceBitmapGc)
+	{
+	iImageCaptureActive = EFalse;
+	iGc->BitBlt(TPoint(0,0), aSourceBitmapGc);
+	CFbsBitmap* image = iImage;
+	RTestCameraFrameBuffer frameBuffer(image);
+	delete iGc;
+	iGc = NULL;
+	delete iDev;
+	iDev = NULL;
+	if (iObserver2 != NULL)
+		{
+		iObserver2->ImageBufferReady(frameBuffer,KErrNone);
+		}
+	else
+		{
+		iImage = NULL;
+		iObserver->ImageReady(image,NULL,KErrNone);
+		}
+	}
+	
+void CTestCamera::ServiceBurstImageCapture(const CFbsBitGc& aSourceBitmapGc)
+	{
+	iGc->BitBlt(TPoint(0,0), aSourceBitmapGc);
+	if (iObserver2 != NULL)
+		{
+		CFbsBitmap* image = iImage;
+		RTestCameraFrameBuffer frameBuffer(image);
+		iObserver2->ImageBufferReady(frameBuffer,KErrNone);
+		}
+	else//not for MCameraObserver
+		{
+		return;
+		}
+	
+	if(iSnapshotImpl)
+		{
+		if(iSnapshotImpl->iSnapshotActive)
+			{
+			return;
+			}
+		}
+	User::After(500000);
+	iStillImagePos.iX += KFramePosIncrement;
+	iStillImagePos.iY += KFramePosIncrement;
+
+	if (iStillImagePos.iX >= iStillImageSize.iWidth)
+		{
+		iStillImagePos.iX = 0;
+		}
+			
+	if (iStillImagePos.iY >= iStillImageSize.iHeight)
+		{
+		iStillImagePos.iY = 0;
+		}
+	}
+
+void CTestCamera::CheckReserveAndPowerL()
+	{
+	if (!iReserved)
+		{
+		User::Leave(KErrInUse);
+		}
+		
+	if (!iPowerOn)
+		{
+		User::Leave(KErrNotReady);
+		}	
+	}
+
+TInt CTestCamera::CheckReserveAndPower() const
+	{
+	if (!iReserved)
+		{
+		return KErrInUse;
+		}
+		
+	if (!iPowerOn)
+		{
+		return KErrNotReady;
+		}	
+	
+	return KErrNone;
+	}
+
+TInt CTestCamera::ReserveCallBack(TAny* aThis)
+	{
+	const TECAMEvent event(KUidECamEventReserveComplete,KErrNone);
+	CTestCamera* testCamera = static_cast<CTestCamera*>(aThis);
+	if (testCamera->iObserver2)
+		{
+		testCamera->iObserver2->HandleEvent(event);
+		}
+	else
+		{
+		testCamera->iObserver->ReserveComplete(KErrNone);
+		}
+	return KErrNone;
+	}
+
+TInt CTestCamera::PowerOnCallBack(TAny* aThis)
+	{
+	TECAMEvent event(KUidECamEventPowerOnComplete,KErrNone);
+	CTestCamera* testCamera = static_cast<CTestCamera*>(aThis);
+	if (testCamera->iObserver2)
+		{
+		testCamera->iObserver2->HandleEvent(event);
+		}
+	else
+		{
+		testCamera->iObserver->PowerOnComplete(testCamera->iPowerOn ? KErrNone : KErrInUse);
+		}
+	return KErrNone;
+	}
+
+TInt CTestCamera::ImageCaptureCallBack(TAny* aThis)
+	{
+	CTestCamera* testCamera = static_cast<CTestCamera*>(aThis);
+	if (testCamera->iObserver2)
+		{
+		testCamera->iObserver2->ImageBufferReady((static_cast<CTestCamera*>(aThis))->iFrameCameraBuffer1,testCamera->iStillCaptureErr);
+		}
+	else
+		{
+		testCamera->iObserver->ImageReady(NULL,NULL,testCamera->iStillCaptureErr);
+		}
+	testCamera->iStillCaptureErr = KErrNone;
+	return KErrNone;
+	}
+
+TInt CTestCamera::VideoCaptureCallBack(TAny* aThis)
+	{
+	CTestCamera* testCamera = static_cast<CTestCamera*>(aThis);
+	if (testCamera->iObserver2)
+		{
+		testCamera->iObserver2->VideoBufferReady((static_cast<CTestCamera*>(aThis))->iFrameCameraBuffer1,testCamera->iVideoCaptureErr);
+		}
+	else
+		{
+		testCamera->iObserver->FrameBufferReady(NULL,testCamera->iVideoCaptureErr);
+		}
+	testCamera->iVideoCaptureErr = KErrNone;
+	return KErrNone;
+	}
+	
+TInt CTestCamera::HandleEventCallBack(TAny* aThis)
+	{
+	CTestCamera* testCamera = static_cast<CTestCamera*>(aThis);
+	if (testCamera->iObserver2)
+		{
+		testCamera->iObserver2->HandleEvent(testCamera->iECamEvent);
+		}
+	
+	return KErrNone;
+	}
+
+TInt CTestCamera::HandleEvent2CallBack(TAny* aThis)
+	{
+	CTestCamera* testCamera = static_cast<CTestCamera*>(aThis);
+	if (testCamera->iObserver2)
+		{
+		testCamera->iObserver2->HandleEvent(testCamera->iECamEvent2);
+		}
+	
+	return KErrNone;
+	}
+
+//
+// CTestCameraInfo
+//
+
+CTestCameraInfo::CTestCameraInfo()
+	{
+	}
+	
+CTestCameraInfo::~CTestCameraInfo()
+	{
+	}
+	
+CTestCameraInfo* CTestCameraInfo::NewL()
+	{
+	FileDependencyUtil::CheckFileDependencyL();
+	return new (ELeave) CTestCameraInfo;
+	}
+	
+TInt CTestCameraInfo::CamerasAvailable()
+	{
+	return 1;
+	}
+
+//void CTestCamera::CheckFileDependencyL()
+void FileDependencyUtil::CheckFileDependencyL()
+	{	
+	RFs fsSession;
+  	RFile file;
+    CleanupClosePushL(fsSession);
+  	User::LeaveIfError(fsSession.Connect());
+    TInt err = file.Open(fsSession, KTestCameraPluginName, EFileRead);
+  	file.Close();
+  	if(err != KErrNone)
+  		{
+	    User::LeaveIfError(KErrNotSupported);
+  		}
+  	CleanupStack::PopAndDestroy(); //fsSession 
+	}
+
+// __________________________________________________________________________
+// Exported proxy for instantiation method resolution
+// Define the interface UIDs
+const TImplementationProxy ImplementationTable[] = 
+	{
+	IMPLEMENTATION_PROXY_ENTRY(KUidOnboardCameraTestPlugin,	CTestCamera::NewL),
+	IMPLEMENTATION_PROXY_ENTRY(KUidOnboardCameraTestInfo,	CTestCameraInfo::NewL)
+	};
+
+EXPORT_C const TImplementationProxy* ImplementationGroupProxy(TInt& aTableCount)
+	{
+	aTableCount = sizeof(ImplementationTable) / sizeof(TImplementationProxy);
+
+	return ImplementationTable;
+	}
+