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

// mmcamerasession.cpp

// 

//

/**

 @file

 @internalComponent

*/

#include "mmcameraserversession.h"

#include "mmcameraservercontroller.h"

CMMCameraServerSession::CMMCameraServerSession()

	:iCameraIndex(0),

	 iHandle(KECamHandleNotKnown),

	 iPriority(KECamNoPriority),

	 iMMCapability(ETrue),

	 iCollaborativeClient(EFalse),

	 iReserved(EFalse),

	 iPoweredUp(EFalse)

	{

	}

void CMMCameraServerSession::CreateL()

	{

	iCameraServer = static_cast<CMMCameraServer*>(const_cast<CServer2*>(CSession2::Server()));

	// Get server policymanager

	iPolicyManager = Server()->PolicyManager();

	//load camera control etc in OpenCamera...

	Server()->AddSession();

	}

CMMCameraServerSession::~CMMCameraServerSession()

	{

//	CameraController()->Reset();

	Server()->DropSession();

	//deque the session queued in controller

	iCamSessionLink.Deque();  //safe to deque if it does not exists in the queue.

	iCamSessionLink.iNext = NULL;

	}

void CMMCameraServerSession::Disconnect(const RMessage2 &aMessage)

	{

	if(!iOverthrowMessage.IsNull())

		{

		iOverthrowMessage.Complete(KErrCancel);

		}

	CSession2::Disconnect(aMessage);

	}

void CMMCameraServerSession::ServiceL(const RMessage2& aMessage)

	{

	// Do policy manager checks

	iPolicyManager->ServiceHandlerL(aMessage);

	switch (aMessage.Function())

		{

		case ECamQueryCamerasAvailable:

			{

			CamerasAvailable(aMessage);

			break;

			}

		case ECamOpenCamera:

			{

			OpenCamera(aMessage);

			break;	

			}

		case ECamCameraAccessControl:

			{

			switch(aMessage.Int0())

				{

				case ECameraRelease:     

					{

					Release(aMessage);

					break;

					}

				case ECameraReservedNotification:    

					{

					Reserve(aMessage);

					break;	

					}

				case ECameraCancelReservedNotification:    

					{

					CancelReserve(aMessage);

					break;	

					}

				case ECameraOverthrowNotification:

					{

					if(iOverthrowMessage.IsNull())

						{

						iOverthrowMessage = aMessage;

						}

					else

						{

						aMessage.Complete(KErrServerBusy);

						}

					break;

					}

				case ECameraCancelOverthrowNotification:

					{

					if(!iOverthrowMessage.IsNull())

						{

						iOverthrowMessage.Complete(KErrCancel);

						}

					CameraController()->Reset(); //Stops VF, VC. Cancels ImageCapture if issued using this session.

					aMessage.Complete(KErrNone);

					break;

					}

				default:

					aMessage.Complete(KErrArgument);

				}

			break;

			}

		case ECamPowerCamera:

			{

			switch(aMessage.Int0())

				{

				case ECameraPowerOnNotification:     

					{

					PowerOn(aMessage);

					break;

					}

				case ECameraPowerOff:

					{

					PowerOff();	

					aMessage.Complete(KErrNone);

					break;

					}

				case ECameraCancelPowerOnNotification:

					{

					CancelPowerOn();

					aMessage.Complete(KErrNone);

					break;

					}

				}

			break;

			}

		case ECamPrepareDirectViewFinder:

			{

			PrepareDirectViewFinder(aMessage);

			break;

			}

		case ECamStartDirectViewFinder:

			{

			StartDirectViewFinder(aMessage);

			break;

			}

		case ECamStopDirectViewFinder:

			{

			StopDirectViewFinder(aMessage);

			break;

			}

		case ECamPauseDirectViewFinder:

			{

			PauseDirectViewFinder(aMessage);

			break;

			}

		case ECamResumeDirectViewFinder:

			{

			ResumeDirectViewFinder(aMessage);

			break;

			}

		case ECamDirectViewFinderState:

			{

			DirectViewFinderState(aMessage);

			break;

			}

		case ECamSetDirectViewFinderMirror:

			{

			SetDirectViewFinderMirror(aMessage);

			break;

			}

		case ECamGetDirectViewFinderMirror:

			{

			GetDirectViewFinderMirror(aMessage);

			break;

			}

		case ECamDirectViewFinderProperties:

			{

			DirectViewFinderProperties(aMessage);

			break;

			}

		case ECamSetParameter:

			{

			SetCameraParameter(aMessage);

			break;

			}

		case ECamGetParameter:

			{

			GetCameraParameter(aMessage);

			break;

			}

		case ECamCameraHandle:

			{

			CameraHandle(aMessage);

			break;

			}

		default:

			Server()->PanicClient(aMessage, EPanicNotSupported);

			break;

		}

	}

