--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/imagingandcamerafws/camerafw/testapps/testcameraapp/TestCameraApp.cpp	Tue Feb 02 01:56:55 2010 +0200
@@ -0,0 +1,744 @@
+// 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 <eikenv.h>
+#include <testcameraapp.rsg>
+#include "TestCameraApp.h"
+#include "TestCameraApp.hrh"
+#include "TestCamera.h"
+
+const TInt KMaxErrLength=50;
+_LIT(KErrorFormat,"Error - %d (%S)");
+
+//
+//  CTCamAppUi
+//
+
+void CTCamAppUi::ConstructL()
+	{
+	CEikAppUi::ConstructL();
+	iAppView = new(ELeave) CTCamAppView;
+	iAppView->ConstructL(ClientRect());
+	AddToStackL(iAppView);
+	
+	// The plugin relies on a specific file existing
+	// hence this has to be created.
+	CreateDependencyFileL();
+
+	iCamera = CCamera::NewL(*this,0,0);
+	
+	iCameraAdvSet = CCamera::CCameraAdvancedSettings::NewL(*iCamera);
+	iCameraPresets = CCamera::CCameraPresets::NewL(*iCamera);
+	iCameraImgProc = CCamera::CCameraImageProcessing::NewL(*iCamera);
+	iCameraSnapshot = CCamera::CCameraSnapshot::NewL(*iCamera);
+	
+	iCamera->Reserve();
+	}
+
+CTCamAppUi::~CTCamAppUi()
+	{
+	if (iCamera!=NULL)
+		iCamera->Release();
+	
+	delete iCameraSnapshot;
+	delete iCameraImgProc;	
+	delete iCameraPresets;
+	delete iCameraAdvSet;
+	delete iCamera;
+
+	// as the application is being closed, delete the file
+	// so that the plugin will not be reactivated accidentaly
+	RemoveDependencyFile();
+	
+	if (iAppView)
+		{
+		RemoveFromStack(iAppView);
+		delete iAppView;
+		}
+	}
+
+void CTCamAppUi::HandleCommandL(TInt aCommand)
+	{
+	switch (aCommand)
+		{
+	case ETCamCmdPowerOn:
+		iCamera->PowerOn();
+		break;
+	case ETCamCmdPowerOff:
+		iCamera->PowerOff();
+		break;
+	case ETCamCmdViewFinder:
+		ViewFinderL();
+		break;
+	case ETCamCmdCaptureImage:
+		SingleShotL();
+		break;
+	case ETCamCmdBurstMode:
+		BurstModeL();
+		break;
+	case ETCamCmdCaptureVideo:
+		CaptureVideoL();
+		break;
+	case ETCamCmdIncBrightness:
+		iCamera->SetBrightnessL(iCamera->Brightness() + 10);
+		break;
+	case ETCamCmdIncContrast:
+		iCamera->SetContrastL(iCamera->Contrast() + 10);
+		break;
+	case ETCamCmdDecBrightness:
+		iCamera->SetBrightnessL(iCamera->Brightness() - 10);
+		break;
+	case ETCamCmdDecContrast:
+		iCamera->SetContrastL(iCamera->Contrast() - 10);
+		break;
+	case ETCamCmdResetBrightness:
+		iCamera->SetBrightnessL(0);
+		break;
+	case ETCamCmdResetContrast:
+		iCamera->SetContrastL(0);
+		break;
+	case ETCamCmdIncNumBurstImages:
+		iCameraAdvSet->SetBurstImages(iCameraAdvSet->BurstImages() + 1);
+		break;
+	case ETCamCmdDecNumBurstImages:
+		iCameraAdvSet->SetBurstImages(iCameraAdvSet->BurstImages() - 1);
+		break;
+	case ETCamCmdResetNumBurstImages:
+		iCameraAdvSet->SetBurstImages(4);
+		break;
+		
+	case ETCamCmdFactoryPreset:
+		iCameraPresets->SetPreset(KUidECamPresetFactoryDefault);
+		break;
+	
+	case ETCamCmdOutdoorPreset:
+		iCameraPresets->SetPreset(KUidECamPresetOutdoor);
+		break;	
+		
+	case ETCamCmdOutdoorSportPreset:
+		iCameraPresets->SetPreset(KUidECamPresetOutdoorSport);
+		break;
+	
+	case ETCamCmdFogPreset:
+		iCameraPresets->SetPreset(KUidECamPresetFog);
+		break;	
+
+	case ETCamCmdNightPartyIndoorPreset:
+		iCameraPresets->SetPreset(KUidECamPresetNightPartyIndoor);
+		break;
+	
+	case ETCamCmdTextDocumentPreset:
+		iCameraPresets->SetPreset(KUidECamPresetTextDocument);
+		break;	
+		
+	case ETCamCmdImgProcIncBrightness:
+		IncImgProcAdjustmentL(KUidECamEventImageProcessingAdjustBrightness);
+		break;
+		
+	case ETCamCmdImgProcDecBrightness:
+		DecImgProcAdjustmentL(KUidECamEventImageProcessingAdjustBrightness);
+		break;
+		
+	case ETCamCmdImgProcIncContrast:
+		IncImgProcAdjustmentL(KUidECamEventImageProcessingAdjustContrast);
+		break;
+		
+	case ETCamCmdImgProcDecContrast:
+		DecImgProcAdjustmentL(KUidECamEventImageProcessingAdjustContrast);
+		break;
+		
+	case ETCamCmdEnableSnapshot:
+		EnableSnapshotL();
+		break;
+		
+	case ETCamCmdDisableSnapshot:
+		DisableSnapshot();
+		break;
+	
+	case EEikCmdExit:
+		Exit();
+		break;
+		}
+	}
+
+void CTCamAppUi::ViewFinderL()
+	{
+	TSize imageSize;
+	iCamera->EnumerateCaptureSizes(imageSize,1,CCamera::EFormatFbsBitmapColor16M);
+	const TPoint pos = iAppView->DrawBorders(imageSize);
+	TRect screenRect(pos,imageSize);
+	TRect clipRect;
+
+	if (!iCamera->ViewFinderActive())
+		{
+		iCamera->StartViewFinderDirectL(iCoeEnv->WsSession(),*iCoeEnv->ScreenDevice(),*iAppView->DrawableWindow(),screenRect,clipRect);		
+		}
+	else
+		{
+		iCamera->StopViewFinder();
+		}
+	}
+
+void CTCamAppUi::BurstModeL()
+	{
+	if (!iCameraAdvSet)
+		{
+		User::Leave(KErrNotSupported);
+		}
+	
+	if(CCamera::CCameraAdvancedSettings::EDriveModeBurst & iCameraAdvSet->SupportedDriveModes() )
+		{
+		iCameraAdvSet->SetDriveMode(CCamera::CCameraAdvancedSettings::EDriveModeBurst);
+		}
+	else
+		{
+		User::Leave(KErrNotSupported);	
+		}
+	}
+	
+void CTCamAppUi::EnableSnapshotL()
+	{
+	if(!iCameraSnapshot->IsSnapshotActive())
+		{
+		TSize size;
+		iCamera->EnumerateCaptureSizes(size,1,CCamera::EFormatFbsBitmapColor16M);
+		if(iCameraSnapshot->SupportedFormats() & CCamera::EFormatFbsBitmapColor4K)
+			{
+			iCameraSnapshot->PrepareSnapshotL(CCamera::EFormatFbsBitmapColor4K, TPoint(0,0), size, KRgbWhite, EFalse);
+			iCameraSnapshot->StartSnapshot();
+			}
+		}
+	}
+	
+void CTCamAppUi::DisableSnapshot()
+	{
+	if(iCameraSnapshot->IsSnapshotActive())
+		{
+		iCameraSnapshot->StopSnapshot();
+		}
+	}
+	
+void CTCamAppUi::SingleShotL()
+	{
+	if (!iCameraAdvSet)
+		{
+		User::Leave(KErrNotSupported);
+		}
+	
+	if(CCamera::CCameraAdvancedSettings::EDriveModeSingleShot & iCameraAdvSet->SupportedDriveModes() )
+		{
+		iCameraAdvSet->SetDriveMode(CCamera::CCameraAdvancedSettings::EDriveModeSingleShot);
+		}
+	else
+		{
+		User::Leave(KErrNotSupported);	
+		}
+	}
+
+void CTCamAppUi::CaptureImageL()
+	{
+	TSize size;
+	iCamera->EnumerateCaptureSizes(size,1,CCamera::EFormatFbsBitmapColor16M);
+	iCamera->PrepareImageCaptureL(CCamera::EFormatFbsBitmapColor16M,1);
+	iCamera->CaptureImage();
+	}
+
+void CTCamAppUi::CaptureVideoL()
+	{
+	if (!iCamera->VideoCaptureActive())
+		{
+		iCameraSnapshot->StopSnapshot();
+		
+		TSize size;
+		TReal32 rate = 0;
+		iCamera->EnumerateVideoFrameSizes(size,0,CCamera::EFormatFbsBitmapColor16M);
+		iCamera->EnumerateVideoFrameRates(rate,0,CCamera::EFormatFbsBitmapColor16M,0);
+		iCamera->PrepareVideoCaptureL(CCamera::EFormatFbsBitmapColor16M,0,0,2,1);
+		iCamera->StartVideoCapture();
+		}
+	else
+		{
+		iCamera->StopVideoCapture();
+		}	
+	}
+	
+void CTCamAppUi::IncImgProcAdjustmentL(TUid aTransformation)
+	{
+	if(!iCameraImgProc)	
+		{
+		User::Leave(KErrNotSupported);
+		}
+	
+	RArray<TUid> supportedTransformations;
+	CleanupClosePushL(supportedTransformations);
+	iCameraImgProc->GetSupportedTransformationsL(supportedTransformations);
+	
+	TInt error = supportedTransformations.Find(aTransformation);
+	CleanupStack::PopAndDestroy(); 
+
+	if(error == KErrNotFound)
+		{
+		User::Leave(error);
+		}
+		
+	TInt valuetx;
+	User::LeaveIfError(iCameraImgProc->GetTransformationValue(aTransformation, valuetx));
+	
+	iCameraImgProc->SetTransformationValue(aTransformation, valuetx + 10);
+	}
+	
+void CTCamAppUi::DecImgProcAdjustmentL(TUid aTransformation)
+	{
+	if(!iCameraImgProc)	
+		{
+		User::Leave(KErrNotSupported);
+		}
+	
+	RArray<TUid> supportedTransformations;
+	CleanupClosePushL(supportedTransformations);
+	iCameraImgProc->GetSupportedTransformationsL(supportedTransformations);
+	
+	TInt error = supportedTransformations.Find(aTransformation);
+	CleanupStack::PopAndDestroy(); 
+
+	if(error == KErrNotFound)
+		{
+		User::Leave(error);
+		}
+		
+	TInt valuetx;
+	User::LeaveIfError(iCameraImgProc->GetTransformationValue(aTransformation, valuetx));
+	
+	iCameraImgProc->SetTransformationValue(aTransformation, valuetx - 10);
+	}
+	
+void CTCamAppUi::ReserveComplete(TInt /*aError*/)
+	{
+	}
+
+void CTCamAppUi::PowerOnComplete(TInt /*aError*/)
+	{
+	}
+
+void CTCamAppUi::ViewFinderFrameReady(CFbsBitmap& /*aFrame*/)
+	{
+	}
+
+void CTCamAppUi::ImageReady(CFbsBitmap* aBitmap,HBufC8* /*aData*/,TInt aError)
+	{
+	TBuf<KMaxErrLength> msgBuffer;
+	_LIT(KErrMessage,"CTCamAppUi::ImageReady");
+	if (aBitmap)
+		{
+		iAppView->DrawImage(aBitmap);
+		delete aBitmap;
+		}
+	if (aError)
+		{
+		msgBuffer.Format(KErrorFormat,aError,&KErrMessage);
+		iEikonEnv->InfoMsg(msgBuffer);
+		}
+	}
+
+void CTCamAppUi::FrameBufferReady(MFrameBuffer* aFrameBuffer,TInt aError)
+	{
+	TBuf<KMaxErrLength> msgBuffer;
+	_LIT(KErrMessage,"CTCamAppUi::FrameBufferReady");
+	if (aError)
+		{
+		msgBuffer.Format(KErrorFormat,aError,&KErrMessage);
+		iEikonEnv->InfoMsg(msgBuffer);
+		return;
+		}
+	TRAPD(error,iAppView->DrawImage(aFrameBuffer->FrameL(0)));
+	aFrameBuffer->Release();
+	if (error)
+		{
+		msgBuffer.Format(KErrorFormat,error,&KErrMessage);
+		iEikonEnv->InfoMsg(msgBuffer);
+		}
+	}
+	
+void CTCamAppUi::HandleEvent(const TECAMEvent& aEvent)
+	{
+	if(!TECAMEvent2::IsEventEncapsulationValid(aEvent))
+		{
+		HandleEvent1(aEvent);
+		}
+	else
+		{
+		HandleEvent2(static_cast<const TECAMEvent2&>(aEvent));
+		}
+	}
+	
+void CTCamAppUi::HandleEvent2(const TECAMEvent2& /*aEvent2*/)
+	{
+	
+	}
+	
+void CTCamAppUi::HandleEvent1(const TECAMEvent& aEvent)
+	{
+	TBuf<KMaxErrLength> msgBuffer;
+	
+	switch(aEvent.iEventType.iUid)
+		{
+		case KUidECamEventCameraSettingDriveModeUidValue:
+			{
+			if(!aEvent.iErrorCode)
+				{
+				TRAPD(error,CaptureImageL());	
+				if(error)
+					{
+					_LIT(KErrMessage,"CaptureImage");
+					msgBuffer.Format(KErrorFormat,error,&KErrMessage);
+					iEikonEnv->InfoMsg(msgBuffer);
+					}
+				}
+			else
+				{
+				_LIT(KErrMessage,"SettingDriveMode");
+				msgBuffer.Format(KErrorFormat,aEvent.iErrorCode,&KErrMessage);
+				iEikonEnv->InfoMsg(msgBuffer);
+				}
+			break;
+			}
+		case KUidECamEventBurstImagesUidValue:
+			{
+			if(aEvent.iErrorCode)
+				{
+				_LIT(KErrMessage,"SettingNumOfBurstImage");
+				msgBuffer.Format(KErrorFormat,aEvent.iErrorCode,&KErrMessage);
+				iEikonEnv->InfoMsg(msgBuffer);
+				}	
+			break;	
+			}
+		case KUidECamEventSnapshotUidValue:
+			{
+			if(aEvent.iErrorCode)
+				{
+				_LIT(KErrMessage,"SnapshotDataNotification");
+				msgBuffer.Format(KErrorFormat,aEvent.iErrorCode,&KErrMessage);
+				iEikonEnv->InfoMsg(msgBuffer);
+				}
+			else
+				{
+				if(iCamera->ViewFinderActive())
+					{	
+					iCamera->StopViewFinder();
+					}
+			
+				TRAPD(error, SnapshotDataDisplayL());
+
+				if(error != KErrNone)
+					{
+					_LIT(KErrMessage,"SnapshotDataDisplay");
+					msgBuffer.Format(KErrorFormat,error,&KErrMessage);
+					iEikonEnv->InfoMsg(msgBuffer);
+					}
+				}
+			break;
+			}
+			
+		case KUidECamPresetFactoryDefaultUidValue:
+			{
+			if(aEvent.iErrorCode)
+				{
+				_LIT(KErrMessage,"FactoryPreset");
+				msgBuffer.Format(KErrorFormat,aEvent.iErrorCode,&KErrMessage);
+				iEikonEnv->InfoMsg(msgBuffer);
+				}
+			break;
+			}
+			
+		case KUidECamPresetOutdoorUidValue:
+			{
+			if(aEvent.iErrorCode)
+				{
+				_LIT(KErrMessage,"OutdoorPreset");
+				msgBuffer.Format(KErrorFormat,aEvent.iErrorCode,&KErrMessage);
+				iEikonEnv->InfoMsg(msgBuffer);
+				}
+			break;
+			}
+			
+		case KUidECamPresetOutdoorSportUidValue:
+			{
+			if(aEvent.iErrorCode)
+				{
+				_LIT(KErrMessage,"OutdoorSportPreset");
+				msgBuffer.Format(KErrorFormat,aEvent.iErrorCode,&KErrMessage);
+				iEikonEnv->InfoMsg(msgBuffer);
+				}
+			break;
+			}
+			
+		case KUidECamPresetFogUidValue:
+			{
+			if(aEvent.iErrorCode)
+				{
+				_LIT(KErrMessage,"FogPreset");
+				msgBuffer.Format(KErrorFormat,aEvent.iErrorCode,&KErrMessage);
+				iEikonEnv->InfoMsg(msgBuffer);
+				}
+			break;
+			}
+			
+		case KUidECamPresetNightPartyIndoorUidValue:
+			{
+			if(aEvent.iErrorCode)
+				{
+				_LIT(KErrMessage,"NightPartyIndoorPreset");
+				msgBuffer.Format(KErrorFormat,aEvent.iErrorCode,&KErrMessage);
+				iEikonEnv->InfoMsg(msgBuffer);
+				}
+			break;
+			}
+			
+		case KUidECamPresetTextDocumentUidValue:
+			{
+			if(aEvent.iErrorCode)
+				{
+				_LIT(KErrMessage,"TextDocumentPreset");
+				msgBuffer.Format(KErrorFormat,aEvent.iErrorCode,&KErrMessage);
+				iEikonEnv->InfoMsg(msgBuffer);
+				}
+			break;
+			}
+		
+		case KUidECamEventImageProcessingAdjustBrightnessUidValue:
+			{
+			if(aEvent.iErrorCode)
+				{
+				_LIT(KErrMessage,"ImageProcessingAdjustBrightness");
+				msgBuffer.Format(KErrorFormat,aEvent.iErrorCode,&KErrMessage);
+				iEikonEnv->InfoMsg(msgBuffer);
+				}
+			break;
+			}
+			
+		case KUidECamEventImageProcessingAdjustContrastUidValue:
+			{
+			if(aEvent.iErrorCode)
+				{
+				_LIT(KErrMessage,"ImageProcessingAdjustContrast");
+				msgBuffer.Format(KErrorFormat,aEvent.iErrorCode,&KErrMessage);
+				iEikonEnv->InfoMsg(msgBuffer);
+				}
+			break;
+			}
+					
+		default:
+			break;
+		}
+	}
+	
+void CTCamAppUi::ViewFinderReady(MCameraBuffer& /*aCameraBuffer*/,TInt /*aError*/)
+	{
+	
+	}
+	
+void CTCamAppUi::ImageBufferReady(MCameraBuffer& aCameraBuffer,TInt aError)
+	{
+	TBuf<KMaxErrLength> msgBuffer;
+	_LIT(KErrMessage,"CTCamAppUi::ImageBufferReady");
+	if(aError)
+		{
+		msgBuffer.Format(KErrorFormat,aError,&KErrMessage);
+		iEikonEnv->InfoMsg(msgBuffer);
+		return;
+		}
+	if(!iCameraSnapshot->IsSnapshotActive())
+		{
+		if (iCamera->ViewFinderActive())
+			{	
+			iCamera->StopViewFinder();
+			}
+		TRAP(aError,iAppView->DrawImage(&aCameraBuffer.BitmapL(0)));		
+		}
+
+	aCameraBuffer.Release();
+	
+	if (aError)
+		{
+		msgBuffer.Format(KErrorFormat,aError,&KErrMessage);
+		iEikonEnv->InfoMsg(msgBuffer);
+		}
+		
+	}
+	
+void CTCamAppUi::VideoBufferReady(MCameraBuffer& aCameraBuffer,TInt aError)
+	{
+	TBuf<KMaxErrLength> msgBuffer;
+	_LIT(KErrMessage,"CTCamAppUi::FrameBufferReady");
+	if (aError)
+		{
+		msgBuffer.Format(KErrorFormat,aError,&KErrMessage);
+		iEikonEnv->InfoMsg(msgBuffer);
+		return;
+		}
+	TRAPD(error,iAppView->DrawImage(&aCameraBuffer.BitmapL(0)));
+	aCameraBuffer.Release();
+	if (error)
+		{
+		msgBuffer.Format(KErrorFormat,error,&KErrMessage);
+		iEikonEnv->InfoMsg(msgBuffer);
+		}		
+	}
+	
+void CTCamAppUi::SnapshotDataDisplayL()
+	{
+	RArray<TInt> array;
+	array.Reset();
+	RTestCameraFrameBuffer& buffer = static_cast<RTestCameraFrameBuffer&>(iCameraSnapshot->SnapshotDataL(array));
+	iAppView->DrawImage(&buffer.BitmapL(0));
+	array.Close();
+	buffer.Release();
+	}	
+
+void CTCamAppUi::CreateDependencyFileL()
+	{
+	// enforce dependency
+	// create the file the plugin depends on.
+	User::LeaveIfError(ifsSession.Connect());
+	RFile file;
+	TInt err = file.Replace(ifsSession, KTestCameraPluginName, EFileShareAny);
+  	file.Close();
+  	if(err != KErrNone)
+  		{
+	    User::LeaveIfError(KErrNotSupported);
+  		}
+	}
+	
+void CTCamAppUi::RemoveDependencyFile()
+	{
+	ifsSession.Delete(KTestCameraPluginName);
+	ifsSession.Close();
+	}
+
+//
+// CTCamAppView
+//
+
+CTCamAppView::CTCamAppView():
+	CCoeControl()
+	{
+	}
+
+void CTCamAppView::ConstructL(const TRect& /*aRect*/)
+	{
+	CreateWindowL();
+	EnableDragEvents();
+	SetExtentToWholeScreen();
+	ActivateL();
+	}
+
+CTCamAppView::~CTCamAppView()
+	{
+	}
+
+void CTCamAppView::DrawImage(CFbsBitmap* aImage) const
+	{
+	CWindowGc& gc = SystemGc();
+	gc.Activate(Window());
+	TRect drawRect=Rect();
+	TPoint pos;
+	pos.iX = (3 * drawRect.iBr.iX / 4) - (aImage->SizeInPixels().iWidth / 2);
+	pos.iY = (drawRect.iBr.iY - aImage->SizeInPixels().iWidth) / 2;
+	gc.BitBlt(pos,aImage);
+	TRect border(pos,aImage->SizeInPixels());
+	border.Grow(1,1);
+	gc.DrawRect(border);
+	gc.Deactivate();
+	iCoeEnv->WsSession().Flush();
+	}
+
+void CTCamAppView::Draw(const TRect& /*aRect*/) const
+	{
+	CWindowGc& gc = SystemGc();
+	TRect drawRect(Rect());
+	drawRect.Shrink(1,1);
+	gc.DrawRect(drawRect);
+	gc.Clear();
+	}
+
+TPoint CTCamAppView::DrawBorders(const TSize& aSize) const
+	{
+	CWindowGc& gc = SystemGc();
+	gc.Activate(Window());
+	TRect drawRect(Rect());
+	TPoint pos;
+	pos.iX = (drawRect.iBr.iX / 4) - (aSize.iWidth / 2);
+	pos.iY = (drawRect.iBr.iY - aSize.iWidth) / 2;
+	TRect border(pos,aSize);
+	border.Grow(1,1);
+	gc.SetPenColor(KRgbBlack);
+	gc.DrawRect(border);
+	gc.Deactivate();
+	iCoeEnv->WsSession().Flush();
+	return pos;
+	}
+
+//
+// CTCamDocument
+//
+
+CTCamDocument::CTCamDocument(CEikApplication& aApp)
+		: CEikDocument(aApp)
+	{
+	}
+
+CEikAppUi* CTCamDocument::CreateAppUiL()
+	{
+    return new(ELeave) CTCamAppUi;
+	}
+
+//
+// CTCamApp
+//
+
+TUid CTCamApp::AppDllUid() const
+	{
+	return KUidTestCameraApp;
+	}
+
+CApaDocument* CTCamApp::CreateDocumentL()
+	{
+	return new(ELeave) CTCamDocument(*this);
+	}
+
+
+
+//
+// Base factory function
+//
+
+#include <eikstart.h>
+LOCAL_C CApaApplication* NewApplication()
+	{
+	return new CTCamApp;
+	}
+
+//
+// EXE Entry point
+//
+
+GLDEF_C TInt E32Main()
+	{
+	return EikStart::RunApplication(NewApplication);
+	}
+
+
+
+