// 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:

//

/**

 @file

 @internalComponent

*/

#include "mmcameraserver.h"

#include "mmcameraserversession.h"

#include "mmcameraservercontroller.h"

#include <graphics/surfacemanager.h>

using namespace MMClient;

using namespace MMVideoComponents;

using namespace MMCameraComponents;

static const TInt KMMCamHandleNumberBase = 500;

const TInt KDefaultFrameRate = 30;

CMMCameraServerController* CMMCameraServerController::NewL(TInt aCameraIndex)

	{

	CMMCameraServerController* self = new(ELeave) CMMCameraServerController(aCameraIndex);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;	

	}

CMMCameraServerController::CMMCameraServerController(TInt aCameraIndex): iCameraIndex(aCameraIndex),

																	 iCameraHandle(KMMCamHandleNumberBase + iCameraIndex),

																	 iMMCapability(EFalse),

																	 iViewFinderState(CCamera::CCameraV2DirectViewFinder::EViewFinderInActive),

																	 iFlash(CCamera::EFlashNone),

																	 iExposure(CCamera::EExposureAuto),

																	 iWhiteBalance(CCamera::EWBAuto)

	{

	}

void CMMCameraServerController::ConstructL()

	{	

	User::LeaveIfError(iMMServer.Connect()); // Connect to the MM server

	// Create characterizations for camera and graphics sink

	XMMCameraViewFinderCharacterization* cameraViewFinderChar = XMMCameraViewFinderCharacterization::New();

	XMMVideoGraphicsSinkCharacterization* graphicsSinkChar = XMMVideoGraphicsSinkCharacterization::New();

	XMMCameraSensorCharacterization* cameraSensorChar = XMMCameraSensorCharacterization::New();

//	XMMCameraCaptureCharacterization* cameraCaptureChar = XMMCameraCaptureCharacterization::New();

	// Open stream, stream container and camera/graphics sink components

	User::LeaveIfError(iMMStreamContainer.Open());

	User::LeaveIfError(iMMStream.Open(iMMStreamContainer));

	User::LeaveIfError(iCameraViewFinder.Open(*cameraViewFinderChar));

	User::LeaveIfError(iMMStream.Append(iCameraViewFinder));

	User::LeaveIfError(iGraphicsSink.Open(*graphicsSinkChar));

	User::LeaveIfError(iMMStream.Append(iGraphicsSink));

	User::LeaveIfError(iCameraSensor.Open(*cameraSensorChar));

	User::LeaveIfError(iMMStream.Append(iCameraSensor));

	}

CMMCameraServerController::~CMMCameraServerController()

	{

	iCameraCapture.Close();

	iCameraSensor.Close();

	iGraphicsSink.Close();

	iCameraViewFinder.Close();

	iMMStream.Close();

	iMMStreamContainer.Close();

	iMMServer.Close();

	iCamCntrlLink.Deque();

	iCamCntrlLink.iNext = NULL;

	}

TInt CMMCameraServerController::CameraIndex() const

	{

	return iCameraIndex;

	}

TInt CMMCameraServerController::CameraHandle() const

	{

	return iCameraHandle;

	}

void CMMCameraServerController::PrepareDirectViewFinderL(TDirectViewFinderInfo& aDirectViewFinderInfo)

	{

	// Default mode - One Shot setting off

	User::LeaveIfError(iCameraSensor.SetSensorOneShot(EFalse));

	User::LeaveIfError(iCameraViewFinder.SetFrameDimensions(aDirectViewFinderInfo.iScreenRect.Width(), aDirectViewFinderInfo.iScreenRect.Height()));

	User::LeaveIfError(iCameraViewFinder.SetColorFormat(MMCameraComponents::EColorFormatYUV422Planar));

	// TODO: Replace 2 with calculation to find bytes per pixel depending on color format

	User::LeaveIfError(iCameraViewFinder.SetStride(aDirectViewFinderInfo.iScreenRect.Width() * 2));

	// Default mode - Frame rate = 30 fps

	User::LeaveIfError(iCameraViewFinder.SetFrameRate(KDefaultFrameRate));

	User::LeaveIfError(iMMServer.Commit(iMMStreamContainer));

//	User::LeaveIfError(iGraphicsSink.SetScreenNumber(aDirectViewFinderInfo.iScreenNum)); // Commented out as not yet supported by translators

	User::LeaveIfError(iGraphicsSink.GetSurfaceId(aDirectViewFinderInfo.iSurfaceId));

	iClipRect = aDirectViewFinderInfo.iClipRect;

	}