/**

 * Queries controller to find out how many cameras are available to clients.

 */

void CMMCameraServerSession::CamerasAvailable(const RMessage2& aMessage)

	{

	TCamerasAvailable info;

	CMMCameraServerControllerQuery* query = NULL;

	TRAPD(error, Server()->GetCameraControllerQueryL(query));

	if (error == KErrNone)

		{

		info.iCameraCount = query->GetCamerasAvailable();

		delete query;

		TCamerasAvailablePckg pckg(info);

		error = aMessage.Write(TInt(0), pckg);

		}

	aMessage.Complete(error);

	}

/**

 * Stores client information and retrieves camera controller for required camera index.

 * 

 * Called when client connects to the server for the first time.

 */

void CMMCameraServerSession::OpenCamera(const RMessage2& aMessage)

	{

	TOpenCamera parameters;

	TOpenCameraPckg parametersBuf(parameters);

	TInt error = aMessage.Read(TInt(0),parametersBuf);

	if (error != KErrNone)

		{

		aMessage.Complete(error);

		}

	parameters = parametersBuf();

	iCameraIndex = parameters.iCameraIndex;   // Store the required member variables 

    iPriority = parameters.iPriority;

    iMMCapability = parameters.iMMCapability;

    iHandle = parameters.iHandle; 

    iCollaborativeClient = parameters.iCollaborativeClient;

    TRAP(error, Server()->GetCameraControllerL(iCameraIndex, iCameraController));

    aMessage.Complete(error);

 	}

/**

 * Reserves the camera.

 * 

 * Delegates the responsibility to the policy manager

 */

void CMMCameraServerSession::Release(const RMessage2& aMessage)

	{

	if(!iReserved)

		{

		aMessage.Complete(KErrAlreadyExists);

		}

	else

		{		

		CameraController()->Reset(); //Stops VF, VC. Cancels ImageCapture if issued using this session.

		iPolicyManager->ReleaseClient(this);

		iReserved = EFalse;

		iPoweredUp = EFalse;

		if(!iOverthrowMessage.IsNull())

			{	

			iOverthrowMessage.Complete(KErrCancel);

			}

		aMessage.Complete(KErrNone);

		}

	}

void CMMCameraServerSession::CompleteOverthrow ()

	{

	if(!iOverthrowMessage.IsNull())

		{

		// Complete means sucess

		iOverthrowMessage.Complete(KErrNone);

		}

	iPoweredUp = EFalse;

	}

/**

 * Releases the camera.

 * 

 * Delegates the responsibility to the policy manager

 */

void CMMCameraServerSession::Reserve(const RMessage2& aMessage)

	{

	if (iReserved)

		{

		aMessage.Complete(KErrInUse);

		return;

		}

	iReserved = iPolicyManager->ReserveClient(this);

    if(!iReserved)       	

    	{

    	aMessage.Complete(KErrAccessDenied);

    	}

    else

    	{

   	    aMessage.Complete(KErrNone);

    	}

    }

/**

 * Cancels on ongoing Reserve() operation.

 */

void CMMCameraServerSession::CancelReserve(const RMessage2& aMessage)

	{

	Release(aMessage);

	}

/**

 * Powers on the device.

 * 

 * Simply returns with KErrNone or KErrNotReady since device is not powered on until VF is activated.

 */

void CMMCameraServerSession::PowerOn(const RMessage2& aMessage)

	{

	if(!iReserved)

		{

		aMessage.Complete(KErrNotReady);

		}

	else if (iPoweredUp)

		{

		aMessage.Complete(KErrInUse);

		}

	else

		{

		iPoweredUp = ETrue;

		aMessage.Complete(KErrNone);

		}

	}

/**

 * Powers off the device.

 * 

 * Simply stops any viewfinder activity.

 */

void CMMCameraServerSession::PowerOff()

	{

	CameraController()->Reset();

	iPoweredUp = EFalse;

	}

void CMMCameraServerSession::CancelPowerOn()

	{

	iPoweredUp = EFalse;

	}

/**

 * Prepares the view finder.

 * 

 * First step before viewfinder is started.

 */

void CMMCameraServerSession::PrepareDirectViewFinder(const RMessage2& aMessage)

	{

	TDirectViewFinderInfo viewFinderInfo;

	TDirectViewFinderInfoPckg viewFinderInfoPckg(viewFinderInfo);

	TInt error = aMessage.Read(TInt(0), viewFinderInfoPckg);

	if(error == KErrNone)

		{

		viewFinderInfo = viewFinderInfoPckg();

		TRAP(error, CameraController()->PrepareDirectViewFinderL(viewFinderInfo));

		if(error == KErrNone)

			{

			TDirectViewFinderInfoPckg pckg(viewFinderInfo);

			error = aMessage.Write(TInt(0), pckg);

			}

		}

	aMessage.Complete(error); 

	}

