mmplugins/cameraplugins/source/mmcameraclientplugin/mmcameraserver/src/mmcameraserversession.cpp
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/mmplugins/cameraplugins/source/mmcameraclientplugin/mmcameraserver/src/mmcameraserversession.cpp Tue Feb 02 01:56:55 2010 +0200
@@ -0,0 +1,782 @@
+// 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;
+ }