--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/camerauis/cameraxui/cxengine/src/dummyengine/cxedummycamera.h	Tue Aug 31 15:03:46 2010 +0300
@@ -0,0 +1,478 @@
+/*
+* Copyright (c) 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:
+*
+*/
+#ifndef CXEDUMMYCAMERA_H
+#define CXEDUMMYCAMERA_H
+
+#if defined(CXE_USE_DUMMY_CAMERA) || defined(__WINSCW__)
+
+// Disable warnings about unused arguments
+#pragma warn_unusedarg off
+
+#include <fbs.h>
+#include <ecam/ecamplugin.h>
+#include <ecam/ecamadvsettingsintf.h>
+#include <ecam/mcamerasnapshot.h>
+#include <ecam/mcameradirectviewfinder.h>
+
+#include "cxutils.h"
+
+
+class CxeDummyCamera;
+class CxeDummyAdvancedSettings;
+class CxeDummySnapshot;
+
+class CxeDummyBuffer : public CBase,
+                       public MCameraBuffer
+{
+public:
+    CxeDummyBuffer() : iData(_L8("ABC"))
+        {
+        CX_DEBUG_IN_FUNCTION();
+        }
+
+    ~CxeDummyBuffer()
+        {
+        CX_DEBUG_ENTER_FUNCTION();
+        delete iBitmap;
+        CX_DEBUG_EXIT_FUNCTION();
+        }
+
+    void CreateBitmapL(  const TSize& aSize );
+
+public:
+    TInt NumFrames() { return 1; }
+    TDesC8* DataL(TInt aFrameIndex) { return &iData; }
+    CFbsBitmap& BitmapL(TInt aFrameIndex) { User::LeaveIfNull( iBitmap ); return *iBitmap; }
+    RChunk& ChunkL() { return iChunk; }
+    TInt ChunkOffsetL(TInt aFrameIndex) { return 0; }
+    TInt FrameSize(TInt aFrameIndex) { return 0; }
+    void Release() {}
+
+public:
+    TBuf8<128> iData;
+    CFbsBitmap* iBitmap;
+    RChunk iChunk;
+
+};
+
+class CxeDummySnapshot : public CBase,
+                         public MCameraSnapshot
+{
+public:
+    CxeDummySnapshot()
+        {
+        CX_DEBUG(("snap this = 0x%08x", this));
+        CX_DEBUG_IN_FUNCTION();
+        }
+    ~CxeDummySnapshot()
+        {
+        CX_DEBUG_ENTER_FUNCTION();
+        delete iBuffer;
+        CX_DEBUG_EXIT_FUNCTION();
+        }
+
+    TUint32 SupportedFormats() { return 0; }
+    void PrepareSnapshotL(CCamera::TFormat aFormat, const TPoint& aPosition, const TSize& aSize, const TRgb& aBgColor, TBool aMaintainAspectRatio);
+    void PrepareSnapshotL(CCamera::TFormat aFormat, const TSize& aSize, TBool aMaintainAspectRatio);
+    void SetBgColorL(const TRgb& aBgColor) {}
+    void SetPositionL(const TPoint& aPosition) {}
+    TBool IsSnapshotActive() const { return iActive; }
+    void StartSnapshot() { iActive = ETrue; }
+    void StopSnapshot() { iActive = EFalse; }
+    MCameraBuffer& SnapshotDataL(RArray<TInt>& aFrameIndexOrder) { return *iBuffer; }
+    void Release() {}
+
+private:
+    CxeDummyBuffer* iBuffer;
+    TBool iActive;
+};
+
+
+
+class CxeDummyDirectViewfinder : public CBase,
+                                 public MCameraDirectViewFinder
+{
+public:
+    CxeDummyDirectViewfinder();
+    ~CxeDummyDirectViewfinder();
+
+    void Release();
+    void PauseViewFinderDirectL();
+    void ResumeViewFinderDirectL();
+    CCamera::CCameraDirectViewFinder::TViewFinderState ViewFinderState() const;
+
+private:
+    CCamera::CCameraDirectViewFinder::TViewFinderState iState;
+};
+
+
+
+class CxeDummyAdvancedSettings : public CBase,
+                                 public MCameraAdvancedSettings,
+                                 public MCameraAdvancedSettings3
+{
+private:
+    class TCxeDummyNotification
+    {
+    public:
+        TCxeDummyNotification(TUid aEventUid, TInt aStatus) : iEventUid(aEventUid), iStatus(aStatus) {}
+        TUid iEventUid;
+        TInt iStatus;
+    };
+
+public:
+    CxeDummyAdvancedSettings(CCamera* aCamera);
+    ~CxeDummyAdvancedSettings();
+
+    void Release() {}
+    CCamera::CCameraAdvancedSettings::TCameraType CameraType() const { return CCamera::CCameraAdvancedSettings::ECameraOnBoard; }
+    CCamera::CCameraAdvancedSettings::TCameraType CameraType(TInt aCameraIndex) const { return CCamera::CCameraAdvancedSettings::ECameraOnBoard; }
+    TBool IsCameraPresent() const { return ETrue; }
+    TBool IsCameraPresent(TInt aCameraIndex) const { return ETrue; }
+    TInt CameraIndex() const { return 1; }
+    TInt SupportedStabilizationModes() const { return 0; }
+    CCamera::CCameraAdvancedSettings::TStabilizationMode StabilizationMode() const { return CCamera::CCameraAdvancedSettings::EStabilizationModeOff; }
+    void SetStabilizationMode(CCamera::CCameraAdvancedSettings::TStabilizationMode aStabilizationMode) {}
+
+    TInt SupportedFocusModes() const;
+    CCamera::CCameraAdvancedSettings::TFocusMode FocusMode() const;
+    void SetFocusMode(CCamera::CCameraAdvancedSettings::TFocusMode aFocusMode);
+
+    TInt SupportedFocusRanges() const;
+    CCamera::CCameraAdvancedSettings::TFocusRange FocusRange() const;
+    void SetFocusRange(CCamera::CCameraAdvancedSettings::TFocusRange aFocusRange);
+
+    TInt SupportedAutoFocusTypes() const;
+    CCamera::CCameraAdvancedSettings::TAutoFocusType AutoFocusType() const;
+    void SetAutoFocusType(CCamera::CCameraAdvancedSettings::TAutoFocusType aAutoFocusType);
+
+    TInt SupportedAutoFocusAreas() const { return 0; }
+    CCamera::CCameraAdvancedSettings::TAutoFocusArea AutoFocusArea() const { return CCamera::CCameraAdvancedSettings::EAutoFocusTypeAuto; }
+    void SetAutoFocusArea(CCamera::CCameraAdvancedSettings::TAutoFocusArea aAutoFocusArea) {}
+    TInt FocusDistance() const { return 0; }
+    void SetFocusDistance(TInt aDistance) {}
+    TInt GetMinFocalLength() const { return 0; }
+    void GetSupportedIsoRatesL(RArray<TInt>& aSupportedIsoRates) const {}
+    TInt IsoRate() const { return 0; }
+    void SetIsoRate(TInt aRate) {}
+    void GetAperturesL(RArray<TInt>& aFStops, TValueInfo& aInfo) const {}
+    TInt Aperture() const { return 0; }
+    void SetAperture(TInt aFStop) {}
+    void GetShutterSpeedsL(RArray<TInt>& aShutterSpeeds, TValueInfo& aInfo) const {}
+    TInt ShutterSpeed() const { return 0; }
+    void SetShutterSpeed(TInt aShutterSpeed) {}
+    TInt SupportedMeteringModes() const { return 0; }
+    CCamera::CCameraAdvancedSettings::TMeteringMode MeteringMode() const { return CCamera::CCameraAdvancedSettings::EMeteringModeAuto; }
+    void SetMeteringMode(CCamera::CCameraAdvancedSettings::TMeteringMode aMeteringMode) {}
+    TInt SupportedDriveModes() const { return 0; }
+    CCamera::CCameraAdvancedSettings::TDriveMode DriveMode() const { return CCamera::CCameraAdvancedSettings::EDriveModeAuto; }
+    void SetDriveMode(CCamera::CCameraAdvancedSettings::TDriveMode aDriveMode) {}
+    TInt SupportedBracketModes() const { return 0; }
+    CCamera::CCameraAdvancedSettings::TBracketMode BracketMode() const { return CCamera::CCameraAdvancedSettings::EBracketModeOff; }
+    void SetBracketMode(CCamera::CCameraAdvancedSettings::TBracketMode aBracketMode) {}
+    TInt SupportedBracketParameters() const { return 0; }
+    CCamera::CCameraAdvancedSettings::TBracketParameter BracketParameter() const { return CCamera::CCameraAdvancedSettings::EBracketParameterNone; }
+    void SetBracketParameter(CCamera::CCameraAdvancedSettings::TBracketParameter aBracketParameter) {}
+    TInt SupportedBracketSteps() const { return 0; }
+    CCamera::CCameraAdvancedSettings::TBracketStep BracketStep() const { return CCamera::CCameraAdvancedSettings::EBracketStepNonConfig; }
+    void SetBracketStep(CCamera::CCameraAdvancedSettings::TBracketStep aBracketStep) {}
+    void GetBracketMerge(TInt& aStartIndex, TInt& aFrames) const {}
+    void SetBracketMerge(TInt aStartIndex, TInt aFrames) {}
+    TInt SupportedFlashModes() const { return 0; }
+    CCamera::TFlash FlashMode() const { return CCamera::EFlashAuto; }
+    void SetFlashMode(CCamera::TFlash aMode) {}
+    TBool RedEyeReduceOn() const { return EFalse; }
+    void SetRedEyeReduceOn(TBool aState) {}
+    void GetFlashCompensationStepsL(RArray<TInt>& aFlashCompensationSteps, TValueInfo& aInfo) const{}
+    TInt FlashCompensationStep() const { return 0; }
+    TInt GetFlashCompensationStep(TInt& aFlashCompensationStep) const { return 0; }
+    void SetFlashCompensationStep(TInt aFlashCompensationStep) {}
+    void GetFlashCompensationRangeInSteps(TInt& aNegativeCompensation, TInt& aPositiveCompensation) const {}
+    TInt FlashCompensation() const { return 0; }
+    TInt GetFlashCompensation(TInt& aFlashCompensation) const { return 0; }
+    void SetFlashCompensation(TInt aFlashCompensationSteps) {}
+    TBool IsExternalFlashPresent() const { return EFalse; }
+    void GetManualFlashPowerLevelsL(RArray<TInt>& aManualFlashPowerLevels, TValueInfo& aInfo) const {}
+    TInt ManualFlashPowerLevel() const { return 0; }
+    void SetManualFlashPowerLevel(TInt aManualFlashPowerLevel) {}
+    TInt SupportedExposureModes() const { return 0; }
+    CCamera::TExposure ExposureMode() const { return CCamera::EExposureAuto; }
+    void SetExposureMode(CCamera::TExposure aExposureMode) {}
+    void GetExposureCompensationStepsL(RArray<TInt>& aExposureCompensationSteps, TValueInfo& aInfo) const {}
+    TInt ExposureCompensationStep() const { return 0; }
+    TInt GetExposureCompensationStep(TInt& aExposureCompensationStep) const { return 0; }
+    void SetExposureCompensationStep(TInt aExposureCompensationStep) {}
+    void GetExposureCompensationRangeInSteps(TInt& aNegativeCompensation, TInt& aPositiveCompensation) const {}
+    TInt ExposureCompensation() const { return 0; }
+    TInt GetExposureCompensation(TInt& aExposureCompensation) const { return 0; }
+    void SetExposureCompensation(TInt aExposureCompensationSteps) {}
+    TInt SupportedWhiteBalanceModes() const { return 0;}
+    CCamera::TWhiteBalance WhiteBalanceMode() const { return CCamera::EWBAuto; }
+    void SetWhiteBalanceMode(CCamera::TWhiteBalance aWhiteBalanceMode) {}
+    TBool ApertureExposureLockOn() const { return EFalse; }
+    void SetApertureExposureLockOn(TBool aAELock) {}
+    TBool ShootClickOn() const { return EFalse; }
+    void SetShootClickOn(TBool aShootClickOn) {}
+    void GetTimerIntervalsL(RArray<TInt>& aTimerIntervals, TValueInfo& aInfo) const {}
+    TInt TimerInterval() const { return 0; }
+    void SetTimerInterval(TInt aTimerInterval) {}
+    void GetTimeLapsePeriodRange(TTime& aTimeLapseMin, TTime& aTimeLapseMax) const {}
+    void GetTimeLapse(TTime& aStart, TTime& aEnd, TTime& aInterval) const {}
+    void SetTimeLapse(const TTime& aStart, const TTime& aEnd, const TTime& aInterval) {}
+    CCamera::CCameraAdvancedSettings::TPictureOrientation PictureOrientation() const { return CCamera::CCameraAdvancedSettings::EPictureOrientationUnknown; }
+    void SetPictureOrientation(CCamera::CCameraAdvancedSettings::TPictureOrientation aOrientation) {}
+    TInt SupportedPixelAspectRatios() const { return 0; }
+    CCamera::CCameraAdvancedSettings::TPixelAspectRatio PixelAspectRatio() const { return CCamera::CCameraAdvancedSettings::EPixelAspectUnknown; };
+    void SetPixelAspectRatio(CCamera::CCameraAdvancedSettings::TPixelAspectRatio aPixelAspectRatio) {}
+    TInt SupportedYuvRanges() const { return 0; }
+    CCamera::CCameraAdvancedSettings::TYuvRange YuvRange() const { return CCamera::CCameraAdvancedSettings::EYuvRangeUnknown; }
+    void SetYuvRange(CCamera::CCameraAdvancedSettings::TYuvRange aYuvRange) {}
+    TInt BurstImages() const { return 0; }
+    void SetBurstImages( TInt aImages ) {}
+
+    void GetOpticalZoomStepsL(RArray<TInt>& aOpticalZoomSteps, TValueInfo& aInfo) const {}
+    TInt OpticalZoom() const { return 0; }
+    void SetOpticalZoom(TInt aOpticalZoom) {}
+    void GetDigitalZoomStepsL(RArray<TInt>& aDigitalZoomSteps, TValueInfo& aInfo) const;
+    TInt DigitalZoom() const { return iZoomValue; }
+    void SetDigitalZoom(TInt aDigitalZoom) { iZoomValue = aDigitalZoom; }
+
+    TBool ExposureLockOn() const { return EFalse; }
+    void SetExposureLockOn(TBool aState) {}
+    TBool AutoFocusLockOn() const {return EFalse; }
+    void SetAutoFocusLockOn(TBool aState) {}
+    void GetSupportedSettingsL(RArray<TUid>& aSettings) const {}
+    void GetActiveSettingsL(RArray<TUid>& aActiveSettings) const {}
+    void GetDisabledSettingsL(RArray<TUid>& aDisabledSettings) const {}
+    TBool AutomaticSizeSelectionChangeOn() const { return EFalse; }
+    void SetAutomaticSizeSelectionChangeOn(TBool aSetOn) {}
+    void GetSupportedContinuousAutoFocusTimeoutsL(RArray<TInt>& aTimeouts, TValueInfo& aInfo) const {}
+    TInt ContinuousAutoFocusTimeout() const { return 0; }
+    void SetContinuousAutoFocusTimeout(TInt aTimeout) {}
+    TInt SupportedStabilizationEffects() const { return 0; }
+    CCamera::CCameraAdvancedSettings::TStabilizationEffect StabilizationEffect() const { return CCamera::CCameraAdvancedSettings::EStabilizationOff; }
+    void SetStabilizationEffect(CCamera::CCameraAdvancedSettings::TStabilizationEffect aEffect) {}
+    TInt SupportedStabilizationComplexityValues() const { return 0; }
+    CCamera::CCameraAdvancedSettings::TStabilizationAlgorithmComplexity StabilizationComplexity() const { return CCamera::CCameraAdvancedSettings::EStabilizationComplexityAuto; }
+    void SetStabilizationComplexity(CCamera::CCameraAdvancedSettings::TStabilizationAlgorithmComplexity aComplexity) {}
+    CCamera::CCameraAdvancedSettings::TWBUnits SupportedWBUnits() const { return CCamera::CCameraAdvancedSettings::EWBUnknown; }
+    void GetWBRgbValue(TRgb& aValue) const {}
+    void SetWBRgbValue(const TRgb& aValue) {}
+    void GetWBSupportedColorTemperaturesL(RArray<TInt>& aWBColorTemperatures, TValueInfo& aInfo) const {}
+    TInt WBColorTemperature() const { return 0; }
+    void SetWBColorTemperature(TInt aWBColorTemperature) {}
+
+
+    // from MCameraAdvancedSettings3
+    void GetSupportedISORateTypeL(TInt& aSupportedISORateTypes) const {}
+
+    void SetISORate(CCamera::CCameraAdvancedSettings::TISORateType aISORateType, TInt aParam){}
+
+    void GetISORateL(CCamera::CCameraAdvancedSettings::TISORateType& aISORateType, TInt& aParam, TInt& aISORate) const{}
+
+    void SetReferenceScreen(CWsScreenDevice& aScreenDevice){}
+
+
+    void GetDigitalZoomStepsForStillL(RArray<TInt>& aDigitalZoomSteps, TValueInfo& aInfo, TInt aSizeIndex,
+                    CCamera::TFormat aFormat, TBool& aIsInfluencePossible) const;
+
+    void GetDigitalZoomStepsForVideoL(RArray<TInt>& aDigitalZoomSteps, TValueInfo& aInfo, TInt aFrameRateIndex,
+                    TInt aSizeIndex, CCamera::TFormat aFormat, TBool& aIsInfluencePossible, CCamera::TExposure aExposure) const{}
+
+    void GetPreCaptureWarningSupportedL(CCamera::CCameraAdvancedSettings::TCameraMode aCameraMode, TInt& aPreCaptureWarningSupported) const{}
+
+    void SubscribeToPreCaptureWarningL(TInt aPreCaptureWarning){}
+
+    void UnSubscribePreCaptureWarningL(){}
+
+    void GetPreCaptureWarningL(TInt& aPreCaptureWarning) const{}
+
+    void GetSupportedAFAssistantLightL(TInt& aSupportedAFAssistantLight) const{}
+
+    void GetAFAssistantLightL(CCamera::CCameraAdvancedSettings::TAFAssistantLight& aAFAssistantLight) const{}
+
+    void SetAFAssistantLight(CCamera::CCameraAdvancedSettings::TAFAssistantLight aAFAssistantLight){}
+
+
+private:
+    void queueClientNotification(TUid aUid, TInt aStatus);
+    void doClientNotification();
+    static TInt clientNotificationCallback(TAny* aParam);
+
+private:
+
+    CCamera* iCamera; // Not own
+    CPeriodic* iNotificationTimer;
+    RArray<TCxeDummyNotification> iClientNofications;
+
+    CCamera::CCameraAdvancedSettings::TFocusMode iFocusMode;
+    CCamera::CCameraAdvancedSettings::TFocusRange iFocusRange;
+    CCamera::CCameraAdvancedSettings::TAutoFocusType iFocusType;
+
+    TInt iZoomValue;
+};
+
+
+class CxeDummyImageProcessing : public CBase, public MCameraImageProcessing
+{
+public:
+
+
+    void Release(){};
+    void GetSupportedTransformationsL(RArray<TUid>& aTransformations) const{};
+    void GetActiveTransformationsL(RArray<TUid>& aTransformations) const{};
+    void GetTransformationSupportedValuesL(TUid aTransformation, RArray<TInt>& aValues, TValueInfo& aInfo) const{};
+    TInt TransformationValue(TUid aTransformation) const{return KErrNotFound;};
+    TInt GetTransformationValue(TUid aTransformation, TInt& aTransformationValue) const{return KErrNotFound;};
+    void SetTransformationValue(TUid aTransformation, TInt aValue){};
+    void GetActiveTransformSequenceL(RArray<TUid>& aTransformSequence) const{};
+    void SetActiveTransformSequenceL(RArray<TUid>& aTransformSequence){};
+    void SetSourceRect(const TRect& aRect){};
+    void GetSourceRect(TRect& aRect) const{};
+
+};
+
+
+enum TCxeDummyCommand
+    {
+    EReserve,
+    EPowerOn,
+    EProvideSnapshot,
+    EProvideStillImage
+    };
+
+enum TCxeState
+    {
+    EStReleased,
+    EStReserving,
+    EStReserved,
+    EStPoweringOn,
+    EStPowerOn,
+    EStImagePrepared,
+    EStVideoPrepared
+    };
+
+class CxeDummyCamera : public CCameraPlugin
+{
+    friend class CxeDummyAdvancedSettings;
+
+public:
+    static TInt CamerasAvailable() { return 2; }
+
+    static CxeDummyCamera* NewL(MCameraObserver& aObserver,TInt aCameraIndex, TInt aCameraVersion) { return NULL; }
+    static CxeDummyCamera* NewDuplicateL(MCameraObserver& aObserver,TInt aCameraHandle, TInt aCameraVersion) { return NULL; }
+    static CxeDummyCamera* NewL(MCameraObserver2& aObserver,TInt aCameraIndex,TInt aPriority, TInt aCameraVersion);
+    static CxeDummyCamera* NewDuplicateL(MCameraObserver2& aObserver,TInt aCameraHandle, TInt aCameraVersion) { return NULL; }
+
+    void Construct2L( MCameraObserver2 &, TInt, TInt ) {}
+    void Construct2L( MCameraObserver2 &, TInt ) {}
+    void Construct2L( MCameraObserver &, TInt ) {}
+    void Construct2DupL( MCameraObserver2 &, TInt ) {}
+    void Construct2DupL( MCameraObserver &, TInt ) {}
+
+    ~CxeDummyCamera();
+
+    void CameraInfo(TCameraInfo& aInfo) const { aInfo = iInfo; }
+    void Reserve();
+    void Release();
+    void PowerOn();
+    void PowerOff();
+    TInt Handle() { return 0; }
+
+    void SetZoomFactorL(TInt aZoomFactor) {}
+    TInt ZoomFactor() const { return 0; }
+    void SetDigitalZoomFactorL(TInt aDigitalZoomFactor) { iZoom = aDigitalZoomFactor; }
+    TInt DigitalZoomFactor() const { return iZoom; }
+    void SetContrastL(TInt aContrast) { iContrast = aContrast; }
+    TInt Contrast() const { return iContrast; }
+    void SetBrightnessL(TInt aBrightness) { iBrightness = aBrightness; }
+    TInt Brightness() const { return iBrightness; }
+    void SetFlashL(TFlash aFlash ) { iFlash = aFlash; }
+    TFlash Flash() const { return iFlash; }
+    void SetExposureL(TExposure aExposure ) { iExposure = aExposure; }
+    TExposure Exposure() const { return iExposure; }
+    void SetWhiteBalanceL(TWhiteBalance aWhiteBalance ) { iWb = aWhiteBalance; }
+    TWhiteBalance WhiteBalance() const { return iWb; }
+
+    void StartViewFinderDirectL(RWsSession& aWs,CWsScreenDevice& aScreenDevice,RWindowBase& aWindow,TRect& aScreenRect) {}
+    void StartViewFinderDirectL(RWsSession& aWs,CWsScreenDevice& aScreenDevice,RWindowBase& aWindow,TRect& aScreenRect,TRect& aClipRect) {}
+    void StartViewFinderBitmapsL(TSize& aSize) {}
+    void StartViewFinderBitmapsL(TSize& aSize,TRect& aClipRect) {}
+    void StartViewFinderL(TFormat aImageFormat,TSize& aSize) {}
+    void StartViewFinderL(TFormat aImageFormat,TSize& aSize,TRect& aClipRect) {}
+    void StopViewFinder() {}
+    TBool ViewFinderActive() const { return EFalse; }
+    void SetViewFinderMirrorL(TBool aMirror) {}
+    TBool ViewFinderMirror() const { return EFalse; }
+    void PrepareImageCaptureL(TFormat aImageFormat,TInt aSizeIndex)
+        {
+        CX_DEBUG_IN_FUNCTION();
+        }
+    void PrepareImageCaptureL(TFormat aImageFormat,TInt aSizeIndex,const TRect& aClipRect)
+        {
+        CX_DEBUG_IN_FUNCTION();
+        }
+    void CaptureImage();
+    void CancelCaptureImage() {}
+    void EnumerateCaptureSizes(TSize& aSize,TInt aSizeIndex,TFormat aFormat) const;
+    void PrepareVideoCaptureL(TFormat aFormat,TInt aSizeIndex,TInt aRateIndex,TInt aBuffersToUse,TInt aFramesPerBuffer) {}
+    void PrepareVideoCaptureL(TFormat aFormat,TInt aSizeIndex,TInt aRateIndex,TInt aBuffersToUse,TInt aFramesPerBuffer,const TRect& aClipRect) {}
+    void StartVideoCapture() {}
+    void StopVideoCapture() {}
+    TBool VideoCaptureActive() const { return EFalse; }
+    void EnumerateVideoFrameSizes(TSize& aSize,TInt aSizeIndex,TFormat aFormat) const {}
+    void EnumerateVideoFrameRates(TReal32& aRate,TInt aRateIndex,TFormat aFormat,TInt aSizeIndex,TExposure aExposure = EExposureAuto) const {}
+    void GetFrameSize(TSize& aSize) const {}
+    TReal32 FrameRate() const  { return 0.0; }
+    TInt BuffersInUse() const { return 0; }
+    TInt FramesPerBuffer() const { return 0; }
+    void SetJpegQuality(TInt aQuality) {}
+    TInt JpegQuality() const { return 0; }
+    TAny* CustomInterface(TUid aInterface);
+    TInt CameraVersion() { return 1; }
+
+private:
+    CxeDummyCamera(MCameraObserver2& aObserver,TInt aCameraIndex,TInt aPriority, TInt aCameraVersion);
+    void doCommand( TCxeDummyCommand aCmd );
+    static TInt callBack( TAny* aParam );
+    TInt doHandleCallback();
+
+private:
+    CPeriodic* iCommandTimer;
+    RArray<TCxeDummyCommand> iCommandBuf;
+    MCameraObserver2& iObserver;
+    TCameraInfo iInfo;
+    TWhiteBalance iWb;
+    TExposure iExposure;
+    TFlash iFlash;
+    TInt iBrightness;
+    TInt iContrast;
+    TInt iZoom;
+    TCxeState iState;
+    CxeDummyAdvancedSettings* iAdvancedSettings;
+    CxeDummyDirectViewfinder* iDirectViewfinder;
+    CxeDummySnapshot* iSnapshot;
+    CxeDummyBuffer* iStillImage;
+    CxeDummyImageProcessing* iImageProcessing;
+    };
+
+// Restore warnings about unused arguments
+#pragma warn_unusedarg reset
+
+#endif // defined(CXE_USE_DUMMY_CAMERA) || defined(__WINSCW__)
+
+#endif // CXEDUMMYCAMERA_H