/**

 * Starts the viewfinder

 */

void CMMCameraServerSession::StartDirectViewFinder(const RMessage2& aMessage)

	{

	TInt error = CameraController()->StartDirectViewFinder();

	aMessage.Complete(error);

	}

/**

 * Stops the viewfinder.

 * 

 * Returns KErrNone even if stop is called when the viewfinder is not active, as client API must fail silently if error occurs.

 */

void CMMCameraServerSession::StopDirectViewFinder(const RMessage2& aMessage)

	{

	if (CameraController()->GetDirectViewFinderState() == CCamera::CCameraV2DirectViewFinder::EViewFinderActive)

		{

		CameraController()->StopDirectViewFinder();

		}

	aMessage.Complete(KErrNone);

	}

/**

 * Pauses the viewfinder.

 * 

 * Returns KErrNone even if pause is called when the viewfinder is not active, as client API must fail silently if error occurs.

 */

void CMMCameraServerSession::PauseDirectViewFinder(const RMessage2& aMessage)

	{

	if (CameraController()->GetDirectViewFinderState() == CCamera::CCameraV2DirectViewFinder::EViewFinderActive)

		{

		CameraController()->PauseDirectViewFinder();

		}

	aMessage.Complete(KErrNone);

	}

/**

 * Resumes the viewfinder if previously paused.

 * 

 * Returns KErrNone even if resume is called when the viewfinder is not paused, as client API must fail silently if error occurs.

 */

void CMMCameraServerSession::ResumeDirectViewFinder(const RMessage2& aMessage)

	{

	if (CameraController()->GetDirectViewFinderState() == CCamera::CCameraV2DirectViewFinder::EViewFinderPause)

		{

		CameraController()->ResumeDirectViewFinder();

		}

	aMessage.Complete(KErrNone);

	}

/**

 * Retrieves the state of the viewfinder

 */

void CMMCameraServerSession::DirectViewFinderState(const RMessage2& aMessage)

	{

	TDirectViewFinderState state;

	state.iState = CameraController()->GetDirectViewFinderState();

	TDirectViewFinderStatePckg pckg(state);

	TInt error = aMessage.Write(TInt(0), pckg);

	aMessage.Complete(error);

	}

/**

 * Sets viewfinder mirror mode on or off.

 */

void CMMCameraServerSession::SetDirectViewFinderMirror(const RMessage2& aMessage)

	{

	TViewFinderMirror viewFinderMirror;

	TViewFinderMirrorPckg pckg(viewFinderMirror);

	TInt error = aMessage.Read(TInt(0), pckg);

	if (error == KErrNone)

		{

		viewFinderMirror = pckg();

		error = CameraController()->SetDirectViewFinderMirror(viewFinderMirror.iMirror);

		}

	aMessage.Complete(error);

	}

/**

 * Retrieves whether viewfinder mirror mode is activated or not.

 */

void CMMCameraServerSession::GetDirectViewFinderMirror(const RMessage2& aMessage)

	{

	TViewFinderMirror viewFinderMirror;

	TInt error = CameraController()->GetDirectViewFinderMirror(viewFinderMirror.iMirror);

	if (error == KErrNone)

		{

		TViewFinderMirrorPckg pckg(viewFinderMirror);

		error = aMessage.Write(TInt(0), pckg);

		}

	aMessage.Complete(error);	

	}

/**

 * Retrieves the viewfinder properties

 */

void CMMCameraServerSession::DirectViewFinderProperties(const RMessage2& aMessage)

	{

	TDirectViewFinderInfo info;

	TInt error = CameraController()->DirectViewFinderProperties(info.iScreenNum, info.iScreenRect, info.iClipRect);

	if (error == KErrNone)

		{

		TDirectViewFinderInfoPckg pckg(info);

		error = aMessage.Write(TInt(0), pckg);

		}

	aMessage.Complete(error);

	}

/**

 * Sets various camera parameters depending on what the client wishes to set.

 */