TInt CMMCameraServerController::StartDirectViewFinder()

	{

	TRequestStatus status;

	iMMStream.Start(status);

	User::WaitForRequest(status);

	if(status.Int() == KErrNone)

		{

		iViewFinderState = CCamera::CCameraV2DirectViewFinder::EViewFinderActive;

		}

	return status.Int();

	}

void CMMCameraServerController::StopDirectViewFinder()

	{

	TRequestStatus status;

	iMMStream.Stop(status);

	User::WaitForRequest(status);

	iViewFinderState = CCamera::CCameraV2DirectViewFinder::EViewFinderInActive;

	}

void CMMCameraServerController::PauseDirectViewFinder()

	{

	TRequestStatus status;

	iMMStream.Pause(status);

	User::WaitForRequest(status);

	iViewFinderState = CCamera::CCameraV2DirectViewFinder::EViewFinderPause;

	}

void CMMCameraServerController::ResumeDirectViewFinder()

	{

	TRequestStatus status;

	iMMStream.Resume(status);

	User::WaitForRequest(status);

	iViewFinderState = CCamera::CCameraV2DirectViewFinder::EViewFinderActive;

	}

CCamera::CCameraV2DirectViewFinder::TViewFinderState CMMCameraServerController::GetDirectViewFinderState() const

	{

	return iViewFinderState;

	}

TInt CMMCameraServerController::SetDirectViewFinderMirror(const TBool aMirror)

	{

	// mismatch here between ECAM API (which only specify whether mirror is on or off)

	// and RMMCameraSensor (which specify horizontal and/or vertical mirror modes)

	if (aMirror)

		{

		return iCameraSensor.SetMirrorType(EMirrorHorizontal);

		}

	else

		{

		return iCameraSensor.SetMirrorType(EMirrorNone);

		}

	}

TInt CMMCameraServerController::GetDirectViewFinderMirror(TBool& aMirror)

	{

	// mismatch here between ECAM API (which only specify whether mirror is on or off)

	// and RMMCameraSensor (which specify horizontal and/or vertical mirror modes)

	TMMMirror mirror;

	TInt error = iCameraSensor.GetMirrorType(mirror);

	if (error != KErrNone)

		{

		return error;

		}

	if (mirror == EMirrorHorizontal)

		{

		aMirror = ETrue;

		}

	else

		{

		aMirror = EFalse;

		}

	return KErrNone;

	}

TInt CMMCameraServerController::DirectViewFinderProperties(TInt& aScreenNum, TRect& aScreenRect, TRect& aClipRect)

	{

	TUint screenNumber = 0;

	TInt error = iGraphicsSink.GetScreenNumber(screenNumber); // will currently just return 0 as screen number Set() not yet supported

	if (error == KErrNone)

		{

		aScreenNum = screenNumber;

		TUint width;

		TUint height;

		TInt error = iCameraViewFinder.GetFrameDimensions(width, height);

		if (error ==KErrNone)

			{

			aScreenRect.SetWidth(width);

			aScreenRect.SetHeight(height);

			aClipRect = iClipRect;

			return KErrNone;

			}

		}

	else

		{

		aScreenNum = -1;

		}

	return error;	

	}

TInt CMMCameraServerController::SetZoom(const TInt aZoom)

	{

	iZoom = aZoom;

	return KErrNone;

	}

TInt CMMCameraServerController::SetDigitalZoom(const TInt aDigitalZoom)

	{

	iDigitalZoom = aDigitalZoom;

	return KErrNone;

	}

