// 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);

	}