void CMMCameraServerSession::SetCameraParameter(const RMessage2& aMessage)

	{

	TInt error = KErrNone;

	switch(aMessage.Int0())

		{

		case EZoomFactor:

			{

			TInt zoom = aMessage.Int1();

			error = CameraController()->SetZoom(zoom);

			aMessage.Complete(error);

			break;

			}

		case EDigitalZoomFactor:

			{

			TInt digitalZoom = aMessage.Int1();

			error = CameraController()->SetDigitalZoom(digitalZoom);

			aMessage.Complete(error);

			break;

			}

		case EContrast:

			{

			TInt contrast = aMessage.Int1();

			error = CameraController()->SetContrast(contrast);

			aMessage.Complete(error);

			break;

			}

		case EBrightness:

			{

			TInt brightness = aMessage.Int1();

			error = CameraController()->SetBrightness(brightness);

			aMessage.Complete(error);

			break;

			}

		case EFlash:

			{

			TCameraFlash flash;

			TCameraFlashPckg pckg(flash);

			error = aMessage.Read(TInt(1), pckg);

			if (error == KErrNone)

				{

				flash = pckg();

				error = CameraController()->SetFlash(flash.iFlash);

				}

			aMessage.Complete(error);

			break;

			}

		case EExposure:

			{

			TCameraExposure exposure;

			TCameraExposurePckg pckg(exposure);

			error = aMessage.Read(TInt(1), pckg);

			if (error == KErrNone)

				{

				exposure = pckg();

				error = CameraController()->SetExposure(exposure.iExposure);

				}

			aMessage.Complete(error);

			break;

			}

		case EWhiteBalance:

			{

			TCameraWhiteBalance whiteBalance;

			TCameraWhiteBalancePckg pckg(whiteBalance);

			error = aMessage.Read(TInt(1), pckg);

			if (error == KErrNone)

				{

				whiteBalance = pckg();

				error = CameraController()->SetWhiteBalance(whiteBalance.iWhiteBalance);

				}

			aMessage.Complete(error);

			break;

			}

		default:

			{

			Server()->PanicClient(aMessage, EPanicNotSupported);

			break;

			}

		}

	}

/**

 * Gets various camera parameters depending on what information the client wishes to retrieve.

 */

void CMMCameraServerSession::GetCameraParameter(const RMessage2& aMessage)

	{

	TInt error = KErrNone;

	switch(aMessage.Int0())

		{

		case EZoomFactor:

			{

			TCameraZoom zoom;

			error = CameraController()->GetZoom(zoom.iZoom);

			if (error == KErrNone)

				{

				TCameraZoomPckg pckg(zoom);

				error = aMessage.Write(TInt(1), pckg);

				}

			break;

			}

		case EDigitalZoomFactor:

			{

			TCameraDigitalZoom digitalZoom;

			error = CameraController()->GetDigitalZoom(digitalZoom.iDigitalZoom);

			if (error == KErrNone)

				{

				TCameraDigitalZoomPckg pckg(digitalZoom);

				error = aMessage.Write(TInt(1), pckg);

				}

			break;

			}

		case EContrast:

			{

			TCameraContrast contrast;

			error = CameraController()->GetContrast(contrast.iContrast);

			if (error == KErrNone)

				{

				TCameraContrastPckg pckg(contrast);

				error = aMessage.Write(TInt(1), pckg);

				}

			break;

			}

		case EBrightness:

			{

			TCameraBrightness brightness;

			error = CameraController()->GetBrightness(brightness.iBrightness);

			if (error == KErrNone)

				{

				TCameraBrightnessPckg pckg(brightness);

				error = aMessage.Write(TInt(1), pckg);

				}

			break;

			}

		case EFlash:

			{

			TCameraFlash flash;

			error = CameraController()->GetFlash(flash.iFlash);

			if (error == KErrNone)

				{

				TCameraFlashPckg pckg(flash);

				error = aMessage.Write(TInt(1), pckg);		

				}

			break;

			}

		case EExposure:

			{

			TCameraExposure exposure;

			error = CameraController()->GetExposure(exposure.iExposure);

			if (error == KErrNone)

				{

				TCameraExposurePckg pckg(exposure);

				error = aMessage.Write(TInt(1), pckg);

				}

			break;

			}

		case EWhiteBalance:

			{

			TCameraWhiteBalance whiteBalance;

			error = CameraController()->GetWhiteBalance(whiteBalance.iWhiteBalance);

			if (error == KErrNone)

				{

				TCameraWhiteBalancePckg pckg(whiteBalance);

				error = aMessage.Write(TInt(1), pckg);

				}

			break;

			}

		default:

			{

			Server()->PanicClient(aMessage, EPanicNotSupported);

			break;

			}

		}

	aMessage.Complete(error);

	}

/**

 * Retrives the camera handle

 */

void CMMCameraServerSession::CameraHandle(const RMessage2& aMessage)

	{

	TCameraHandle cameraHandle;

	cameraHandle.iHandle = CameraController()->CameraHandle();

	TCameraHandlePckg pckg(cameraHandle);

	aMessage.Write(TInt(0), pckg);

	aMessage.Complete(KErrNone);

	}

void CMMCameraServerSession::SetHandle (TInt aHandle)

	{

	iHandle = aHandle;

	}

void CMMCameraServerSession::SetPriority (TInt aPriority)

	{

	iPriority = aPriority;

	}

void CMMCameraServerSession::SetReserved (TBool aReserved)

	{

	iReserved = aReserved;

	}

CMMCameraServer* CMMCameraServerSession::Server()

	{

	return iCameraServer;

	}

CMMCameraServerController* CMMCameraServerSession::CameraController()

	{

	return iCameraController;

	}