TInt CMMCameraServerController::SetContrast(const TInt aContrast)

	{

	iContrast = aContrast;

	return KErrNone;

	}

TInt CMMCameraServerController::SetBrightness(const TInt aBrightness)

	{

	iBrightness = aBrightness;

	return KErrNone;

//	return iCameraSensor.SetBrightness(aBrightness);

	}

TInt CMMCameraServerController::SetFlash(const CCamera::TFlash aFlash)

	{

	iFlash = aFlash;

	return KErrNone;

	}

TInt CMMCameraServerController::SetExposure(const CCamera::TExposure aExposure)

	{

	iExposure = aExposure;

	return KErrNone;

	/*

	// Several CCamera exposure values dont have equivalent TMMExposureControl values

	switch (aExposure)

		{

		case CCamera::EExposureAuto:

			{

			return iCameraSensor.SetExposureControl(EExposureControlAuto);

			}

		case CCamera::EExposureNight:

			{

			return iCameraSensor.SetExposureControl(EExposureControlNight);

			}

		case CCamera::EExposureBacklight:

			{

			return iCameraSensor.SetExposureControl(EExposureControlBackLight);

			}

		case CCamera::EExposureCenter:

			{

			return iCameraSensor.SetExposureControl(EExposureControlSpotLight);

			}

		case CCamera::EExposureSport:

			{

			return iCameraSensor.SetExposureControl(EExposureControlSports);

			}

		case CCamera::EExposureSnow:

			{

			return iCameraSensor.SetExposureControl(EExposureControlSnow);

			}

		case CCamera::EExposureBeach:

			{

			return iCameraSensor.SetExposureControl(EExposureControlBeach);

			}

		default:

			{

			return KErrNotSupported;

			}

		}

*/	}

TInt CMMCameraServerController::SetWhiteBalance(const CCamera::TWhiteBalance aWhiteBalance)

	{

	iWhiteBalance = aWhiteBalance;

	return KErrNone;

/*	// Several CCamera white balance values dont have equivalent TMMWhiteBalControl values

	switch (aWhiteBalance)

		{

		case CCamera::EWBAuto:

			{

			return iCameraSensor.SetWhiteBalanceControl(EWhiteBalControlAuto);

			}

		case CCamera::EWBDaylight:

			{

			return iCameraSensor.SetWhiteBalanceControl(EWhiteBalControlSunLight);

			}

		case CCamera::EWBCloudy:

			{

			return iCameraSensor.SetWhiteBalanceControl(EWhiteBalControlCloudy);

			}

		case CCamera::EWBTungsten:

			{

			return iCameraSensor.SetWhiteBalanceControl(EWhiteBalControlTungsten);

			}

		case CCamera::EWBFluorescent:

			{

			return iCameraSensor.SetWhiteBalanceControl(EWhiteBalControlFluorescent);

			}

		case CCamera::EWBFlash:

			{

			return iCameraSensor.SetWhiteBalanceControl(EWhiteBalControlFlash);

			}

		case CCamera::EWBShade:

			{

			return iCameraSensor.SetWhiteBalanceControl(EWhiteBalControlShade);

			}

		case CCamera::EWBHorizon:

			{

			return iCameraSensor.SetWhiteBalanceControl(EWhiteBalControlHorizon);

			}

		default:

			{

			return KErrNotSupported;

			}

		}

*/	}

TInt CMMCameraServerController::GetZoom(TInt& aZoom)

	{

	aZoom = iZoom;

	return KErrNone;

	}

TInt CMMCameraServerController::GetDigitalZoom(TInt& aDigitalZoom)

	{

	aDigitalZoom = iDigitalZoom;

	return KErrNone;

	}

TInt CMMCameraServerController::GetContrast(TInt& aContrast)

	{

	aContrast = iContrast;

	return KErrNone;

	}

TInt CMMCameraServerController::GetBrightness(TInt& aBrightness)

	{

	aBrightness = iBrightness;

	return KErrNone;

//	return iCameraSensor.GetBrightness(aBrightness);

	}

