diff -r 000000000000 -r bde4ae8d615e os/mm/imagingandcamerafws/cameraunittest/src/ECamUnitTestPlugin/ECamUnitTestPlugin.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/os/mm/imagingandcamerafws/cameraunittest/src/ECamUnitTestPlugin/ECamUnitTestPlugin.cpp	Fri Jun 15 03:10:57 2012 +0200
@@ -0,0 +1,681 @@
+// Copyright (c) 2004-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 <f32file.h>
+#include <ecom/ecom.h>
+#include <ecom/implementationproxy.h>
+#include <ecamuids.hrh>
+#include <ecam.h>
+#include <ecam/ecamadvsettingsintfuids.hrh>
+#include "ECamUnitTestPlugin.h"
+#include "ECamUnitTestPluginUids.hrh"
+#include "AdvancedSettings.h"
+#include <ecam/ecamcommonuids.hrh>
+#include "EnhanceFunctionality.h"
+#include "directviewfinder.h"
+#include "extended_functionality.h"
+
+const TBool KTestCamerasPresent[] = {ETrue, EFalse, EFalse};
+const CCamera::CCameraAdvancedSettings::TCameraType KTestCamerasTypes[] = 	
+									{
+									CCamera::CCameraAdvancedSettings::ECameraOnBoard, 
+									CCamera::CCameraAdvancedSettings::ECameraPluggable, 
+									CCamera::CCameraAdvancedSettings::ECameraPluggable
+									}; 
+
+//
+// Main stuff
+//
+static void Panic(TInt aReason)
+	{
+	_LIT(KDllName, "ECam Unit Test Plugin");
+	User::Panic(KDllName, aReason);
+	}
+	
+//
+// CCamUnitTestPlugin
+//
+CCamUnitTestPlugin::CCamUnitTestPlugin()
+	{
+	iPresets.Reset();
+	iSupportedISORates.Reset();
+	iIsoRate = KDefaultIsoRate;
+	for ( TInt i = 0; i< KECamSetAvailableCameras; i++)
+		{
+		iCameras[i] = KTestCamerasPresent[i]; 
+		iCameraTypes[i] = KTestCamerasTypes[i];
+		}	
+		
+	iVFHandleGenerater = 0;
+	}
+	
+CCamUnitTestPlugin::~CCamUnitTestPlugin()
+	{
+	iSupportedISORates.Close();
+	}
+	
+CCamUnitTestPlugin* CCamUnitTestPlugin::NewL()
+	{
+	FileDependencyUtil::CheckFileDependencyL();
+	return new (ELeave) CCamUnitTestPlugin;
+	}
+	
+// 
+// 2nd stage ConstructL calls called by framework
+//
+
+void CCamUnitTestPlugin::Construct2L(MCameraObserver& aObserver,TInt aCameraIndex)
+	{
+	iObserver = &aObserver;
+	iCameraIndex = aCameraIndex;
+	}
+	
+void CCamUnitTestPlugin::Construct2DupL(MCameraObserver& aObserver,TInt aCameraHandle)
+	{
+	iObserver = &aObserver;
+	iCameraHandle = aCameraHandle;
+	}
+
+
+void CCamUnitTestPlugin::Construct2L(MCameraObserver2& aObserver,TInt aCameraIndex,TInt aPriority)
+	{
+	iObserver2 = &aObserver;
+	iCameraIndex = aCameraIndex;
+	iPriority = aPriority;
+			
+	iSupportedISORates.AppendL(KMinIsoRate);
+	iSupportedISORates.AppendL(KDefaultIsoRate);
+	iSupportedISORates.AppendL(KIsoRate1);
+	iSupportedISORates.AppendL(KIsoRate2);
+	iSupportedISORates.AppendL(KIsoRate3);
+	iSupportedISORates.AppendL(KIsoRate4);
+	iSupportedISORates.AppendL(KIsoRate5);
+	iSupportedISORates.AppendL(KMaxIsoRate);
+	}
+	
+void CCamUnitTestPlugin::Construct2DupL(MCameraObserver2& aObserver,TInt aCameraHandle)
+	{
+	iObserver2 = &aObserver;
+	iCameraHandle = aCameraHandle;
+	
+		
+	iSupportedISORates.AppendL(KMinIsoRate);
+	iSupportedISORates.AppendL(KDefaultIsoRate);
+	iSupportedISORates.AppendL(KIsoRate1);
+	iSupportedISORates.AppendL(KIsoRate2);
+	iSupportedISORates.AppendL(KIsoRate3);
+	iSupportedISORates.AppendL(KIsoRate4);
+	iSupportedISORates.AppendL(KIsoRate5);
+	iSupportedISORates.AppendL(KMaxIsoRate);
+	}
+
+
+	
+//
+// Dummy versions of virtual functions
+//
+
+void CCamUnitTestPlugin::CameraInfo(TCameraInfo& /*aInfo*/) const
+	{
+	}
+
+void CCamUnitTestPlugin::Reserve()
+	{
+	}
+
+
+void CCamUnitTestPlugin::Release()
+	{
+	}
+
+void CCamUnitTestPlugin::PowerOn()
+	{
+	}
+
+void CCamUnitTestPlugin::PowerOff()
+	{
+	}
+
+TInt CCamUnitTestPlugin::Handle()
+	{
+	return 0;
+	}
+
+void CCamUnitTestPlugin::SetZoomFactorL(TInt /*aZoomFactor = 0*/)
+	{
+	}
+
+TInt CCamUnitTestPlugin::ZoomFactor() const
+	{
+	return 0;
+	}
+
+void CCamUnitTestPlugin::SetDigitalZoomFactorL(TInt /*aDigitalZoomFactor = 0*/)
+	{
+	}
+
+TInt CCamUnitTestPlugin::DigitalZoomFactor() const
+	{
+	return 0;
+	}
+
+void CCamUnitTestPlugin::SetContrastL(TInt /*aContrast*/)
+	{
+	}
+
+TInt CCamUnitTestPlugin::Contrast() const
+	{
+	return 0;
+	}
+
+void CCamUnitTestPlugin::SetBrightnessL(TInt /*aBrightness*/)
+	{
+	}
+
+TInt CCamUnitTestPlugin::Brightness() const
+	{
+	return 0;
+	}
+
+
+void CCamUnitTestPlugin::SetFlashL(TFlash /*aFlash = EFlashNone*/)
+	{
+	Panic(EPanicUnimplemented);
+	}
+
+CCamera::TFlash CCamUnitTestPlugin::Flash() const
+	{
+	Panic(EPanicUnimplemented);
+	return EFlashNone;
+	}
+
+void CCamUnitTestPlugin::SetExposureL(TExposure /*aExposure = EExposureAuto*/)
+	{
+	Panic(EPanicUnimplemented);
+	}
+
+CCamera::TExposure CCamUnitTestPlugin::Exposure() const
+	{
+	Panic(EPanicUnimplemented);
+	return EExposureAuto;
+	}
+
+void CCamUnitTestPlugin::SetWhiteBalanceL(TWhiteBalance /*aWhiteBalance = EWBAuto*/)
+	{
+	Panic(EPanicUnimplemented);
+	}
+
+CCamera::TWhiteBalance CCamUnitTestPlugin::WhiteBalance() const
+	{
+	Panic(EPanicUnimplemented);
+	return EWBAuto;
+	}
+
+void CCamUnitTestPlugin::StartViewFinderDirectL(RWsSession& /*aWs*/,CWsScreenDevice& /*aScreenDevice*/,RWindowBase& /*aWindow*/,TRect& /*aScreenRect*/)
+	{
+	Panic(EPanicUnimplemented);
+	}
+
+void CCamUnitTestPlugin::StartViewFinderDirectL(RWsSession& /*aWs*/,CWsScreenDevice& /*aScreenDevice*/,RWindowBase& /*aWindow*/,TRect& /*aScreenRect*/,TRect& /*aClipRect*/)
+	{
+	Panic(EPanicUnimplemented);
+	}
+
+void CCamUnitTestPlugin::StartViewFinderBitmapsL(TSize& /*aSize*/)
+	{
+	Panic(EPanicUnimplemented);
+	}
+	
+void CCamUnitTestPlugin::StartViewFinderBitmapsL(TSize& /*aSize*/,TRect& /*aClipRect*/)
+	{
+	Panic(EPanicUnimplemented);
+	}
+
+
+void CCamUnitTestPlugin::StartViewFinderL(TFormat /*aImageFormat*/,TSize& /*aSize*/)
+	{
+	Panic(EPanicUnimplemented);
+	}
+
+void CCamUnitTestPlugin::StartViewFinderL(TFormat /*aImageFormat*/,TSize& /*aSize*/,TRect& /*aClipRect*/)
+	{
+	Panic(EPanicUnimplemented);
+	}
+
+
+void CCamUnitTestPlugin::StopViewFinder()
+	{
+	Panic(EPanicUnimplemented);
+	}
+
+TBool CCamUnitTestPlugin::ViewFinderActive() const
+	{
+	Panic(EPanicUnimplemented);
+	return EFalse;
+	}
+
+void CCamUnitTestPlugin::SetViewFinderMirrorL(TBool /*aMirror*/)
+	{
+	Panic(EPanicUnimplemented);
+	}
+
+TBool CCamUnitTestPlugin::ViewFinderMirror() const
+	{
+	Panic(EPanicUnimplemented);
+	return EFalse;
+	}
+
+void CCamUnitTestPlugin::PrepareImageCaptureL(TFormat /*aImageFormat*/,TInt /*aSizeIndex*/)
+	{
+	Panic(EPanicUnimplemented);
+	}
+
+void CCamUnitTestPlugin::PrepareImageCaptureL(TFormat /*aImageFormat*/,TInt /*aSizeIndex*/,const TRect& /*aClipRect*/)
+	{
+	Panic(EPanicUnimplemented);
+	}
+
+void CCamUnitTestPlugin::CaptureImage()
+	{
+	Panic(EPanicUnimplemented);
+	}
+
+void CCamUnitTestPlugin::CancelCaptureImage()
+	{
+	Panic(EPanicUnimplemented);
+	}
+
+void CCamUnitTestPlugin::EnumerateCaptureSizes(TSize& /*aSize*/,TInt /*aSizeIndex*/,TFormat /*aFormat*/) const
+	{
+	Panic(EPanicUnimplemented);
+	}
+
+void CCamUnitTestPlugin::PrepareVideoCaptureL(TFormat /*aFormat*/,TInt /*aSizeIndex*/,TInt /*aRateIndex*/,TInt /*aBuffersToUse*/,TInt /*aFramesPerBuffer*/)
+	{
+	Panic(EPanicUnimplemented);
+	}
+
+void CCamUnitTestPlugin::PrepareVideoCaptureL(TFormat /*aFormat*/,TInt /*aSizeIndex*/,TInt /*aRateIndex*/,TInt /*aBuffersToUse*/,TInt /*aFramesPerBuffer*/,const TRect& /*aClipRect*/)
+	{
+	Panic(EPanicUnimplemented);
+	}
+
+void CCamUnitTestPlugin::StartVideoCapture()
+	{
+	Panic(EPanicUnimplemented);
+	}
+
+void CCamUnitTestPlugin::StopVideoCapture()
+	{
+	Panic(EPanicUnimplemented);
+	}
+
+TBool CCamUnitTestPlugin::VideoCaptureActive() const
+	{
+	Panic(EPanicUnimplemented);
+	return EFalse;
+	}
+
+void CCamUnitTestPlugin::EnumerateVideoFrameSizes(TSize& /*aSize*/,TInt /*aSizeIndex*/,TFormat /*aFormat*/) const
+	{
+	Panic(EPanicUnimplemented);
+	}
+
+void CCamUnitTestPlugin::EnumerateVideoFrameRates(TReal32& /*aRate*/,TInt /*aRateIndex*/,TFormat /*aFormat*/,TInt /*aSizeIndex*/,TExposure /*aExposure = EExposureAuto*/) const
+	{
+	Panic(EPanicUnimplemented);
+	}
+
+void CCamUnitTestPlugin::GetFrameSize(TSize& /*aSize*/) const
+	{
+	Panic(EPanicUnimplemented);
+	}
+
+TReal32 CCamUnitTestPlugin::FrameRate() const
+	{
+	Panic(EPanicUnimplemented);
+	return 0.0;
+	}
+
+TInt CCamUnitTestPlugin::BuffersInUse() const
+	{
+	Panic(EPanicUnimplemented);
+	return 0;
+	}
+
+TInt CCamUnitTestPlugin::FramesPerBuffer() const
+	{
+	Panic(EPanicUnimplemented);
+	return 0;
+	}
+
+void CCamUnitTestPlugin::SetJpegQuality(TInt /*aQuality*/)
+	{
+	Panic(EPanicUnimplemented);
+	}
+
+TInt CCamUnitTestPlugin::JpegQuality() const
+	{
+	Panic(EPanicUnimplemented);
+	return 0;
+	}
+
+TAny* CCamUnitTestPlugin::CustomInterface(TUid aInterfaceUid)
+	{
+	TAny* advSettingObject = NULL;
+	// use the fact that the parent is a friend of the class
+	
+	TRAPD(err, advSettingObject = CCamera::CustomInterface(aInterfaceUid));
+	
+	if (err == KErrNone)
+		{
+		return advSettingObject;
+		}
+	/*else if (err == KErrNoMemory)
+		{
+		User::Leave(KErrNoMemory);
+		}*/
+	return NULL;
+	}
+
+
+TAny* CCamera::CustomInterface(TUid aInterfaceUid)
+	{
+	switch (aInterfaceUid.iUid)
+		{
+		// presets
+		case KECamPresetsUidValue:
+			{
+			CCamera::CCameraPresets* presets = new (ELeave)CCamera::CCameraPresets(*this); 
+			CleanupStack::PushL(presets);
+			presets->ConstructL();
+			CleanupStack::Pop(presets);
+			
+			return static_cast<TAny*>(presets); 
+			}	
+
+		case KECamMCameraPresetsUidValue:
+			{
+			return static_cast<MCameraPresets*>(CCamPresets::NewL(static_cast<CCamUnitTestPlugin&>(*this)));
+			}
+			
+		case KECamMCameraPresets2UidValue:
+			{
+			return static_cast<MCameraPresets2*>(CCamPresets::NewL(static_cast<CCamUnitTestPlugin&>(*this)));
+			}
+			
+		// image processing 
+		case KECamImageProcessingUidValue:
+			{
+			CCamera::CCameraImageProcessing* processing = new (ELeave)CCamera::CCameraImageProcessing(*this); 
+			CleanupStack::PushL(processing);
+			processing->ConstructL();
+			CleanupStack::Pop(processing);
+			
+			return static_cast<TAny*>(processing); 
+			}
+						
+		case KECamMCameraImageProcessingUidValue:
+			{
+			return static_cast<MCameraImageProcessing*>(CCamImgProc::NewL(static_cast<CCamUnitTestPlugin&>(*this)));
+			}
+			
+		case KECamMCameraImageProcessing2UidValue:
+			{
+			return static_cast<MCameraImageProcessing2*>(CCamImgProc::NewL(static_cast<CCamUnitTestPlugin&>(*this)));
+			}
+			
+		case KECamMCameraImageProcessing3UidValue:
+			{
+			return static_cast<MCameraImageProcessing3*>(CCamImgProc::NewL(static_cast<CCamUnitTestPlugin&>(*this)));
+			}
+			
+		// advanced settings
+		case KECamAdvancedSettingUidValue:
+			{
+			CCamera::CCameraAdvancedSettings* settings = new (ELeave)CCamera::CCameraAdvancedSettings(*this); 
+			CleanupStack::PushL(settings);
+			settings->ConstructL();
+			CleanupStack::Pop(settings);
+			
+			return static_cast<TAny*>(settings); 
+			}
+			
+		case KECamMCameraAdvancedSettingsUidValue:
+			{
+			return static_cast<MCameraAdvancedSettings*>(CCamAdvSet::NewL(static_cast<CCamUnitTestPlugin&>(*this)));
+			}
+		
+		case KECamMCameraAdvancedSettings2UidValue:
+			{
+			return static_cast<MCameraAdvancedSettings2*>(CCamAdvSet::NewL(static_cast<CCamUnitTestPlugin&>(*this)));
+			}	
+			
+		case KECamMCameraAdvancedSettings3UidValue:
+			{
+			return static_cast<MCameraAdvancedSettings3*>(CCamAdvSet::NewL(static_cast<CCamUnitTestPlugin&>(*this)));
+			}
+			
+		case KECamMCameraAdvancedSettings4UidValue:
+			{
+			return static_cast<MCameraAdvancedSettings4*>(CCamAdvSet::NewL(static_cast<CCamUnitTestPlugin&>(*this)));
+			}
+		
+		case KUidCameraManagementUidValue:
+			{
+			return (CCamManagement::NewL(static_cast<CCamUnitTestPlugin&>(*this)));
+			}
+
+		//		
+		// enhance camera functionality //
+		//
+		case KECamHistogramUidValue:
+			{
+			return static_cast<TAny*>(CCamera::CCameraHistogram::NewL(*this)); 
+			}
+			
+		case KECamMCameraHistogramUidValue:
+			{
+			return static_cast<MCameraHistogram*>(CCamHistogram::NewL(static_cast<CCamUnitTestPlugin&>(*this)));
+			}
+			
+		case KECamOverlayUidValue:
+			{
+			return static_cast<TAny*>(CCamera::CCameraOverlay::NewL(*this)); 
+			}	
+			
+		case KECamMCameraOverlayUidValue:
+			{
+			return static_cast<MCameraOverlay*>(CCamOverlay::NewL(static_cast<CCamUnitTestPlugin&>(*this)));
+			}	
+			
+		case KECamMCameraOverlay2UidValue:
+			{
+			return static_cast<MCameraOverlay2*>(CCamOverlay::NewL(static_cast<CCamUnitTestPlugin&>(*this)));
+			}
+			
+		case KECamSnapshotUidValue:
+			{
+			return static_cast<TAny*>(CCamera::CCameraSnapshot::NewL(*this)); 
+			}
+					
+		case KECamMCameraSnapshotUidValue:
+			{
+			return static_cast<MCameraSnapshot*>(CCamSnapshot::NewL(static_cast<CCamUnitTestPlugin&>(*this)));
+			}	
+			
+		//		
+		// direct viewfinder functionality //
+		//			
+		case KECamDirectViewFinderUidValue:
+			{
+			return static_cast<TAny*>(CCamera::CCameraDirectViewFinder::NewL(*this));  
+			}		
+			
+		case KECamMCameraDirectViewFinderUidValue:
+			{
+			return static_cast<MCameraDirectViewFinder*>(CCamDirectViewFinder::NewL(static_cast<CCamUnitTestPlugin&>(*this)));
+			}	
+		
+		case KECamMCameraPreImageCaptureControlUidValue:
+			{
+			return static_cast<MCameraPreImageCaptureControl*>(CCamPreImageCaptureControl::NewL(static_cast<CCamUnitTestPlugin&>(*this)));
+			}
+		
+		case KECamMCameraImageCaptureUidValue:
+			{
+			return static_cast<MCameraImageCapture*>(CCamImageCapture::NewL(static_cast<CCamUnitTestPlugin&>(*this)));
+			}
+
+		case KECamMCameraVideoCaptureControlUidValue:
+			{
+			return static_cast<MCameraVideoCaptureControl*>(CCamVideoCaptureControl::NewL(static_cast<CCamUnitTestPlugin&>(*this)));
+			}
+			
+		case KECamMCameraClientViewFinderUidValue:
+			{
+			return static_cast<MCameraClientViewFinder*>(CCamClientViewFinder::NewL(static_cast<CCamUnitTestPlugin&>(*this)));
+			}
+			
+		case KECamMCameraBaseClientViewFinderUidValue:
+			{
+			return static_cast<MCameraViewFinder*>(CCamClientViewFinder::NewL(static_cast<CCamUnitTestPlugin&>(*this)));
+			}
+			
+		case KECamMCameraV2DirectViewFinderUidValue:
+			{
+			return static_cast<MCameraV2DirectViewFinder*>(CCamV2DirectViewFinder::NewL(static_cast<CCamUnitTestPlugin&>(*this)));
+			}
+			
+		case KECamMCameraBaseV2DirectViewFinderUidValue:
+			{
+			return static_cast<MCameraViewFinder*>(CCamV2DirectViewFinder::NewL(static_cast<CCamUnitTestPlugin&>(*this)));
+			}
+		default:
+			{		
+			return NULL;
+			}
+		}
+	}
+	
+void CCamUnitTestPlugin::GenerateVFHandle(TInt& aVFHandle)
+	{
+	iVFHandleGenerater++;
+	aVFHandle = iVFHandleGenerater;
+	}
+	
+void CCamUnitTestPlugin::Notify(TUid aMessageId, TInt aError)
+	{
+	if (iObserver2 != NULL)
+		{
+		iObserver2->HandleEvent(TECAMEvent(aMessageId, aError));
+		}
+	}
+	
+void CCamUnitTestPlugin::Notify2(TUid aMessageId, TInt aError, TInt aParam)
+	{
+	if (iObserver2 != NULL)
+		{
+		iObserver2->HandleEvent(TECAMEvent2(aMessageId, aError, aParam));	
+		}
+	}
+	
+//
+// CCamUnitTestPluginInfo
+//
+
+CCamUnitTestPluginInfo::CCamUnitTestPluginInfo()
+	{
+	}
+	
+CCamUnitTestPluginInfo::~CCamUnitTestPluginInfo()
+	{
+	}
+	
+CCamUnitTestPluginInfo* CCamUnitTestPluginInfo::NewL()
+	{
+	FileDependencyUtil::CheckFileDependencyL();
+	return new (ELeave) CCamUnitTestPluginInfo;
+	}
+	
+TInt CCamUnitTestPluginInfo::CamerasAvailable()
+	{
+	return KECamSetAvailableCameras;
+	}
+
+//
+// CCamUnitTestPluginSecureId
+//	
+
+CCamUnitTestPluginSecureId::CCamUnitTestPluginSecureId()
+	{
+	}
+	
+CCamUnitTestPluginSecureId::~CCamUnitTestPluginSecureId()
+	{
+	}
+	
+CCamUnitTestPluginSecureId* CCamUnitTestPluginSecureId::NewL()
+	{
+	CCamUnitTestPluginSecureId* pluginSecureId = new (ELeave) CCamUnitTestPluginSecureId;
+	return pluginSecureId;
+	}
+	
+void CCamUnitTestPluginSecureId::Release()
+	{
+	delete this;
+	}
+	
+void CCamUnitTestPluginSecureId::GetSecureIdL(TInt& aSecureId) const
+	{
+	TSecureId secureId = User::CreatorSecureId();	
+	aSecureId = secureId.iId;
+	}
+
+void FileDependencyUtil::CheckFileDependencyL()
+	{
+	RFs fsSession;
+  	RFile file;
+    
+  	User::LeaveIfError(fsSession.Connect());
+  	CleanupClosePushL(fsSession);
+    TInt err = file.Open(fsSession, KECamUnitTestPluginName, EFileRead);
+  	file.Close();
+  	
+  	if(err != KErrNone)
+  		{
+	    User::LeaveIfError(KErrNotSupported);
+  		}
+  	CleanupStack::PopAndDestroy(); //fsSession 
+	
+	}
+
+// __________________________________________________________________________
+// Exported proxy for instantiation method resolution
+// Define the interface UIDs
+const TImplementationProxy ImplementationTable[] = 
+	{
+		IMPLEMENTATION_PROXY_ENTRY(KUidCameraUnitTestPlugin,	CCamUnitTestPlugin::NewL),
+		IMPLEMENTATION_PROXY_ENTRY(KUidCameraUnitTestInfo,	CCamUnitTestPluginInfo::NewL),
+		IMPLEMENTATION_PROXY_ENTRY(KUidCameraUnitTestSecureId,	CCamUnitTestPluginSecureId::NewL)
+	};
+
+EXPORT_C const TImplementationProxy* ImplementationGroupProxy(TInt& aTableCount)
+	{
+	aTableCount = sizeof(ImplementationTable) / sizeof(TImplementationProxy);
+
+	return ImplementationTable;
+	}
+