--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/imagingandcamerafws/cameraunittest/src/ECamUnitTestPlugin/ECamUnitTestPlugin.cpp Tue Feb 02 01:56:55 2010 +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;
+ }
+