TInt CMMCameraServerController::GetFlash(CCamera::TFlash& aFlash)

	{

	aFlash = iFlash;

	return KErrNone;

	}

TInt CMMCameraServerController::GetExposure(CCamera::TExposure& aExposure)

	{

	aExposure = iExposure;

	return KErrNone;

	/*

	// Several CCamera exposure values dont have equivalent TMMExposureControl values

	TMMExposureControl exposure;

	TInt error = iCameraSensor.GetExposureControl(exposure);

	if (error != KErrNone)

		{

		return error;

		}

	switch (exposure)

		{

		case EExposureControlAuto:

			{

			aExposure = CCamera::EExposureAuto;

			break;

			}

		case EExposureControlNight:

			{

			aExposure = CCamera::EExposureNight;

			break;

			}

		case EExposureControlBackLight:

			{

			aExposure = CCamera::EExposureBacklight;

			break;

			}

		case EExposureControlSpotLight:

			{

			aExposure = CCamera::EExposureCenter;

			break;

			}

		case EExposureControlSports:

			{

			aExposure = CCamera::EExposureSport;

			break;

			}

		case EExposureControlSnow:

			{

			aExposure = CCamera::EExposureSnow;

			break;

			}

		case EExposureControlBeach:

			{

			aExposure = CCamera::EExposureBeach;

			break;

			}

		default:

			{

			return KErrNotSupported;

			}

		}

	return KErrNone;

*/	}

TInt CMMCameraServerController::GetWhiteBalance(CCamera::TWhiteBalance& aWhiteBalance)

	{

	aWhiteBalance = iWhiteBalance;

	return KErrNone;

	/*

	// Several CCamera white balance values dont have equivalent TMMWhiteBalControl values

	TMMWhiteBalControl whiteBal;

	TInt error = iCameraSensor.GetWhiteBalanceControl(whiteBal);

	if (error != KErrNone)

		{

		return error;

		}

	switch (aWhiteBalance)

		{

		case EWhiteBalControlAuto:

			{

			aWhiteBalance = CCamera::EWBAuto;

			break;

			}

		case EWhiteBalControlSunLight:

			{

			aWhiteBalance = CCamera::EWBDaylight;

			break;

			}

		case EWhiteBalControlCloudy:

			{

			aWhiteBalance = CCamera::EWBCloudy;

			break;

			}

		case EWhiteBalControlTungsten:

			{

			aWhiteBalance = CCamera::EWBTungsten;

			break;

			}

		case EWhiteBalControlFluorescent:

			{

			aWhiteBalance = CCamera::EWBFluorescent;

			break;

			}

		case EWhiteBalControlFlash:

			{

			aWhiteBalance = CCamera::EWBFlash;

			break;

			}

		case EWhiteBalControlShade:

			{

			aWhiteBalance = CCamera::EWBShade;

			break;

			}

		case EWhiteBalControlHorizon:

			{

			aWhiteBalance = CCamera::EWBHorizon;

			break;

			}

		default:

			{

			return KErrNotSupported;

			}

		}

	return KErrNone;

*/	}

void CMMCameraServerController::Reset()

	{

	if (iViewFinderState == CCamera::CCameraV2DirectViewFinder::EViewFinderActive)

		{

		StopDirectViewFinder();

		}

	}

CMMCameraServerControllerQuery* CMMCameraServerControllerQuery::NewL()

	{

	CMMCameraServerControllerQuery* self = new (ELeave) CMMCameraServerControllerQuery();

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

CMMCameraServerControllerQuery::~CMMCameraServerControllerQuery()

	{

	iServer.Close();

	}

void CMMCameraServerControllerQuery::ConstructL()

	{

	User::LeaveIfError(iServer.Connect());

	}

CMMCameraServerControllerQuery::CMMCameraServerControllerQuery()

	{

	}

TInt CMMCameraServerControllerQuery::GetCamerasAvailable()

	{

	// Code to query MM server TBC

	return 1;

	}