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

 	}