--- a/mmplugins/cameraplugins/source/testcamera/test_advanced_settings.cpp Thu Mar 25 11:21:36 2010 +0900
+++ b/mmplugins/cameraplugins/source/testcamera/test_advanced_settings.cpp Tue Oct 19 11:48:59 2010 +0900
@@ -1,1602 +1,1602 @@
-// Copyright (c) 2007-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:
-// testadvancedsettings.cpp
-//
-//
-
-#include "test_advanced_settings.h"
-#include <ecamerrors.h>
-#include "ecamversion.h"
-
-CTestCamAdvSet::CTestCamAdvSet(CTestCamera& aOwner): iOwner(aOwner)
- {
- Init();
- }
-
-CTestCamAdvSet::~CTestCamAdvSet()
- {
- iSupportedISORates.Close();
- iSupportedApertures.Close();
- iSupportedShutterSpeeds.Close();
-
- CDataGlobal* globalData = static_cast <CDataGlobal*> (Dll::Tls());
- if(globalData != NULL)
- {
- if(!globalData->iTestCamPresets && !globalData->iTestCamSnapshot && !globalData->iTestCamImgProc)
- {
- delete globalData;
- Dll::FreeTls();
- }
- else
- {
- globalData->iTestCamAdvSet = NULL;
- Dll::SetTls(globalData);
- }
- }
- }
-
-CTestCamAdvSet* CTestCamAdvSet::NewL(CTestCamera& aOwner)
- {
- CDataGlobal* globalData = static_cast <CDataGlobal*> (Dll::Tls());
-
- if(globalData == NULL)
- {
- globalData = new (ELeave) CDataGlobal;
- CleanupStack::PushL(globalData);
- globalData->iAdvSetReferenceCount = 0;
- globalData->iTestCamAdvSet = new (ELeave) CTestCamAdvSet(aOwner);
- CleanupStack::PushL(globalData->iTestCamAdvSet);
- globalData->iTestCamAdvSet->ConstructL();
- globalData->iTestCamAdvSet->iRefCount = 1;
- User::LeaveIfError(Dll::SetTls(globalData));
- CleanupStack::Pop(globalData->iTestCamAdvSet);
- CleanupStack::Pop(globalData);
- return globalData->iTestCamAdvSet;
- }
- else
- {
- if(globalData->iTestCamAdvSet == NULL)
- {
- globalData->iAdvSetReferenceCount = 0;
- globalData->iTestCamAdvSet = new (ELeave) CTestCamAdvSet(aOwner);
- CleanupStack::PushL(globalData->iTestCamAdvSet);
- globalData->iTestCamAdvSet->ConstructL();
- globalData->iTestCamAdvSet->iRefCount = 1;
- User::LeaveIfError(Dll::SetTls(globalData));
- CleanupStack::Pop(globalData->iTestCamAdvSet);
- return globalData->iTestCamAdvSet;
- }
-
- CTestCamAdvSet* self = globalData->iTestCamAdvSet;
-
- globalData->iAdvSetReferenceCount++;
- self->iRefCount = globalData->iAdvSetReferenceCount + 1;
- if (globalData->iAdvSetReferenceCount == KNumOfAdvSetExtensions-1 )
- {
- globalData->iTestCamAdvSet = NULL;
- if(!globalData->iTestCamPresets && !globalData->iTestCamSnapshot && !globalData->iTestCamImgProc)
- {
- delete globalData;
- Dll::FreeTls();
- }
- else
- {
- User::LeaveIfError(Dll::SetTls(globalData));
- }
- }
- else
- {
- User::LeaveIfError(Dll::SetTls(globalData));
- }
- return self;
- }
- }
-
-void CTestCamAdvSet::Release()
- {
- iRefCount--;
- if(iRefCount == 0)
- {
- iOwner.iAdvSettingsImpl = NULL;
- delete this;
- }
- }
-
-void CTestCamAdvSet::Init()
- {
- for(TUint i=0; i< KNumAvailableCameras; i++)
- {
- iCameraTypes[i] = CCamera::CCameraAdvancedSettings::ECameraPluggable;
- }
-
- iFocusDistance = KDefaultFocusDistance;
- iIsoRate = KDefaultIsoRate;
- iISORateType = CCamera::CCameraAdvancedSettings::EISOManual;
- iAperture = KDefaultAperture;
- iShutterSpeed = KDefaultShutterSpeed;
- }
-
-void CTestCamAdvSet::ConstructL()
- {
- iSupportedISORates.Reset();
- iSupportedISORates.AppendL(KDefaultIsoRate);
-
- iSupportedApertures.Reset();
- iSupportedApertures.AppendL(KDefaultAperture);
-
- iSupportedShutterSpeeds.Reset();
- iSupportedShutterSpeeds.AppendL(KDefaultShutterSpeed);
- }
-
-CCamera::CCameraAdvancedSettings::TCameraType CTestCamAdvSet::CameraType() const
- {
- return CCamera::CCameraAdvancedSettings::ECameraPluggable;
- }
-
-CCamera::CCameraAdvancedSettings::TCameraType CTestCamAdvSet::CameraType(TInt aCameraIndex) const
- {
- if (aCameraIndex >= KNumAvailableCameras || aCameraIndex < 0)
- {
- return CCamera::CCameraAdvancedSettings::ECameraUnknown;
- }
- else
- {
- return iCameraTypes[aCameraIndex];
- }
- }
-
-TBool CTestCamAdvSet::IsCameraPresent() const
- {
- return ETrue;
- }
-
-TBool CTestCamAdvSet::IsCameraPresent(TInt aCameraIndex) const
- {
- if (aCameraIndex >= KNumAvailableCameras || aCameraIndex < 0)
- {
- return EFalse;
- }
- else
- {
- return ETrue;
- }
- }
-
-TInt CTestCamAdvSet::CameraIndex() const
- {
- return iOwner.iCameraIndex;
- }
-
-TInt CTestCamAdvSet::SupportedStabilizationModes() const
- {
- return KFeatureNotSupported;
- }
-
-CCamera::CCameraAdvancedSettings::TStabilizationMode CTestCamAdvSet::StabilizationMode() const
- {
- return CCamera::CCameraAdvancedSettings::EStabilizationModeOff;
- }
-
-void CTestCamAdvSet::SetStabilizationMode(CCamera::CCameraAdvancedSettings::TStabilizationMode aStabilizationMode)
- {
- TInt eventError = KErrNotSupported;
- if(aStabilizationMode == CCamera::CCameraAdvancedSettings::EStabilizationModeOff)
- {
- eventError = KErrAlreadyExists;
- }
-
- TECAMEvent ecamevent(KUidECamEventCameraSettingStabilizationMode, eventError);
-
- iOwner.iECamEvent = ecamevent;
- iOwner.iHandleEventAsync.CallBack();
- }
-
-TInt CTestCamAdvSet::SupportedFocusModes() const
- {
- return KFeatureNotSupported;
- }
-
-CCamera::CCameraAdvancedSettings::TFocusMode CTestCamAdvSet::FocusMode() const
- {
- return CCamera::CCameraAdvancedSettings::EFocusModeAuto;
- }
-
-void CTestCamAdvSet::SetFocusMode(CCamera::CCameraAdvancedSettings::TFocusMode aFocusMode)
- {
- TInt eventError = KErrNotSupported;
- if(aFocusMode == CCamera::CCameraAdvancedSettings::EFocusModeAuto)
- {
- eventError = KErrAlreadyExists;
- }
-
- TECAMEvent ecamevent(KUidECamEventCameraSettingFocusMode, eventError);
-
- iOwner.iECamEvent = ecamevent;
- iOwner.iHandleEventAsync.CallBack();
- }
-
-TInt CTestCamAdvSet::SupportedFocusRanges() const
- {
- return KFeatureNotSupported;
- }
-
-CCamera::CCameraAdvancedSettings::TFocusRange CTestCamAdvSet::FocusRange() const
- {
- return CCamera::CCameraAdvancedSettings::EFocusRangeAuto;
- }
-
-void CTestCamAdvSet::SetFocusRange(CCamera::CCameraAdvancedSettings::TFocusRange aFocusRange)
- {
- TInt eventError = KErrNotSupported;
- if(aFocusRange == CCamera::CCameraAdvancedSettings::EFocusRangeAuto)
- {
- eventError = KErrAlreadyExists;
- }
-
- TECAMEvent ecamevent1(KUidECamEventCameraSettingFocusRange2, eventError);
- TECAMEvent ecamevent2(KUidECamEventCameraSettingFocusRange, eventError);
-
- iOwner.iECamEvent = ecamevent1;
- iOwner.iHandleEventAsync.CallBack();
-
- iOwner.iECamEvent = ecamevent2;
- iOwner.iHandleEventAsync.CallBack();
- }
-
-TInt CTestCamAdvSet::SupportedAutoFocusTypes() const
- {
- return KFeatureNotSupported;
- }
-
-CCamera::CCameraAdvancedSettings::TAutoFocusType CTestCamAdvSet::AutoFocusType() const
- {
- return CCamera::CCameraAdvancedSettings::EAutoFocusTypeOff;
- }
-
-void CTestCamAdvSet::SetAutoFocusType(CCamera::CCameraAdvancedSettings::TAutoFocusType aAutoFocusType)
- {
- TInt eventError = KErrNotSupported;
- if(aAutoFocusType == CCamera::CCameraAdvancedSettings::EAutoFocusTypeOff)
- {
- eventError = KErrAlreadyExists;
- }
-
- TECAMEvent ecamevent1(KUidECamEventCameraSettingAutoFocusType2, eventError);
- TECAMEvent ecamevent2(KUidECamEventCameraSettingAutoFocusType, eventError);
-
- iOwner.iECamEvent = ecamevent1;
- iOwner.iHandleEventAsync.CallBack();
-
- iOwner.iECamEvent = ecamevent2;
- iOwner.iHandleEventAsync.CallBack();
- }
-
-TInt CTestCamAdvSet::SupportedAutoFocusAreas() const
- {
- return KFeatureNotSupported;
- }
-
-CCamera::CCameraAdvancedSettings::TAutoFocusArea CTestCamAdvSet::AutoFocusArea() const
- {
- return CCamera::CCameraAdvancedSettings::EAutoFocusTypeAuto;
- }
-
-void CTestCamAdvSet::SetAutoFocusArea(CCamera::CCameraAdvancedSettings::TAutoFocusArea aAutoFocusArea)
- {
- TInt eventError = KErrNotSupported;
- if(aAutoFocusArea == CCamera::CCameraAdvancedSettings::EAutoFocusTypeAuto)
- {
- eventError = KErrAlreadyExists;
- }
-
- TECAMEvent ecamevent(KUidECamEventCameraSettingAutoFocusArea, eventError);
-
- iOwner.iECamEvent = ecamevent;
- iOwner.iHandleEventAsync.CallBack();
- }
-
-TInt CTestCamAdvSet::FocusDistance() const
- {
- return iFocusDistance;
- }
-
-void CTestCamAdvSet::SetFocusDistance(TInt aDistance)
- {
- TInt eventError = KErrNone;
- if(aDistance < 0)
- {
- eventError = KErrNotSupported;
- }
- else
- {
- iFocusDistance = aDistance;
- }
-
- TECAMEvent ecamevent(KUidECamEventCameraSettingFocusDistance, eventError);
-
- iOwner.iECamEvent = ecamevent;
- iOwner.iHandleEventAsync.CallBack();
- }
-
-TInt CTestCamAdvSet::GetMinFocalLength() const
- {
- return KErrNotSupported;
- }
-
-void CTestCamAdvSet::GetSupportedIsoRatesL(RArray<TInt>& aSupportedIsoRates) const
- {
- if(iSupportedISORates.Count() == 0)
- {
- User::Leave(KErrNotSupported);
- }
-
- for(TInt index=0; index < iSupportedISORates.Count(); index++)
- {
- aSupportedIsoRates.AppendL(iSupportedISORates[index]);
- }
- }
-
-TInt CTestCamAdvSet::IsoRate() const
- {
- return iIsoRate;
- }
-
-void CTestCamAdvSet::SetIsoRate(TInt aRate)
- {
- TInt eventError = KErrNone;
- if(iSupportedISORates.Find(aRate) == KErrNotFound)
- {
- eventError = KErrECamParameterNotInRange;
- }
- else
- {
- //set the ISO type to Manual
- iISORateType = CCamera::CCameraAdvancedSettings::EISOManual;
- iIsoRate = aRate;
- }
-
- TECAMEvent ecamevent(KUidECamEventCameraSettingIsoRate, eventError);
-
- iOwner.iECamEvent = ecamevent;
- iOwner.iHandleEventAsync.CallBack();
- }
-
-void CTestCamAdvSet::GetSupportedISORateTypeL(TInt& aSupportedISORateTypes) const
- {
- aSupportedISORateTypes = KSupportedISORateTypes;
- }
-
-void CTestCamAdvSet::SetISORate(CCamera::CCameraAdvancedSettings::TISORateType aISORateType, TInt aParam)
- {
- TInt eventError = KErrNone;
-
- if(!(aISORateType & KSupportedISORateTypes) || iSupportedISORates.Count() == 0)
- {
- eventError = KErrNotSupported;
- }
- else
- {
- switch(aISORateType)
- {
- case CCamera::CCameraAdvancedSettings::EISOManual:
- {
- if(iSupportedISORates.Find(aParam) == KErrNotFound)
- {
- eventError = KErrECamParameterNotInRange;
- }
- else
- {
- iISORateType = aISORateType;
- if(aParam == iIsoRate)
- {
- eventError = KErrAlreadyExists;
- }
- else
- {
- iIsoRate = aParam;
- }
- }
- break;
- }
- case CCamera::CCameraAdvancedSettings::EISOAutoUnPrioritised:
- {
- eventError = KErrNotSupported;
- break;
- }
- case CCamera::CCameraAdvancedSettings::EISOAutoISOPrioritised:
- {
- eventError = KErrNotSupported;
- break;
- }
- case CCamera::CCameraAdvancedSettings::EISOAutoShutterSpeedPrioritised:
- {
- eventError = KErrNotSupported;
- break;
- }
- case CCamera::CCameraAdvancedSettings::EISOAutoAperturePrioritised:
- {
- eventError = KErrNotSupported;
- break;
- }
- default:
- eventError = KErrNotSupported;
- }
- }
-
- TECAMEvent ecamevent(KUidECamEventCameraSettingIsoRateType, eventError);
-
- iOwner.iECamEvent = ecamevent;
- iOwner.iHandleEventAsync.CallBack();
- }
-
-void CTestCamAdvSet::GetISORateL(CCamera::CCameraAdvancedSettings::TISORateType& aISORateType, TInt& /*aParam*/, TInt& aISORate) const
- {
- //If camera has no ISO rate supported, then leave
- if(iSupportedISORates.Count() == 0)
- {
- User::Leave(KErrNotSupported);
- }
-
- aISORateType = iISORateType;
- aISORate = iIsoRate;
-// aParam is redundant for manual ISO.
- }
-
-void CTestCamAdvSet::GetAperturesL(RArray<TInt>& aFStops, TValueInfo& aInfo) const
- {
- if(iSupportedApertures.Count() == 0)
- {
- aFStops.Reset();
- aInfo = ENotActive;
- }
-
- for(TInt index=0; index < iSupportedApertures.Count(); index++)
- {
- aFStops.AppendL(iSupportedApertures[index]);
- }
-
- aInfo = EDiscreteSteps;
- }
-
-TInt CTestCamAdvSet::Aperture() const
- {
- return iAperture;
- }
-
-void CTestCamAdvSet::SetAperture(TInt aFStop)
- {
- TInt eventError = KErrNone;
- if(iSupportedApertures.Find(aFStop) == KErrNotFound)
- {
- eventError = KErrECamParameterNotInRange;
- }
- else
- {
- iAperture = aFStop;
- }
-
- TECAMEvent ecamevent(KUidECamEventCameraSettingAperture, eventError);
-
- iOwner.iECamEvent = ecamevent;
- iOwner.iHandleEventAsync.CallBack();
- }
-
-void CTestCamAdvSet::GetShutterSpeedsL(RArray<TInt>& aShutterSpeeds, TValueInfo& aInfo) const
- {
- if(iSupportedShutterSpeeds.Count() == 0)
- {
- aShutterSpeeds.Reset();
- aInfo = ENotActive;
- }
-
- for(TInt index=0; index < iSupportedShutterSpeeds.Count(); index++)
- {
- aShutterSpeeds.AppendL(iSupportedShutterSpeeds[index]);
- aInfo = EDiscreteSteps;
- }
- }
-
-TInt CTestCamAdvSet::ShutterSpeed() const
- {
- return iShutterSpeed;
- }
-
-void CTestCamAdvSet::SetShutterSpeed(TInt aShutterSpeed)
- {
- TInt eventError = KErrNone;
- if(iSupportedShutterSpeeds.Find(aShutterSpeed) == KErrNotFound)
- {
- eventError = KErrECamParameterNotInRange;
- }
- else
- {
- iShutterSpeed = aShutterSpeed;
- }
-
- TECAMEvent ecamevent(KUidECamEventCameraSettingShutterSpeed, eventError);
-
- iOwner.iECamEvent = ecamevent;
- iOwner.iHandleEventAsync.CallBack();
- }
-
-TInt CTestCamAdvSet::SupportedMeteringModes() const
- {
- return KFeatureNotSupported;
- }
-
-CCamera::CCameraAdvancedSettings::TMeteringMode CTestCamAdvSet::MeteringMode() const
- {
- return CCamera::CCameraAdvancedSettings::EMeteringModeAuto;
- }
-
-void CTestCamAdvSet::SetMeteringMode(CCamera::CCameraAdvancedSettings::TMeteringMode aMeteringMode)
- {
- TInt eventError = KErrNotSupported;
- if(aMeteringMode == CCamera::CCameraAdvancedSettings::EMeteringModeAuto)
- {
- eventError = KErrAlreadyExists;
- }
-
- TECAMEvent ecamevent(KUidECamEventCameraSettingMeteringMode, eventError);
-
- iOwner.iECamEvent = ecamevent;
- iOwner.iHandleEventAsync.CallBack();
- }
-
-TInt CTestCamAdvSet::SupportedDriveModes() const
- {
- return KSupportedDriveModes;
- }
-
-CCamera::CCameraAdvancedSettings::TDriveMode CTestCamAdvSet::DriveMode() const
- {
- return iOwner.iDriveMode;
- }
-
-void CTestCamAdvSet::SetDriveMode(CCamera::CCameraAdvancedSettings::TDriveMode aDriveMode)
- {
- TInt eventError = KErrNone;
- if(iOwner.iVideoCaptureActive || iOwner.iImageCaptureActive)
- {
- eventError = KErrNotReady;
- }
- else
- {
- if(!(aDriveMode & KSupportedDriveModes))
- {
- eventError = KErrNotSupported;
- }
- else
- {
- if(eventError == KErrNone)
- {
- iOwner.iDriveMode = aDriveMode;
- }
- }
- }
-
- TECAMEvent ecamevent(KUidECamEventCameraSettingDriveMode, eventError);
-
- iOwner.iECamEvent = ecamevent;
- iOwner.iHandleEventAsync.CallBack();
- }
-
-TInt CTestCamAdvSet::SupportedBracketModes() const
- {
- return KFeatureNotSupported;
- }
-
-CCamera::CCameraAdvancedSettings::TBracketMode CTestCamAdvSet::BracketMode() const
- {
- return CCamera::CCameraAdvancedSettings::EBracketModeOff;
- }
-
-void CTestCamAdvSet::SetBracketMode(CCamera::CCameraAdvancedSettings::TBracketMode aBracketMode)
- {
- TInt eventError = KErrNotSupported;
- if(aBracketMode == CCamera::CCameraAdvancedSettings::EBracketModeOff)
- {
- eventError = KErrAlreadyExists;
- }
-
- TECAMEvent ecamevent(KUidECamEventCameraSettingBracketMode, eventError);
-
- iOwner.iECamEvent = ecamevent;
- iOwner.iHandleEventAsync.CallBack();
- }
-
-TInt CTestCamAdvSet::SupportedBracketParameters() const
- {
- return KFeatureNotSupported;
- }
-
-CCamera::CCameraAdvancedSettings::TBracketParameter CTestCamAdvSet::BracketParameter() const
- {
- return CCamera::CCameraAdvancedSettings::EBracketParameterNone;
- }
-
-void CTestCamAdvSet::SetBracketParameter(CCamera::CCameraAdvancedSettings::TBracketParameter aBracketParameter)
- {
- TInt eventError = KErrNotSupported;
- if(aBracketParameter == CCamera::CCameraAdvancedSettings::EBracketParameterNone)
- {
- eventError = KErrAlreadyExists;
- }
-
- TECAMEvent ecamevent(KUidECamEventCameraSettingBracketParameter, eventError);
-
- iOwner.iECamEvent = ecamevent;
- iOwner.iHandleEventAsync.CallBack();
- }
-
-TInt CTestCamAdvSet::SupportedBracketSteps() const
- {
- return KFeatureNotSupported;
- }
-
-CCamera::CCameraAdvancedSettings::TBracketStep CTestCamAdvSet::BracketStep() const
- {
- return CCamera::CCameraAdvancedSettings::EBracketStepNonConfig;
- }
-
-void CTestCamAdvSet::SetBracketStep(CCamera::CCameraAdvancedSettings::TBracketStep aBracketStep)
- {
- TInt eventError = KErrNotSupported;
- if(aBracketStep == CCamera::CCameraAdvancedSettings::EBracketStepNonConfig)
- {
- eventError = KErrAlreadyExists;
- }
-
- TECAMEvent ecamevent(KUidECamEventCameraSettingBracketStep, eventError);
-
- iOwner.iECamEvent = ecamevent;
- iOwner.iHandleEventAsync.CallBack();
- }
-
-void CTestCamAdvSet::GetBracketMerge(TInt& aStartIndex, TInt& aFrames) const
- {
- aStartIndex = KFeatureNotSupported;
- aFrames = KFeatureNotSupported;
- }
-
-void CTestCamAdvSet::SetBracketMerge(TInt /*aStartIndex*/ , TInt /*aFrames*/)
- {
- TECAMEvent ecamevent(KUidECamEventBracketMerge, KErrNotSupported);
-
- iOwner.iECamEvent = ecamevent;
- iOwner.iHandleEventAsync.CallBack();
- }
-
-TInt CTestCamAdvSet::SupportedFlashModes() const
- {
- return KFeatureNotSupported;
- }
-
-CCamera::TFlash CTestCamAdvSet::FlashMode() const
- {
- return CCamera::EFlashNone;
- }
-
-void CTestCamAdvSet::SetFlashMode(CCamera::TFlash /*aMode*/)
- {
- TECAMEvent ecamevent(KUidECamEventCameraSettingFlashMode, KErrNotSupported);
-
- iOwner.iECamEvent = ecamevent;
- iOwner.iHandleEventAsync.CallBack();
- }
-
-TBool CTestCamAdvSet::RedEyeReduceOn() const
- {
- return KDefaultRedEyeReduce;
- }
-
-void CTestCamAdvSet::SetRedEyeReduceOn(TBool /*aState*/)
- {
- TECAMEvent ecamevent(KUidECamEventCameraSettingFlashRedEyeReduce, KErrNotSupported);
-
- iOwner.iECamEvent = ecamevent;
- iOwner.iHandleEventAsync.CallBack();
- }
-
-void CTestCamAdvSet::GetFlashCompensationStepsL(RArray<TInt>& aFlashCompensationSteps, TValueInfo& aInfo) const
- {
- aFlashCompensationSteps.Reset();
- aInfo = ENotActive;
- }
-
-TInt CTestCamAdvSet::FlashCompensationStep() const
- {
- return KFlashCompensationStep;
- }
-
-TInt CTestCamAdvSet::GetFlashCompensationStep(TInt& aFlashCompensationStep) const
- {
- aFlashCompensationStep = KFlashCompensationStep;
- return KErrNone;
- }
-
-void CTestCamAdvSet::GetFlashCompensationRangeInSteps(TInt& aNegativeCompensation, TInt& aPositiveCompensation) const
- {
- aNegativeCompensation = KFlashCompensationStep;
- aPositiveCompensation = KFlashCompensationStep;
- }
-
-void CTestCamAdvSet::SetFlashCompensationStep(TInt /*aFlashCompensationStep*/)
- {
- TECAMEvent ecamevent(KUidECamEventCameraSettingFlashCompensationStep, KErrNotSupported);
-
- iOwner.iECamEvent = ecamevent;
- iOwner.iHandleEventAsync.CallBack();
- }
-
-TInt CTestCamAdvSet::FlashCompensation() const
- {
- return KFlashCompensationStep;
- }
-
-TInt CTestCamAdvSet::GetFlashCompensation(TInt& aFlashCompensation) const
- {
- aFlashCompensation = KFlashCompensationStep;
- return KErrNone;
- }
-
-void CTestCamAdvSet::SetFlashCompensation(TInt /*aFlashCompensation*/)
- {
- TECAMEvent ecamevent(KUidECamEventCameraSettingFlashCompensation, KErrNotSupported);
-
- iOwner.iECamEvent = ecamevent;
- iOwner.iHandleEventAsync.CallBack();
- }
-
-TBool CTestCamAdvSet::IsExternalFlashPresent() const
- {
- return KExternalFlashPresentState;
- }
-
-void CTestCamAdvSet::GetManualFlashPowerLevelsL(RArray<TInt>& aManualFlashPowerLevels, TValueInfo& aInfo) const
- {
- aManualFlashPowerLevels.Reset();
- aInfo = ENotActive;
- }
-
-TInt CTestCamAdvSet::ManualFlashPowerLevel() const
- {
- return KErrNotSupported;
- }
-
-void CTestCamAdvSet::SetManualFlashPowerLevel(TInt /*aManualFlashPowerLevel*/)
- {
- TECAMEvent ecamevent(KUidECamEventCameraSettingFlashManualPower, KErrNotSupported);
-
- iOwner.iECamEvent = ecamevent;
- iOwner.iHandleEventAsync.CallBack();
- }
-
-TInt CTestCamAdvSet::SupportedExposureModes() const
- {
- return CCamera::EExposureAuto;
- }
-
-CCamera::TExposure CTestCamAdvSet::ExposureMode() const
- {
- return CCamera::EExposureAuto;
- }
-
-void CTestCamAdvSet::SetExposureMode(CCamera::TExposure aExposureMode)
- {
- TInt eventError = KErrNotSupported;
- if(aExposureMode == CCamera::EExposureAuto)
- {
- eventError = KErrAlreadyExists;
- }
-
- TECAMEvent ecamevent(KUidECamEventCameraSettingExposureMode, eventError);
-
- iOwner.iECamEvent = ecamevent;
- iOwner.iHandleEventAsync.CallBack();
- }
-
-void CTestCamAdvSet::GetExposureCompensationStepsL(RArray<TInt>& aExposureCompensationSteps, TValueInfo& aInfo) const
- {
- aExposureCompensationSteps.Reset();
- aInfo = ENotActive;
- }
-
-void CTestCamAdvSet::GetExposureCompensationRangeInSteps(TInt& aNegativeCompensation, TInt& aPositiveCompensation) const
- {
- aNegativeCompensation = KExposureCompensationStep;
- aPositiveCompensation = KExposureCompensationStep;
- }
-
-TInt CTestCamAdvSet::ExposureCompensationStep() const
- {
- return KExposureCompensationStep;
- }
-
-TInt CTestCamAdvSet::GetExposureCompensationStep(TInt& aExposureCompensationStep) const
- {
- aExposureCompensationStep = KExposureCompensationStep;
- return KErrNone;
- }
-
-void CTestCamAdvSet::SetExposureCompensationStep(TInt /*aExposureCompensationStep*/)
- {
- TECAMEvent ecamevent(KUidECamEventCameraSettingExposureCompensationStep, KErrNotSupported);
-
- iOwner.iECamEvent = ecamevent;
- iOwner.iHandleEventAsync.CallBack();
- }
-
-TInt CTestCamAdvSet::ExposureCompensation() const
- {
- return KExposureCompensationStep;
- }
-
-TInt CTestCamAdvSet::GetExposureCompensation(TInt& aExposureCompensation) const
- {
- aExposureCompensation = KExposureCompensationStep;
- return KErrNone;
- }
-
-void CTestCamAdvSet::SetExposureCompensation(TInt /*aExposureCompensation*/)
- {
- TECAMEvent ecamevent(KUidECamEventCameraSettingExposureCompensation, KErrNotSupported);
-
- iOwner.iECamEvent = ecamevent;
- iOwner.iHandleEventAsync.CallBack();
- }
-
-TInt CTestCamAdvSet::SupportedWhiteBalanceModes() const
- {
- return KFeatureNotSupported;
- }
-
-CCamera::TWhiteBalance CTestCamAdvSet::WhiteBalanceMode() const
- {
- return CCamera::EWBAuto;
- }
-
-void CTestCamAdvSet::SetWhiteBalanceMode(CCamera::TWhiteBalance aWhiteBalanceMode)
- {
- TInt eventError = KErrNotSupported;
- if(aWhiteBalanceMode == CCamera::EWBAuto)
- {
- eventError = KErrAlreadyExists;
- }
-
- TECAMEvent ecamevent(KUidECamEventCameraSettingWhiteBalanceMode, eventError);
-
- iOwner.iECamEvent = ecamevent;
- iOwner.iHandleEventAsync.CallBack();
- }
-
-TBool CTestCamAdvSet::ApertureExposureLockOn() const
- {
- return KApertureExposureLockOn;
- }
-
-void CTestCamAdvSet::SetApertureExposureLockOn(TBool /*aAELock*/)
- {
- TECAMEvent ecamevent(KUidECamEventAELock, KErrNotSupported);
-
- iOwner.iECamEvent = ecamevent;
- iOwner.iHandleEventAsync.CallBack();
- }
-
-TBool CTestCamAdvSet::ShootClickOn() const
- {
- return KShootClickOn;
- }
-
-void CTestCamAdvSet::SetShootClickOn(TBool /*aShootClickOn*/)
- {
- TECAMEvent ecamevent(KUidECamEventSoundClick, KErrNotSupported);
-
- iOwner.iECamEvent = ecamevent;
- iOwner.iHandleEventAsync.CallBack();
- }
-
-void CTestCamAdvSet::GetTimerIntervalsL(RArray<TInt>& aTimerIntervals, TValueInfo& aInfo) const
- {
- aTimerIntervals.Reset();
- aInfo = ENotActive;
- }
-
-TInt CTestCamAdvSet::TimerInterval() const
- {
- return KErrNotSupported;
- }
-
-void CTestCamAdvSet::SetTimerInterval(TInt /*aTimerInterval*/)
- {
- TECAMEvent ecamevent(KUidECamEventCameraSettingTimerInterval, KErrNotSupported);
-
- iOwner.iECamEvent = ecamevent;
- iOwner.iHandleEventAsync.CallBack();
- }
-
-void CTestCamAdvSet::GetTimeLapsePeriodRange(TTime& aTimeLapseMin, TTime& aTimeLapseMax) const
- {
- TTime timeLapse(KTimeLapse);
- aTimeLapseMin = aTimeLapseMax = timeLapse;
- }
-
-void CTestCamAdvSet::GetTimeLapse(TTime& aStart, TTime& aEnd, TTime& aInterval) const
- {
- TTime timeLapse(KTimeLapse);
- aStart = aEnd = aInterval = timeLapse;
- }
-
-void CTestCamAdvSet::SetTimeLapse(const TTime& /*aStart*/, const TTime& /*aEnd*/, const TTime& /*aInterval*/)
- {
- TECAMEvent ecamevent(KUidECamEventCameraSettingTimeLapse, KErrNotSupported);
-
- iOwner.iECamEvent = ecamevent;
- iOwner.iHandleEventAsync.CallBack();
- }
-
-CCamera::CCameraAdvancedSettings::TPictureOrientation CTestCamAdvSet::PictureOrientation() const
- {
- return CCamera::CCameraAdvancedSettings::EPictureOrientationUnknown;
- }
-
-void CTestCamAdvSet::SetPictureOrientation(CCamera::CCameraAdvancedSettings::TPictureOrientation aOrientation)
- {
- TInt eventError = KErrNotSupported;
-
- if(iOwner.iVideoCaptureActive || iOwner.iImageCaptureActive)
- {
- eventError = KErrNotReady;
- }
- else
- {
- if(aOrientation == CCamera::CCameraAdvancedSettings::EPictureOrientationUnknown)
- {
- eventError = KErrAlreadyExists;
- }
- }
-
- TECAMEvent ecamevent(KUidECamEventCameraSettingPictureOrientation, eventError);
-
- iOwner.iECamEvent = ecamevent;
- iOwner.iHandleEventAsync.CallBack();
- }
-
-TInt CTestCamAdvSet::SupportedPixelAspectRatios() const
- {
- return KSupportedPixelAspectRatio;
- }
-
-CCamera::CCameraAdvancedSettings::TPixelAspectRatio CTestCamAdvSet::PixelAspectRatio() const
- {
- return CCamera::CCameraAdvancedSettings::EPixelAspectUnknown;
- }
-
-void CTestCamAdvSet::SetPixelAspectRatio(CCamera::CCameraAdvancedSettings::TPixelAspectRatio aPixelAspectRatio)
- {
- TInt eventError = KErrNotSupported;
-
- if(aPixelAspectRatio == CCamera::CCameraAdvancedSettings::EPixelAspectUnknown)
- {
- eventError = KErrAlreadyExists;
- }
-
- TECAMEvent ecamevent(KUidECamEventPixelAspectRatio, eventError);
-
- iOwner.iECamEvent = ecamevent;
- iOwner.iHandleEventAsync.CallBack();
- }
-
-TInt CTestCamAdvSet::SupportedYuvRanges() const
- {
- return KSupportedYuvRange;
- }
-
-CCamera::CCameraAdvancedSettings::TYuvRange CTestCamAdvSet::YuvRange() const
- {
- return CCamera::CCameraAdvancedSettings::EYuvRangeUnknown;
- }
-
-void CTestCamAdvSet::SetYuvRange(CCamera::CCameraAdvancedSettings::TYuvRange aYuvRange)
- {
- TInt eventError = KErrNotSupported;
-
- if(aYuvRange == CCamera::CCameraAdvancedSettings::EYuvRangeUnknown)
- {
- eventError = KErrAlreadyExists;
- }
-
- TECAMEvent ecamevent(KUidECamEventYuvRange, eventError);
-
- iOwner.iECamEvent = ecamevent;
- iOwner.iHandleEventAsync.CallBack();
- }
-
-TInt CTestCamAdvSet::BurstImages() const
- {
- return iOwner.iBurstImages;
- }
-
-void CTestCamAdvSet::SetBurstImages(TInt aImages)
- {
- TInt eventError = iOwner.CheckReserveAndPower();
-
- if(eventError == KErrNone)
- {
- if(aImages == iOwner.iBurstImages)
- {
- eventError = KErrAlreadyExists;
- }
- else
- {
- if(aImages<1)
- {
- eventError = KErrArgument;
- }
- }
- }
-
- if(eventError != KErrNone)
- {
- TECAMEvent ecamevent(KUidECamEventBurstImages, eventError);
-
- iOwner.iECamEvent = ecamevent;
- iOwner.iHandleEventAsync.CallBack();
- return;
- }
-
- if(aImages > KMaxBurstImages)
- {
- iOwner.iBurstImages = KMaxBurstImages;
- }
- else
- {
- iOwner.iBurstImages = aImages;
- }
-
- TECAMEvent ecamevent(KUidECamEventBurstImages, eventError);
-
- iOwner.iECamEvent = ecamevent;
- iOwner.iHandleEventAsync.CallBack();
- }
-
-void CTestCamAdvSet::GetOpticalZoomStepsL(RArray<TInt>& aOpticalZoomSteps, TValueInfo& aInfo) const
- {
- aOpticalZoomSteps.Reset();
- aOpticalZoomSteps.AppendL(KECamFineResolutionFactor);
- aInfo = EDiscreteSteps;
- }
-
-TInt CTestCamAdvSet::OpticalZoom() const
- {
- return KECamFineResolutionFactor;
- }
-
-void CTestCamAdvSet::SetOpticalZoom(TInt aOpticalZoom)
- {
- TInt eventError = KErrNotSupported;
-
- if(aOpticalZoom == KECamFineResolutionFactor)
- {
- eventError = KErrAlreadyExists;
- }
-
- TECAMEvent ecamevent(KUidECamEventCameraSettingOpticalZoom, eventError);
-
- iOwner.iECamEvent = ecamevent;
- iOwner.iHandleEventAsync.CallBack();
- }
-
-void CTestCamAdvSet::GetDigitalZoomStepsL(RArray<TInt>& aDigitalZoomSteps,
- TValueInfo& aInfo) const
- {
- aDigitalZoomSteps.Reset();
- aDigitalZoomSteps.AppendL(KECamFineResolutionFactor);
- aInfo = EDiscreteSteps;
- }
-
-void CTestCamAdvSet::GetDigitalZoomStepsForStillL(RArray<TInt>& aDigitalZoomSteps, TValueInfo& aInfo, TInt /*aSizeIndex*/,
- CCamera::TFormat /*aFormat*/, TBool& /*aIsInfluencePossible*/) const
- {
- aDigitalZoomSteps.Reset();
- aDigitalZoomSteps.AppendL(KECamFineResolutionFactor);
- aInfo = EDiscreteSteps;
- }
-
-void CTestCamAdvSet::GetDigitalZoomStepsForVideoL(RArray<TInt>& aDigitalZoomSteps, TValueInfo& aInfo, TInt /*aFrameRateIndex*/,
- TInt /*aSizeIndex*/, CCamera::TFormat /*aFormat*/, TBool& /*aIsInfluencePossible*/, CCamera::TExposure /*aExposure*/) const
- {
- aDigitalZoomSteps.Reset();
- aDigitalZoomSteps.AppendL(KECamFineResolutionFactor);
- aInfo = EDiscreteSteps;
- }
-
-TInt CTestCamAdvSet::DigitalZoom() const
- {
- return KECamFineResolutionFactor;
- }
-
-void CTestCamAdvSet::SetDigitalZoom(TInt aDigitalZoom)
- {
- TInt eventError = KErrNotSupported;
-
- if(aDigitalZoom == KECamFineResolutionFactor)
- {
- eventError = KErrAlreadyExists;
- }
-
- TECAMEvent ecamevent(KUidECamEventCameraSettingDigitalZoom, eventError);
-
- iOwner.iECamEvent = ecamevent;
- iOwner.iHandleEventAsync.CallBack();
- }
-
-TBool CTestCamAdvSet::ExposureLockOn() const
- {
- return KExposureLockOn;
- }
-
-void CTestCamAdvSet::SetExposureLockOn(TBool aState)
- {
- TInt eventError = KErrNotSupported;
-
- if(aState == KExposureLockOn)
- {
- eventError = KErrAlreadyExists;
- }
-
- TECAMEvent ecamevent(KUidECamEventCameraSettingExposureLock, eventError);
-
- iOwner.iECamEvent = ecamevent;
- iOwner.iHandleEventAsync.CallBack();
- }
-
-TBool CTestCamAdvSet::AutoFocusLockOn() const
- {
- return KAutoFocusLockOn;
- }
-
-void CTestCamAdvSet::SetAutoFocusLockOn(TBool aState)
- {
- TInt eventError = KErrNotSupported;
-
- if(aState == KAutoFocusLockOn)
- {
- eventError = KErrAlreadyExists;
- }
-
- TECAMEvent ecamevent(KUidECamEventCameraSettingAutoFocusLock, eventError);
-
- iOwner.iECamEvent = ecamevent;
- iOwner.iHandleEventAsync.CallBack();
- }
-
-void CTestCamAdvSet::GetSupportedSettingsL(RArray<TUid>& aSettings) const
- {
- aSettings.Reset();
- User::Leave(KErrNotSupported);
- }
-
-void CTestCamAdvSet::GetActiveSettingsL(RArray<TUid>& aActiveSettings) const
- {
- aActiveSettings.Reset();
- User::Leave(KErrNotSupported);
- }
-
-void CTestCamAdvSet::GetDisabledSettingsL(RArray<TUid>& aDisbledSettings) const
- {
- aDisbledSettings.Reset();
- User::Leave(KErrNotSupported);
- }
-
-void CTestCamAdvSet::SetAutomaticSizeSelectionChangeOn(TBool aSetOn)
- {
- TInt eventError = KErrNotSupported;
-
- if(aSetOn == KAutomaticSizeSelectionChangeOn)
- {
- eventError = KErrAlreadyExists;
- }
-
- TECAMEvent ecamevent(KUidECamEventCameraSettingAutomaticSizeSelection, eventError);
-
- iOwner.iECamEvent = ecamevent;
- iOwner.iHandleEventAsync.CallBack();
- }
-
-TBool CTestCamAdvSet::AutomaticSizeSelectionChangeOn() const
- {
- return KAutomaticSizeSelectionChangeOn;
- }
-
-void CTestCamAdvSet::GetSupportedContinuousAutoFocusTimeoutsL(RArray<TInt>& aTimeouts, TValueInfo& aInfo) const
- {
- aTimeouts.Reset();
- aInfo = ENotActive;
- }
-
-void CTestCamAdvSet::SetContinuousAutoFocusTimeout(TInt /*aTimeout*/)
- {
- TECAMEvent ecamevent(KUidECamEventCameraSettingsContinuousAutoFocusTimeout, KErrNotSupported);
-
- iOwner.iECamEvent = ecamevent;
- iOwner.iHandleEventAsync.CallBack();
- }
-
-void CTestCamAdvSet::SetStabilizationEffect(CCamera::CCameraAdvancedSettings::TStabilizationEffect aEffect)
- {
- TInt eventError = KErrNotSupported;
-
- if(aEffect == KStabilizationEffect)
- {
- eventError = KErrAlreadyExists;
- }
-
- TECAMEvent ecamevent(KUidECamEventCameraSettingsStabilizationEffect, eventError);
-
- iOwner.iECamEvent = ecamevent;
- iOwner.iHandleEventAsync.CallBack();
- }
-
-CCamera::CCameraAdvancedSettings::TStabilizationEffect CTestCamAdvSet::StabilizationEffect() const
- {
- return KStabilizationEffect;
- }
-
-TInt CTestCamAdvSet::SupportedStabilizationEffects() const
- {
- return KStabilizationEffect;
- }
-
-TInt CTestCamAdvSet::SupportedStabilizationComplexityValues() const
- {
- return KStabilizationComplexity;
- }
-
-CCamera::CCameraAdvancedSettings::TStabilizationAlgorithmComplexity CTestCamAdvSet::StabilizationComplexity() const
- {
- return KStabilizationComplexity;
- }
-
-void CTestCamAdvSet::SetStabilizationComplexity(CCamera::CCameraAdvancedSettings::TStabilizationAlgorithmComplexity aComplexity)
- {
- TInt eventError = KErrNotSupported;
-
- if(aComplexity == KStabilizationComplexity)
- {
- eventError = KErrAlreadyExists;
- }
-
- TECAMEvent ecamevent(KUidECamEventSettingsStabilizationAlgorithmComplexity, eventError);
-
- iOwner.iECamEvent = ecamevent;
- iOwner.iHandleEventAsync.CallBack();
- }
-
-CCamera::CCameraAdvancedSettings::TWBUnits CTestCamAdvSet::SupportedWBUnits() const
- {
- return KSupportedWBUnits;
- }
-
-void CTestCamAdvSet::SetWBRgbValue(const TRgb& /*aValue*/)
- {
- TECAMEvent ecamevent(KUidECamEventCameraSettingsWBValue, KErrNotSupported);
-
- iOwner.iECamEvent = ecamevent;
- iOwner.iHandleEventAsync.CallBack();
- }
-
-void CTestCamAdvSet::GetWBRgbValue(TRgb& aValue) const
- {
- aValue = KRgbWhite;
- }
-
-void CTestCamAdvSet::GetWBSupportedColorTemperaturesL(RArray<TInt>& aWBColorTemperatures, TValueInfo& aInfo) const
- {
- aWBColorTemperatures.Reset();
- aInfo = ENotActive;
- }
-
-void CTestCamAdvSet::SetWBColorTemperature(TInt /*aColorTemperature*/)
- {
- TECAMEvent ecamevent(KUidECamEventCameraSettingsWBValue, KErrNotSupported);
-
- iOwner.iECamEvent = ecamevent;
- iOwner.iHandleEventAsync.CallBack();
- }
-
-TInt CTestCamAdvSet::WBColorTemperature() const
- {
- return KErrNotSupported;
- }
-
-TInt CTestCamAdvSet::ContinuousAutoFocusTimeout() const
- {
- return KErrNotSupported;
- }
-
-TInt CTestCamAdvSet::IsFlashReady(TBool& aReady) const
- {
- aReady = KFlashReadyState;
- return KErrNone;
- }
-
-void CTestCamAdvSet::GetCurrentFocusModeStepsL(RArray<TInt>& aFocusModeSteps, TValueInfo& aInfo) const
- {
- aFocusModeSteps.Reset();
- aInfo = ENotActive;
- }
-
-void CTestCamAdvSet::SetReferenceScreen(CWsScreenDevice& /*aScreenDevice*/)
- {
- TECAMEvent ecamevent(KUidECamEventCameraSettingReferenceScreen, KErrNotSupported);
-
- iOwner.iECamEvent = ecamevent;
- iOwner.iHandleEventAsync.CallBack();
- }
-
-void CTestCamAdvSet::GetPreCaptureWarningSupportedL(CCamera::CCameraAdvancedSettings::TCameraMode /*aCameraMode*/, TInt& aPreCaptureWarningSupported) const
- {
- aPreCaptureWarningSupported = KPreCaptureWarning;
- }
-
-void CTestCamAdvSet::SubscribeToPreCaptureWarningL(TInt /*aPreCaptureWarning*/)
- {
- User::Leave(KErrNotSupported);
- }
-
-void CTestCamAdvSet::UnSubscribePreCaptureWarningL()
- {
- User::Leave(KErrNotSupported);
- }
-
-void CTestCamAdvSet::GetPreCaptureWarningL(TInt& /*aPreCaptureWarning*/) const
- {
- User::Leave(KErrNotSupported);
- }
-
-void CTestCamAdvSet::GetSupportedAFAssistantLightL(TInt& aSupportedAFAssistantLight) const
- {
- aSupportedAFAssistantLight = KAFAssisstantLight;
- }
-
-void CTestCamAdvSet::GetAFAssistantLightL(CCamera::CCameraAdvancedSettings::TAFAssistantLight& /*aAFAssistantLight*/) const
- {
- User::Leave(KErrNotSupported);
- }
-
-void CTestCamAdvSet::SetAFAssistantLight(CCamera::CCameraAdvancedSettings::TAFAssistantLight aAFAssistantLight)
- {
- TInt eventError = KErrNotSupported;
-
- if(aAFAssistantLight == KAFAssisstantLight)
- {
- eventError = KErrAlreadyExists;
- }
-
- TECAMEvent ecamevent(KUidECamEventCameraSettingAFAssistantLight, eventError);
-
- iOwner.iECamEvent = ecamevent;
- iOwner.iHandleEventAsync.CallBack();
- }
-
-/**********************************************************************************************************/
-/* CTestCamPresets */
-/**********************************************************************************************************/
-
-CTestCamPresets::CTestCamPresets(CTestCamera& aOwner): iOwner(aOwner),iCurrentPreset(KNullUid)
- {}
-
-CTestCamPresets::~CTestCamPresets()
- {
- iSupportedPresets.Close();
- iFactoryPresetAffectSettings.Close();
-
- CDataGlobal* globalData = static_cast <CDataGlobal*> (Dll::Tls());
- if(globalData != NULL)
- {
- if(!globalData->iTestCamAdvSet && !globalData->iTestCamSnapshot && !globalData->iTestCamImgProc)
- {
- delete globalData;
- Dll::FreeTls();
- }
- else
- {
- globalData->iTestCamPresets = NULL;
- Dll::SetTls(globalData);
- }
- }
- }
-
-CTestCamPresets* CTestCamPresets::NewL(CTestCamera& aOwner)
- {
- CDataGlobal* globalData = static_cast <CDataGlobal*> (Dll::Tls());
-
- if(globalData == NULL)
- {
- globalData = new (ELeave) CDataGlobal;
- CleanupStack::PushL(globalData);
- globalData->iPresetsReferenceCount = 0;
- globalData->iTestCamPresets = new (ELeave) CTestCamPresets(aOwner);
- globalData->iTestCamPresets->ConstructL();
- globalData->iTestCamPresets->iRefCount = 1;
- User::LeaveIfError(Dll::SetTls(globalData));
- CleanupStack::Pop(globalData);
- return globalData->iTestCamPresets;
- }
- else
- {
- if(globalData->iTestCamPresets == NULL)
- {
- globalData->iPresetsReferenceCount = 0;
- globalData->iTestCamPresets = new (ELeave) CTestCamPresets(aOwner);
- CleanupStack::PushL(globalData->iTestCamPresets);
- globalData->iTestCamPresets->ConstructL();
- globalData->iTestCamPresets->iRefCount = 1;
- User::LeaveIfError(Dll::SetTls(globalData));
- CleanupStack::Pop(globalData->iTestCamPresets);
- return globalData->iTestCamPresets;
- }
-
- CTestCamPresets* self = globalData->iTestCamPresets;
-
- globalData->iPresetsReferenceCount++;
- self->iRefCount = globalData->iPresetsReferenceCount + 1;
- if (globalData->iPresetsReferenceCount == KNumOfPresetExtensions-1 )
- {
- globalData->iTestCamPresets = NULL;
- if(!globalData->iTestCamAdvSet && !globalData->iTestCamSnapshot && !globalData->iTestCamImgProc)
- {
- delete globalData;
- Dll::FreeTls();
- }
- else
- {
- User::LeaveIfError(Dll::SetTls(globalData));
- }
- }
- else
- {
- User::LeaveIfError(Dll::SetTls(globalData));
- }
- return self;
- }
- }
-
-void CTestCamPresets::Release()
- {
- iRefCount--;
- if(iRefCount == 0)
- {
- delete this;
- }
- }
-
-void CTestCamPresets::ConstructL()
- {
- iSupportedPresets.Reset();
- iSupportedPresets.AppendL(KUidECamPresetFactoryDefault);
-
- iFactoryPresetAffectSettings.Reset();
- iFactoryPresetAffectSettings.AppendL(KUidECamEventCameraSettingDriveMode);
- iFactoryPresetAffectSettings.AppendL(KUidECamEventBurstImages);
- }
-
-void CTestCamPresets::GetSupportedPresetsL(RArray<TUid>& aPresets) const
- {
- aPresets.Reset();
- for (TInt index=0; index < iSupportedPresets.Count(); index++)
- {
- User::LeaveIfError(aPresets.Append(iSupportedPresets[index]));
- }
- }
-
-void CTestCamPresets::SetPreset(TUid aPreset)
- {
- TInt eventError = iOwner.CheckReserveAndPower();
- if(eventError == KErrNone)
- {
- if(aPreset == iSupportedPresets[0])
- {
- //ResetBrightness, Contrast, Drivemode, No. of burst mode images
- iOwner.iBrightness = 0;
- iOwner.iContrast = 0;
- iOwner.iImgProcBrightness = 0;
- iOwner.iImgProcContrast = 0;
- iOwner.iDriveMode = KDefaultDriveMode;
- iOwner.iBurstImages = KBurstImages;
- }
- else
- {
- eventError = KErrNotSupported;
- }
- }
-
- TECAMEvent ecamevent(aPreset, eventError);
-
- iOwner.iECamEvent = ecamevent;
- iOwner.iHandleEventAsync.CallBack();
- }
-
-TUid CTestCamPresets::Preset() const
- {
- return iCurrentPreset;
- }
-
-void CTestCamPresets::GetAffectedSettingsL(RArray<TUid>& aSettings) const
- {
- aSettings.Reset();
-
- if(iCurrentPreset == iSupportedPresets[0])
- {
- for (TInt index=0; index < iFactoryPresetAffectSettings.Count(); index++)
- {
- User::LeaveIfError(aSettings.Append(iFactoryPresetAffectSettings[index]));
- }
- }
- }
-
-void CTestCamPresets::GetAssociatedSettingsL(TUid aPreset, RArray<TUid>& aSettings) const
- {
- switch(aPreset.iUid)
- {
- case KUidECamPresetFactoryDefaultUidValue:
- {
- aSettings.Reset();
- for (TInt index=0; index < iFactoryPresetAffectSettings.Count(); index++)
- {
- User::LeaveIfError(aSettings.Append(iFactoryPresetAffectSettings[index]));
- }
- break;
- }
-
- //fall through
- case KUidECamPresetOutdoorUidValue:
- case KUidECamPresetOutdoorSportUidValue:
- case KUidECamPresetSnowUidValue:
- case KUidECamPresetBeachUidValue:
- case KUidECamPresetNightPortraitUidValue:
- case KUidECamPresetNightFireworksUidValue:
- case KUidECamPresetFogUidValue:
- case KUidECamPresetIndoorUidValue:
- case KUidECamPresetIndoorSportUidValue:
- {
- User::Leave(KErrNotSupported);
- }
- //fall through
- case KUidECamPresetNightPartyIndoorUidValue:
- case KUidECamPresetNightCloseUpUidValue:
- case KUidECamPresetNightMacroUidValue:
- case KUidECamPresetTextDocumentUidValue:
- case KUidECamPresetBarcodeUidValue:
- case KUidECamPresetAutoUidValue:
- case KUidECamPresetPortraitUidValue:
- case KUidECamPresetLandscapeUidValue:
- case KUidECamPresetAmbienceMoodUidValue:
- {
- if(iOwner.CameraVersion() == KCameraDefaultVersion)
- {
- User::Leave(KErrArgument);
- }
- else
- {
- User::Leave(KErrNotSupported);
- }
- }
-
- default:
- User::Leave(KErrArgument);
-
- }
- }
+// Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of the License "Symbian Foundation License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+// testadvancedsettings.cpp
+//
+//
+
+#include "test_advanced_settings.h"
+#include <ecamerrors.h>
+#include <ecam/ecamversion.h>
+
+CTestCamAdvSet::CTestCamAdvSet(CTestCamera& aOwner): iOwner(aOwner)
+ {
+ Init();
+ }
+
+CTestCamAdvSet::~CTestCamAdvSet()
+ {
+ iSupportedISORates.Close();
+ iSupportedApertures.Close();
+ iSupportedShutterSpeeds.Close();
+
+ CDataGlobal* globalData = static_cast <CDataGlobal*> (Dll::Tls());
+ if(globalData != NULL)
+ {
+ if(!globalData->iTestCamPresets && !globalData->iTestCamSnapshot && !globalData->iTestCamImgProc)
+ {
+ delete globalData;
+ Dll::FreeTls();
+ }
+ else
+ {
+ globalData->iTestCamAdvSet = NULL;
+ Dll::SetTls(globalData);
+ }
+ }
+ }
+
+CTestCamAdvSet* CTestCamAdvSet::NewL(CTestCamera& aOwner)
+ {
+ CDataGlobal* globalData = static_cast <CDataGlobal*> (Dll::Tls());
+
+ if(globalData == NULL)
+ {
+ globalData = new (ELeave) CDataGlobal;
+ CleanupStack::PushL(globalData);
+ globalData->iAdvSetReferenceCount = 0;
+ globalData->iTestCamAdvSet = new (ELeave) CTestCamAdvSet(aOwner);
+ CleanupStack::PushL(globalData->iTestCamAdvSet);
+ globalData->iTestCamAdvSet->ConstructL();
+ globalData->iTestCamAdvSet->iRefCount = 1;
+ User::LeaveIfError(Dll::SetTls(globalData));
+ CleanupStack::Pop(globalData->iTestCamAdvSet);
+ CleanupStack::Pop(globalData);
+ return globalData->iTestCamAdvSet;
+ }
+ else
+ {
+ if(globalData->iTestCamAdvSet == NULL)
+ {
+ globalData->iAdvSetReferenceCount = 0;
+ globalData->iTestCamAdvSet = new (ELeave) CTestCamAdvSet(aOwner);
+ CleanupStack::PushL(globalData->iTestCamAdvSet);
+ globalData->iTestCamAdvSet->ConstructL();
+ globalData->iTestCamAdvSet->iRefCount = 1;
+ User::LeaveIfError(Dll::SetTls(globalData));
+ CleanupStack::Pop(globalData->iTestCamAdvSet);
+ return globalData->iTestCamAdvSet;
+ }
+
+ CTestCamAdvSet* self = globalData->iTestCamAdvSet;
+
+ globalData->iAdvSetReferenceCount++;
+ self->iRefCount = globalData->iAdvSetReferenceCount + 1;
+ if (globalData->iAdvSetReferenceCount == KNumOfAdvSetExtensions-1 )
+ {
+ globalData->iTestCamAdvSet = NULL;
+ if(!globalData->iTestCamPresets && !globalData->iTestCamSnapshot && !globalData->iTestCamImgProc)
+ {
+ delete globalData;
+ Dll::FreeTls();
+ }
+ else
+ {
+ User::LeaveIfError(Dll::SetTls(globalData));
+ }
+ }
+ else
+ {
+ User::LeaveIfError(Dll::SetTls(globalData));
+ }
+ return self;
+ }
+ }
+
+void CTestCamAdvSet::Release()
+ {
+ iRefCount--;
+ if(iRefCount == 0)
+ {
+ iOwner.iAdvSettingsImpl = NULL;
+ delete this;
+ }
+ }
+
+void CTestCamAdvSet::Init()
+ {
+ for(TUint i=0; i< KNumAvailableCameras; i++)
+ {
+ iCameraTypes[i] = CCamera::CCameraAdvancedSettings::ECameraPluggable;
+ }
+
+ iFocusDistance = KDefaultFocusDistance;
+ iIsoRate = KDefaultIsoRate;
+ iISORateType = CCamera::CCameraAdvancedSettings::EISOManual;
+ iAperture = KDefaultAperture;
+ iShutterSpeed = KDefaultShutterSpeed;
+ }
+
+void CTestCamAdvSet::ConstructL()
+ {
+ iSupportedISORates.Reset();
+ iSupportedISORates.AppendL(KDefaultIsoRate);
+
+ iSupportedApertures.Reset();
+ iSupportedApertures.AppendL(KDefaultAperture);
+
+ iSupportedShutterSpeeds.Reset();
+ iSupportedShutterSpeeds.AppendL(KDefaultShutterSpeed);
+ }
+
+CCamera::CCameraAdvancedSettings::TCameraType CTestCamAdvSet::CameraType() const
+ {
+ return CCamera::CCameraAdvancedSettings::ECameraPluggable;
+ }
+
+CCamera::CCameraAdvancedSettings::TCameraType CTestCamAdvSet::CameraType(TInt aCameraIndex) const
+ {
+ if (aCameraIndex >= KNumAvailableCameras || aCameraIndex < 0)
+ {
+ return CCamera::CCameraAdvancedSettings::ECameraUnknown;
+ }
+ else
+ {
+ return iCameraTypes[aCameraIndex];
+ }
+ }
+
+TBool CTestCamAdvSet::IsCameraPresent() const
+ {
+ return ETrue;
+ }
+
+TBool CTestCamAdvSet::IsCameraPresent(TInt aCameraIndex) const
+ {
+ if (aCameraIndex >= KNumAvailableCameras || aCameraIndex < 0)
+ {
+ return EFalse;
+ }
+ else
+ {
+ return ETrue;
+ }
+ }
+
+TInt CTestCamAdvSet::CameraIndex() const
+ {
+ return iOwner.iCameraIndex;
+ }
+
+TInt CTestCamAdvSet::SupportedStabilizationModes() const
+ {
+ return KFeatureNotSupported;
+ }
+
+CCamera::CCameraAdvancedSettings::TStabilizationMode CTestCamAdvSet::StabilizationMode() const
+ {
+ return CCamera::CCameraAdvancedSettings::EStabilizationModeOff;
+ }
+
+void CTestCamAdvSet::SetStabilizationMode(CCamera::CCameraAdvancedSettings::TStabilizationMode aStabilizationMode)
+ {
+ TInt eventError = KErrNotSupported;
+ if(aStabilizationMode == CCamera::CCameraAdvancedSettings::EStabilizationModeOff)
+ {
+ eventError = KErrAlreadyExists;
+ }
+
+ TECAMEvent ecamevent(KUidECamEventCameraSettingStabilizationMode, eventError);
+
+ iOwner.iECamEvent = ecamevent;
+ iOwner.iHandleEventAsync.CallBack();
+ }
+
+TInt CTestCamAdvSet::SupportedFocusModes() const
+ {
+ return KFeatureNotSupported;
+ }
+
+CCamera::CCameraAdvancedSettings::TFocusMode CTestCamAdvSet::FocusMode() const
+ {
+ return CCamera::CCameraAdvancedSettings::EFocusModeAuto;
+ }
+
+void CTestCamAdvSet::SetFocusMode(CCamera::CCameraAdvancedSettings::TFocusMode aFocusMode)
+ {
+ TInt eventError = KErrNotSupported;
+ if(aFocusMode == CCamera::CCameraAdvancedSettings::EFocusModeAuto)
+ {
+ eventError = KErrAlreadyExists;
+ }
+
+ TECAMEvent ecamevent(KUidECamEventCameraSettingFocusMode, eventError);
+
+ iOwner.iECamEvent = ecamevent;
+ iOwner.iHandleEventAsync.CallBack();
+ }
+
+TInt CTestCamAdvSet::SupportedFocusRanges() const
+ {
+ return KFeatureNotSupported;
+ }
+
+CCamera::CCameraAdvancedSettings::TFocusRange CTestCamAdvSet::FocusRange() const
+ {
+ return CCamera::CCameraAdvancedSettings::EFocusRangeAuto;
+ }
+
+void CTestCamAdvSet::SetFocusRange(CCamera::CCameraAdvancedSettings::TFocusRange aFocusRange)
+ {
+ TInt eventError = KErrNotSupported;
+ if(aFocusRange == CCamera::CCameraAdvancedSettings::EFocusRangeAuto)
+ {
+ eventError = KErrAlreadyExists;
+ }
+
+ TECAMEvent ecamevent1(KUidECamEventCameraSettingFocusRange2, eventError);
+ TECAMEvent ecamevent2(KUidECamEventCameraSettingFocusRange, eventError);
+
+ iOwner.iECamEvent = ecamevent1;
+ iOwner.iHandleEventAsync.CallBack();
+
+ iOwner.iECamEvent = ecamevent2;
+ iOwner.iHandleEventAsync.CallBack();
+ }
+
+TInt CTestCamAdvSet::SupportedAutoFocusTypes() const
+ {
+ return KFeatureNotSupported;
+ }
+
+CCamera::CCameraAdvancedSettings::TAutoFocusType CTestCamAdvSet::AutoFocusType() const
+ {
+ return CCamera::CCameraAdvancedSettings::EAutoFocusTypeOff;
+ }
+
+void CTestCamAdvSet::SetAutoFocusType(CCamera::CCameraAdvancedSettings::TAutoFocusType aAutoFocusType)
+ {
+ TInt eventError = KErrNotSupported;
+ if(aAutoFocusType == CCamera::CCameraAdvancedSettings::EAutoFocusTypeOff)
+ {
+ eventError = KErrAlreadyExists;
+ }
+
+ TECAMEvent ecamevent1(KUidECamEventCameraSettingAutoFocusType2, eventError);
+ TECAMEvent ecamevent2(KUidECamEventCameraSettingAutoFocusType, eventError);
+
+ iOwner.iECamEvent = ecamevent1;
+ iOwner.iHandleEventAsync.CallBack();
+
+ iOwner.iECamEvent = ecamevent2;
+ iOwner.iHandleEventAsync.CallBack();
+ }
+
+TInt CTestCamAdvSet::SupportedAutoFocusAreas() const
+ {
+ return KFeatureNotSupported;
+ }
+
+CCamera::CCameraAdvancedSettings::TAutoFocusArea CTestCamAdvSet::AutoFocusArea() const
+ {
+ return CCamera::CCameraAdvancedSettings::EAutoFocusTypeAuto;
+ }
+
+void CTestCamAdvSet::SetAutoFocusArea(CCamera::CCameraAdvancedSettings::TAutoFocusArea aAutoFocusArea)
+ {
+ TInt eventError = KErrNotSupported;
+ if(aAutoFocusArea == CCamera::CCameraAdvancedSettings::EAutoFocusTypeAuto)
+ {
+ eventError = KErrAlreadyExists;
+ }
+
+ TECAMEvent ecamevent(KUidECamEventCameraSettingAutoFocusArea, eventError);
+
+ iOwner.iECamEvent = ecamevent;
+ iOwner.iHandleEventAsync.CallBack();
+ }
+
+TInt CTestCamAdvSet::FocusDistance() const
+ {
+ return iFocusDistance;
+ }
+
+void CTestCamAdvSet::SetFocusDistance(TInt aDistance)
+ {
+ TInt eventError = KErrNone;
+ if(aDistance < 0)
+ {
+ eventError = KErrNotSupported;
+ }
+ else
+ {
+ iFocusDistance = aDistance;
+ }
+
+ TECAMEvent ecamevent(KUidECamEventCameraSettingFocusDistance, eventError);
+
+ iOwner.iECamEvent = ecamevent;
+ iOwner.iHandleEventAsync.CallBack();
+ }
+
+TInt CTestCamAdvSet::GetMinFocalLength() const
+ {
+ return KErrNotSupported;
+ }
+
+void CTestCamAdvSet::GetSupportedIsoRatesL(RArray<TInt>& aSupportedIsoRates) const
+ {
+ if(iSupportedISORates.Count() == 0)
+ {
+ User::Leave(KErrNotSupported);
+ }
+
+ for(TInt index=0; index < iSupportedISORates.Count(); index++)
+ {
+ aSupportedIsoRates.AppendL(iSupportedISORates[index]);
+ }
+ }
+
+TInt CTestCamAdvSet::IsoRate() const
+ {
+ return iIsoRate;
+ }
+
+void CTestCamAdvSet::SetIsoRate(TInt aRate)
+ {
+ TInt eventError = KErrNone;
+ if(iSupportedISORates.Find(aRate) == KErrNotFound)
+ {
+ eventError = KErrECamParameterNotInRange;
+ }
+ else
+ {
+ //set the ISO type to Manual
+ iISORateType = CCamera::CCameraAdvancedSettings::EISOManual;
+ iIsoRate = aRate;
+ }
+
+ TECAMEvent ecamevent(KUidECamEventCameraSettingIsoRate, eventError);
+
+ iOwner.iECamEvent = ecamevent;
+ iOwner.iHandleEventAsync.CallBack();
+ }
+
+void CTestCamAdvSet::GetSupportedISORateTypeL(TInt& aSupportedISORateTypes) const
+ {
+ aSupportedISORateTypes = KSupportedISORateTypes;
+ }
+
+void CTestCamAdvSet::SetISORate(CCamera::CCameraAdvancedSettings::TISORateType aISORateType, TInt aParam)
+ {
+ TInt eventError = KErrNone;
+
+ if(!(aISORateType & KSupportedISORateTypes) || iSupportedISORates.Count() == 0)
+ {
+ eventError = KErrNotSupported;
+ }
+ else
+ {
+ switch(aISORateType)
+ {
+ case CCamera::CCameraAdvancedSettings::EISOManual:
+ {
+ if(iSupportedISORates.Find(aParam) == KErrNotFound)
+ {
+ eventError = KErrECamParameterNotInRange;
+ }
+ else
+ {
+ iISORateType = aISORateType;
+ if(aParam == iIsoRate)
+ {
+ eventError = KErrAlreadyExists;
+ }
+ else
+ {
+ iIsoRate = aParam;
+ }
+ }
+ break;
+ }
+ case CCamera::CCameraAdvancedSettings::EISOAutoUnPrioritised:
+ {
+ eventError = KErrNotSupported;
+ break;
+ }
+ case CCamera::CCameraAdvancedSettings::EISOAutoISOPrioritised:
+ {
+ eventError = KErrNotSupported;
+ break;
+ }
+ case CCamera::CCameraAdvancedSettings::EISOAutoShutterSpeedPrioritised:
+ {
+ eventError = KErrNotSupported;
+ break;
+ }
+ case CCamera::CCameraAdvancedSettings::EISOAutoAperturePrioritised:
+ {
+ eventError = KErrNotSupported;
+ break;
+ }
+ default:
+ eventError = KErrNotSupported;
+ }
+ }
+
+ TECAMEvent ecamevent(KUidECamEventCameraSettingIsoRateType, eventError);
+
+ iOwner.iECamEvent = ecamevent;
+ iOwner.iHandleEventAsync.CallBack();
+ }
+
+void CTestCamAdvSet::GetISORateL(CCamera::CCameraAdvancedSettings::TISORateType& aISORateType, TInt& /*aParam*/, TInt& aISORate) const
+ {
+ //If camera has no ISO rate supported, then leave
+ if(iSupportedISORates.Count() == 0)
+ {
+ User::Leave(KErrNotSupported);
+ }
+
+ aISORateType = iISORateType;
+ aISORate = iIsoRate;
+// aParam is redundant for manual ISO.
+ }
+
+void CTestCamAdvSet::GetAperturesL(RArray<TInt>& aFStops, TValueInfo& aInfo) const
+ {
+ if(iSupportedApertures.Count() == 0)
+ {
+ aFStops.Reset();
+ aInfo = ENotActive;
+ }
+
+ for(TInt index=0; index < iSupportedApertures.Count(); index++)
+ {
+ aFStops.AppendL(iSupportedApertures[index]);
+ }
+
+ aInfo = EDiscreteSteps;
+ }
+
+TInt CTestCamAdvSet::Aperture() const
+ {
+ return iAperture;
+ }
+
+void CTestCamAdvSet::SetAperture(TInt aFStop)
+ {
+ TInt eventError = KErrNone;
+ if(iSupportedApertures.Find(aFStop) == KErrNotFound)
+ {
+ eventError = KErrECamParameterNotInRange;
+ }
+ else
+ {
+ iAperture = aFStop;
+ }
+
+ TECAMEvent ecamevent(KUidECamEventCameraSettingAperture, eventError);
+
+ iOwner.iECamEvent = ecamevent;
+ iOwner.iHandleEventAsync.CallBack();
+ }
+
+void CTestCamAdvSet::GetShutterSpeedsL(RArray<TInt>& aShutterSpeeds, TValueInfo& aInfo) const
+ {
+ if(iSupportedShutterSpeeds.Count() == 0)
+ {
+ aShutterSpeeds.Reset();
+ aInfo = ENotActive;
+ }
+
+ for(TInt index=0; index < iSupportedShutterSpeeds.Count(); index++)
+ {
+ aShutterSpeeds.AppendL(iSupportedShutterSpeeds[index]);
+ aInfo = EDiscreteSteps;
+ }
+ }
+
+TInt CTestCamAdvSet::ShutterSpeed() const
+ {
+ return iShutterSpeed;
+ }
+
+void CTestCamAdvSet::SetShutterSpeed(TInt aShutterSpeed)
+ {
+ TInt eventError = KErrNone;
+ if(iSupportedShutterSpeeds.Find(aShutterSpeed) == KErrNotFound)
+ {
+ eventError = KErrECamParameterNotInRange;
+ }
+ else
+ {
+ iShutterSpeed = aShutterSpeed;
+ }
+
+ TECAMEvent ecamevent(KUidECamEventCameraSettingShutterSpeed, eventError);
+
+ iOwner.iECamEvent = ecamevent;
+ iOwner.iHandleEventAsync.CallBack();
+ }
+
+TInt CTestCamAdvSet::SupportedMeteringModes() const
+ {
+ return KFeatureNotSupported;
+ }
+
+CCamera::CCameraAdvancedSettings::TMeteringMode CTestCamAdvSet::MeteringMode() const
+ {
+ return CCamera::CCameraAdvancedSettings::EMeteringModeAuto;
+ }
+
+void CTestCamAdvSet::SetMeteringMode(CCamera::CCameraAdvancedSettings::TMeteringMode aMeteringMode)
+ {
+ TInt eventError = KErrNotSupported;
+ if(aMeteringMode == CCamera::CCameraAdvancedSettings::EMeteringModeAuto)
+ {
+ eventError = KErrAlreadyExists;
+ }
+
+ TECAMEvent ecamevent(KUidECamEventCameraSettingMeteringMode, eventError);
+
+ iOwner.iECamEvent = ecamevent;
+ iOwner.iHandleEventAsync.CallBack();
+ }
+
+TInt CTestCamAdvSet::SupportedDriveModes() const
+ {
+ return KSupportedDriveModes;
+ }
+
+CCamera::CCameraAdvancedSettings::TDriveMode CTestCamAdvSet::DriveMode() const
+ {
+ return iOwner.iDriveMode;
+ }
+
+void CTestCamAdvSet::SetDriveMode(CCamera::CCameraAdvancedSettings::TDriveMode aDriveMode)
+ {
+ TInt eventError = KErrNone;
+ if(iOwner.iVideoCaptureActive || iOwner.iImageCaptureActive)
+ {
+ eventError = KErrNotReady;
+ }
+ else
+ {
+ if(!(aDriveMode & KSupportedDriveModes))
+ {
+ eventError = KErrNotSupported;
+ }
+ else
+ {
+ if(eventError == KErrNone)
+ {
+ iOwner.iDriveMode = aDriveMode;
+ }
+ }
+ }
+
+ TECAMEvent ecamevent(KUidECamEventCameraSettingDriveMode, eventError);
+
+ iOwner.iECamEvent = ecamevent;
+ iOwner.iHandleEventAsync.CallBack();
+ }
+
+TInt CTestCamAdvSet::SupportedBracketModes() const
+ {
+ return KFeatureNotSupported;
+ }
+
+CCamera::CCameraAdvancedSettings::TBracketMode CTestCamAdvSet::BracketMode() const
+ {
+ return CCamera::CCameraAdvancedSettings::EBracketModeOff;
+ }
+
+void CTestCamAdvSet::SetBracketMode(CCamera::CCameraAdvancedSettings::TBracketMode aBracketMode)
+ {
+ TInt eventError = KErrNotSupported;
+ if(aBracketMode == CCamera::CCameraAdvancedSettings::EBracketModeOff)
+ {
+ eventError = KErrAlreadyExists;
+ }
+
+ TECAMEvent ecamevent(KUidECamEventCameraSettingBracketMode, eventError);
+
+ iOwner.iECamEvent = ecamevent;
+ iOwner.iHandleEventAsync.CallBack();
+ }
+
+TInt CTestCamAdvSet::SupportedBracketParameters() const
+ {
+ return KFeatureNotSupported;
+ }
+
+CCamera::CCameraAdvancedSettings::TBracketParameter CTestCamAdvSet::BracketParameter() const
+ {
+ return CCamera::CCameraAdvancedSettings::EBracketParameterNone;
+ }
+
+void CTestCamAdvSet::SetBracketParameter(CCamera::CCameraAdvancedSettings::TBracketParameter aBracketParameter)
+ {
+ TInt eventError = KErrNotSupported;
+ if(aBracketParameter == CCamera::CCameraAdvancedSettings::EBracketParameterNone)
+ {
+ eventError = KErrAlreadyExists;
+ }
+
+ TECAMEvent ecamevent(KUidECamEventCameraSettingBracketParameter, eventError);
+
+ iOwner.iECamEvent = ecamevent;
+ iOwner.iHandleEventAsync.CallBack();
+ }
+
+TInt CTestCamAdvSet::SupportedBracketSteps() const
+ {
+ return KFeatureNotSupported;
+ }
+
+CCamera::CCameraAdvancedSettings::TBracketStep CTestCamAdvSet::BracketStep() const
+ {
+ return CCamera::CCameraAdvancedSettings::EBracketStepNonConfig;
+ }
+
+void CTestCamAdvSet::SetBracketStep(CCamera::CCameraAdvancedSettings::TBracketStep aBracketStep)
+ {
+ TInt eventError = KErrNotSupported;
+ if(aBracketStep == CCamera::CCameraAdvancedSettings::EBracketStepNonConfig)
+ {
+ eventError = KErrAlreadyExists;
+ }
+
+ TECAMEvent ecamevent(KUidECamEventCameraSettingBracketStep, eventError);
+
+ iOwner.iECamEvent = ecamevent;
+ iOwner.iHandleEventAsync.CallBack();
+ }
+
+void CTestCamAdvSet::GetBracketMerge(TInt& aStartIndex, TInt& aFrames) const
+ {
+ aStartIndex = KFeatureNotSupported;
+ aFrames = KFeatureNotSupported;
+ }
+
+void CTestCamAdvSet::SetBracketMerge(TInt /*aStartIndex*/ , TInt /*aFrames*/)
+ {
+ TECAMEvent ecamevent(KUidECamEventBracketMerge, KErrNotSupported);
+
+ iOwner.iECamEvent = ecamevent;
+ iOwner.iHandleEventAsync.CallBack();
+ }
+
+TInt CTestCamAdvSet::SupportedFlashModes() const
+ {
+ return KFeatureNotSupported;
+ }
+
+CCamera::TFlash CTestCamAdvSet::FlashMode() const
+ {
+ return CCamera::EFlashNone;
+ }
+
+void CTestCamAdvSet::SetFlashMode(CCamera::TFlash /*aMode*/)
+ {
+ TECAMEvent ecamevent(KUidECamEventCameraSettingFlashMode, KErrNotSupported);
+
+ iOwner.iECamEvent = ecamevent;
+ iOwner.iHandleEventAsync.CallBack();
+ }
+
+TBool CTestCamAdvSet::RedEyeReduceOn() const
+ {
+ return KDefaultRedEyeReduce;
+ }
+
+void CTestCamAdvSet::SetRedEyeReduceOn(TBool /*aState*/)
+ {
+ TECAMEvent ecamevent(KUidECamEventCameraSettingFlashRedEyeReduce, KErrNotSupported);
+
+ iOwner.iECamEvent = ecamevent;
+ iOwner.iHandleEventAsync.CallBack();
+ }
+
+void CTestCamAdvSet::GetFlashCompensationStepsL(RArray<TInt>& aFlashCompensationSteps, TValueInfo& aInfo) const
+ {
+ aFlashCompensationSteps.Reset();
+ aInfo = ENotActive;
+ }
+
+TInt CTestCamAdvSet::FlashCompensationStep() const
+ {
+ return KFlashCompensationStep;
+ }
+
+TInt CTestCamAdvSet::GetFlashCompensationStep(TInt& aFlashCompensationStep) const
+ {
+ aFlashCompensationStep = KFlashCompensationStep;
+ return KErrNone;
+ }
+
+void CTestCamAdvSet::GetFlashCompensationRangeInSteps(TInt& aNegativeCompensation, TInt& aPositiveCompensation) const
+ {
+ aNegativeCompensation = KFlashCompensationStep;
+ aPositiveCompensation = KFlashCompensationStep;
+ }
+
+void CTestCamAdvSet::SetFlashCompensationStep(TInt /*aFlashCompensationStep*/)
+ {
+ TECAMEvent ecamevent(KUidECamEventCameraSettingFlashCompensationStep, KErrNotSupported);
+
+ iOwner.iECamEvent = ecamevent;
+ iOwner.iHandleEventAsync.CallBack();
+ }
+
+TInt CTestCamAdvSet::FlashCompensation() const
+ {
+ return KFlashCompensationStep;
+ }
+
+TInt CTestCamAdvSet::GetFlashCompensation(TInt& aFlashCompensation) const
+ {
+ aFlashCompensation = KFlashCompensationStep;
+ return KErrNone;
+ }
+
+void CTestCamAdvSet::SetFlashCompensation(TInt /*aFlashCompensation*/)
+ {
+ TECAMEvent ecamevent(KUidECamEventCameraSettingFlashCompensation, KErrNotSupported);
+
+ iOwner.iECamEvent = ecamevent;
+ iOwner.iHandleEventAsync.CallBack();
+ }
+
+TBool CTestCamAdvSet::IsExternalFlashPresent() const
+ {
+ return KExternalFlashPresentState;
+ }
+
+void CTestCamAdvSet::GetManualFlashPowerLevelsL(RArray<TInt>& aManualFlashPowerLevels, TValueInfo& aInfo) const
+ {
+ aManualFlashPowerLevels.Reset();
+ aInfo = ENotActive;
+ }
+
+TInt CTestCamAdvSet::ManualFlashPowerLevel() const
+ {
+ return KErrNotSupported;
+ }
+
+void CTestCamAdvSet::SetManualFlashPowerLevel(TInt /*aManualFlashPowerLevel*/)
+ {
+ TECAMEvent ecamevent(KUidECamEventCameraSettingFlashManualPower, KErrNotSupported);
+
+ iOwner.iECamEvent = ecamevent;
+ iOwner.iHandleEventAsync.CallBack();
+ }
+
+TInt CTestCamAdvSet::SupportedExposureModes() const
+ {
+ return CCamera::EExposureAuto;
+ }
+
+CCamera::TExposure CTestCamAdvSet::ExposureMode() const
+ {
+ return CCamera::EExposureAuto;
+ }
+
+void CTestCamAdvSet::SetExposureMode(CCamera::TExposure aExposureMode)
+ {
+ TInt eventError = KErrNotSupported;
+ if(aExposureMode == CCamera::EExposureAuto)
+ {
+ eventError = KErrAlreadyExists;
+ }
+
+ TECAMEvent ecamevent(KUidECamEventCameraSettingExposureMode, eventError);
+
+ iOwner.iECamEvent = ecamevent;
+ iOwner.iHandleEventAsync.CallBack();
+ }
+
+void CTestCamAdvSet::GetExposureCompensationStepsL(RArray<TInt>& aExposureCompensationSteps, TValueInfo& aInfo) const
+ {
+ aExposureCompensationSteps.Reset();
+ aInfo = ENotActive;
+ }
+
+void CTestCamAdvSet::GetExposureCompensationRangeInSteps(TInt& aNegativeCompensation, TInt& aPositiveCompensation) const
+ {
+ aNegativeCompensation = KExposureCompensationStep;
+ aPositiveCompensation = KExposureCompensationStep;
+ }
+
+TInt CTestCamAdvSet::ExposureCompensationStep() const
+ {
+ return KExposureCompensationStep;
+ }
+
+TInt CTestCamAdvSet::GetExposureCompensationStep(TInt& aExposureCompensationStep) const
+ {
+ aExposureCompensationStep = KExposureCompensationStep;
+ return KErrNone;
+ }
+
+void CTestCamAdvSet::SetExposureCompensationStep(TInt /*aExposureCompensationStep*/)
+ {
+ TECAMEvent ecamevent(KUidECamEventCameraSettingExposureCompensationStep, KErrNotSupported);
+
+ iOwner.iECamEvent = ecamevent;
+ iOwner.iHandleEventAsync.CallBack();
+ }
+
+TInt CTestCamAdvSet::ExposureCompensation() const
+ {
+ return KExposureCompensationStep;
+ }
+
+TInt CTestCamAdvSet::GetExposureCompensation(TInt& aExposureCompensation) const
+ {
+ aExposureCompensation = KExposureCompensationStep;
+ return KErrNone;
+ }
+
+void CTestCamAdvSet::SetExposureCompensation(TInt /*aExposureCompensation*/)
+ {
+ TECAMEvent ecamevent(KUidECamEventCameraSettingExposureCompensation, KErrNotSupported);
+
+ iOwner.iECamEvent = ecamevent;
+ iOwner.iHandleEventAsync.CallBack();
+ }
+
+TInt CTestCamAdvSet::SupportedWhiteBalanceModes() const
+ {
+ return KFeatureNotSupported;
+ }
+
+CCamera::TWhiteBalance CTestCamAdvSet::WhiteBalanceMode() const
+ {
+ return CCamera::EWBAuto;
+ }
+
+void CTestCamAdvSet::SetWhiteBalanceMode(CCamera::TWhiteBalance aWhiteBalanceMode)
+ {
+ TInt eventError = KErrNotSupported;
+ if(aWhiteBalanceMode == CCamera::EWBAuto)
+ {
+ eventError = KErrAlreadyExists;
+ }
+
+ TECAMEvent ecamevent(KUidECamEventCameraSettingWhiteBalanceMode, eventError);
+
+ iOwner.iECamEvent = ecamevent;
+ iOwner.iHandleEventAsync.CallBack();
+ }
+
+TBool CTestCamAdvSet::ApertureExposureLockOn() const
+ {
+ return KApertureExposureLockOn;
+ }
+
+void CTestCamAdvSet::SetApertureExposureLockOn(TBool /*aAELock*/)
+ {
+ TECAMEvent ecamevent(KUidECamEventAELock, KErrNotSupported);
+
+ iOwner.iECamEvent = ecamevent;
+ iOwner.iHandleEventAsync.CallBack();
+ }
+
+TBool CTestCamAdvSet::ShootClickOn() const
+ {
+ return KShootClickOn;
+ }
+
+void CTestCamAdvSet::SetShootClickOn(TBool /*aShootClickOn*/)
+ {
+ TECAMEvent ecamevent(KUidECamEventSoundClick, KErrNotSupported);
+
+ iOwner.iECamEvent = ecamevent;
+ iOwner.iHandleEventAsync.CallBack();
+ }
+
+void CTestCamAdvSet::GetTimerIntervalsL(RArray<TInt>& aTimerIntervals, TValueInfo& aInfo) const
+ {
+ aTimerIntervals.Reset();
+ aInfo = ENotActive;
+ }
+
+TInt CTestCamAdvSet::TimerInterval() const
+ {
+ return KErrNotSupported;
+ }
+
+void CTestCamAdvSet::SetTimerInterval(TInt /*aTimerInterval*/)
+ {
+ TECAMEvent ecamevent(KUidECamEventCameraSettingTimerInterval, KErrNotSupported);
+
+ iOwner.iECamEvent = ecamevent;
+ iOwner.iHandleEventAsync.CallBack();
+ }
+
+void CTestCamAdvSet::GetTimeLapsePeriodRange(TTime& aTimeLapseMin, TTime& aTimeLapseMax) const
+ {
+ TTime timeLapse(KTimeLapse);
+ aTimeLapseMin = aTimeLapseMax = timeLapse;
+ }
+
+void CTestCamAdvSet::GetTimeLapse(TTime& aStart, TTime& aEnd, TTime& aInterval) const
+ {
+ TTime timeLapse(KTimeLapse);
+ aStart = aEnd = aInterval = timeLapse;
+ }
+
+void CTestCamAdvSet::SetTimeLapse(const TTime& /*aStart*/, const TTime& /*aEnd*/, const TTime& /*aInterval*/)
+ {
+ TECAMEvent ecamevent(KUidECamEventCameraSettingTimeLapse, KErrNotSupported);
+
+ iOwner.iECamEvent = ecamevent;
+ iOwner.iHandleEventAsync.CallBack();
+ }
+
+CCamera::CCameraAdvancedSettings::TPictureOrientation CTestCamAdvSet::PictureOrientation() const
+ {
+ return CCamera::CCameraAdvancedSettings::EPictureOrientationUnknown;
+ }
+
+void CTestCamAdvSet::SetPictureOrientation(CCamera::CCameraAdvancedSettings::TPictureOrientation aOrientation)
+ {
+ TInt eventError = KErrNotSupported;
+
+ if(iOwner.iVideoCaptureActive || iOwner.iImageCaptureActive)
+ {
+ eventError = KErrNotReady;
+ }
+ else
+ {
+ if(aOrientation == CCamera::CCameraAdvancedSettings::EPictureOrientationUnknown)
+ {
+ eventError = KErrAlreadyExists;
+ }
+ }
+
+ TECAMEvent ecamevent(KUidECamEventCameraSettingPictureOrientation, eventError);
+
+ iOwner.iECamEvent = ecamevent;
+ iOwner.iHandleEventAsync.CallBack();
+ }
+
+TInt CTestCamAdvSet::SupportedPixelAspectRatios() const
+ {
+ return KSupportedPixelAspectRatio;
+ }
+
+CCamera::CCameraAdvancedSettings::TPixelAspectRatio CTestCamAdvSet::PixelAspectRatio() const
+ {
+ return CCamera::CCameraAdvancedSettings::EPixelAspectUnknown;
+ }
+
+void CTestCamAdvSet::SetPixelAspectRatio(CCamera::CCameraAdvancedSettings::TPixelAspectRatio aPixelAspectRatio)
+ {
+ TInt eventError = KErrNotSupported;
+
+ if(aPixelAspectRatio == CCamera::CCameraAdvancedSettings::EPixelAspectUnknown)
+ {
+ eventError = KErrAlreadyExists;
+ }
+
+ TECAMEvent ecamevent(KUidECamEventPixelAspectRatio, eventError);
+
+ iOwner.iECamEvent = ecamevent;
+ iOwner.iHandleEventAsync.CallBack();
+ }
+
+TInt CTestCamAdvSet::SupportedYuvRanges() const
+ {
+ return KSupportedYuvRange;
+ }
+
+CCamera::CCameraAdvancedSettings::TYuvRange CTestCamAdvSet::YuvRange() const
+ {
+ return CCamera::CCameraAdvancedSettings::EYuvRangeUnknown;
+ }
+
+void CTestCamAdvSet::SetYuvRange(CCamera::CCameraAdvancedSettings::TYuvRange aYuvRange)
+ {
+ TInt eventError = KErrNotSupported;
+
+ if(aYuvRange == CCamera::CCameraAdvancedSettings::EYuvRangeUnknown)
+ {
+ eventError = KErrAlreadyExists;
+ }
+
+ TECAMEvent ecamevent(KUidECamEventYuvRange, eventError);
+
+ iOwner.iECamEvent = ecamevent;
+ iOwner.iHandleEventAsync.CallBack();
+ }
+
+TInt CTestCamAdvSet::BurstImages() const
+ {
+ return iOwner.iBurstImages;
+ }
+
+void CTestCamAdvSet::SetBurstImages(TInt aImages)
+ {
+ TInt eventError = iOwner.CheckReserveAndPower();
+
+ if(eventError == KErrNone)
+ {
+ if(aImages == iOwner.iBurstImages)
+ {
+ eventError = KErrAlreadyExists;
+ }
+ else
+ {
+ if(aImages<1)
+ {
+ eventError = KErrArgument;
+ }
+ }
+ }
+
+ if(eventError != KErrNone)
+ {
+ TECAMEvent ecamevent(KUidECamEventBurstImages, eventError);
+
+ iOwner.iECamEvent = ecamevent;
+ iOwner.iHandleEventAsync.CallBack();
+ return;
+ }
+
+ if(aImages > KMaxBurstImages)
+ {
+ iOwner.iBurstImages = KMaxBurstImages;
+ }
+ else
+ {
+ iOwner.iBurstImages = aImages;
+ }
+
+ TECAMEvent ecamevent(KUidECamEventBurstImages, eventError);
+
+ iOwner.iECamEvent = ecamevent;
+ iOwner.iHandleEventAsync.CallBack();
+ }
+
+void CTestCamAdvSet::GetOpticalZoomStepsL(RArray<TInt>& aOpticalZoomSteps, TValueInfo& aInfo) const
+ {
+ aOpticalZoomSteps.Reset();
+ aOpticalZoomSteps.AppendL(KECamFineResolutionFactor);
+ aInfo = EDiscreteSteps;
+ }
+
+TInt CTestCamAdvSet::OpticalZoom() const
+ {
+ return KECamFineResolutionFactor;
+ }
+
+void CTestCamAdvSet::SetOpticalZoom(TInt aOpticalZoom)
+ {
+ TInt eventError = KErrNotSupported;
+
+ if(aOpticalZoom == KECamFineResolutionFactor)
+ {
+ eventError = KErrAlreadyExists;
+ }
+
+ TECAMEvent ecamevent(KUidECamEventCameraSettingOpticalZoom, eventError);
+
+ iOwner.iECamEvent = ecamevent;
+ iOwner.iHandleEventAsync.CallBack();
+ }
+
+void CTestCamAdvSet::GetDigitalZoomStepsL(RArray<TInt>& aDigitalZoomSteps,
+ TValueInfo& aInfo) const
+ {
+ aDigitalZoomSteps.Reset();
+ aDigitalZoomSteps.AppendL(KECamFineResolutionFactor);
+ aInfo = EDiscreteSteps;
+ }
+
+void CTestCamAdvSet::GetDigitalZoomStepsForStillL(RArray<TInt>& aDigitalZoomSteps, TValueInfo& aInfo, TInt /*aSizeIndex*/,
+ CCamera::TFormat /*aFormat*/, TBool& /*aIsInfluencePossible*/) const
+ {
+ aDigitalZoomSteps.Reset();
+ aDigitalZoomSteps.AppendL(KECamFineResolutionFactor);
+ aInfo = EDiscreteSteps;
+ }
+
+void CTestCamAdvSet::GetDigitalZoomStepsForVideoL(RArray<TInt>& aDigitalZoomSteps, TValueInfo& aInfo, TInt /*aFrameRateIndex*/,
+ TInt /*aSizeIndex*/, CCamera::TFormat /*aFormat*/, TBool& /*aIsInfluencePossible*/, CCamera::TExposure /*aExposure*/) const
+ {
+ aDigitalZoomSteps.Reset();
+ aDigitalZoomSteps.AppendL(KECamFineResolutionFactor);
+ aInfo = EDiscreteSteps;
+ }
+
+TInt CTestCamAdvSet::DigitalZoom() const
+ {
+ return KECamFineResolutionFactor;
+ }
+
+void CTestCamAdvSet::SetDigitalZoom(TInt aDigitalZoom)
+ {
+ TInt eventError = KErrNotSupported;
+
+ if(aDigitalZoom == KECamFineResolutionFactor)
+ {
+ eventError = KErrAlreadyExists;
+ }
+
+ TECAMEvent ecamevent(KUidECamEventCameraSettingDigitalZoom, eventError);
+
+ iOwner.iECamEvent = ecamevent;
+ iOwner.iHandleEventAsync.CallBack();
+ }
+
+TBool CTestCamAdvSet::ExposureLockOn() const
+ {
+ return KExposureLockOn;
+ }
+
+void CTestCamAdvSet::SetExposureLockOn(TBool aState)
+ {
+ TInt eventError = KErrNotSupported;
+
+ if(aState == KExposureLockOn)
+ {
+ eventError = KErrAlreadyExists;
+ }
+
+ TECAMEvent ecamevent(KUidECamEventCameraSettingExposureLock, eventError);
+
+ iOwner.iECamEvent = ecamevent;
+ iOwner.iHandleEventAsync.CallBack();
+ }
+
+TBool CTestCamAdvSet::AutoFocusLockOn() const
+ {
+ return KAutoFocusLockOn;
+ }
+
+void CTestCamAdvSet::SetAutoFocusLockOn(TBool aState)
+ {
+ TInt eventError = KErrNotSupported;
+
+ if(aState == KAutoFocusLockOn)
+ {
+ eventError = KErrAlreadyExists;
+ }
+
+ TECAMEvent ecamevent(KUidECamEventCameraSettingAutoFocusLock, eventError);
+
+ iOwner.iECamEvent = ecamevent;
+ iOwner.iHandleEventAsync.CallBack();
+ }
+
+void CTestCamAdvSet::GetSupportedSettingsL(RArray<TUid>& aSettings) const
+ {
+ aSettings.Reset();
+ User::Leave(KErrNotSupported);
+ }
+
+void CTestCamAdvSet::GetActiveSettingsL(RArray<TUid>& aActiveSettings) const
+ {
+ aActiveSettings.Reset();
+ User::Leave(KErrNotSupported);
+ }
+
+void CTestCamAdvSet::GetDisabledSettingsL(RArray<TUid>& aDisbledSettings) const
+ {
+ aDisbledSettings.Reset();
+ User::Leave(KErrNotSupported);
+ }
+
+void CTestCamAdvSet::SetAutomaticSizeSelectionChangeOn(TBool aSetOn)
+ {
+ TInt eventError = KErrNotSupported;
+
+ if(aSetOn == KAutomaticSizeSelectionChangeOn)
+ {
+ eventError = KErrAlreadyExists;
+ }
+
+ TECAMEvent ecamevent(KUidECamEventCameraSettingAutomaticSizeSelection, eventError);
+
+ iOwner.iECamEvent = ecamevent;
+ iOwner.iHandleEventAsync.CallBack();
+ }
+
+TBool CTestCamAdvSet::AutomaticSizeSelectionChangeOn() const
+ {
+ return KAutomaticSizeSelectionChangeOn;
+ }
+
+void CTestCamAdvSet::GetSupportedContinuousAutoFocusTimeoutsL(RArray<TInt>& aTimeouts, TValueInfo& aInfo) const
+ {
+ aTimeouts.Reset();
+ aInfo = ENotActive;
+ }
+
+void CTestCamAdvSet::SetContinuousAutoFocusTimeout(TInt /*aTimeout*/)
+ {
+ TECAMEvent ecamevent(KUidECamEventCameraSettingsContinuousAutoFocusTimeout, KErrNotSupported);
+
+ iOwner.iECamEvent = ecamevent;
+ iOwner.iHandleEventAsync.CallBack();
+ }
+
+void CTestCamAdvSet::SetStabilizationEffect(CCamera::CCameraAdvancedSettings::TStabilizationEffect aEffect)
+ {
+ TInt eventError = KErrNotSupported;
+
+ if(aEffect == KStabilizationEffect)
+ {
+ eventError = KErrAlreadyExists;
+ }
+
+ TECAMEvent ecamevent(KUidECamEventCameraSettingsStabilizationEffect, eventError);
+
+ iOwner.iECamEvent = ecamevent;
+ iOwner.iHandleEventAsync.CallBack();
+ }
+
+CCamera::CCameraAdvancedSettings::TStabilizationEffect CTestCamAdvSet::StabilizationEffect() const
+ {
+ return KStabilizationEffect;
+ }
+
+TInt CTestCamAdvSet::SupportedStabilizationEffects() const
+ {
+ return KStabilizationEffect;
+ }
+
+TInt CTestCamAdvSet::SupportedStabilizationComplexityValues() const
+ {
+ return KStabilizationComplexity;
+ }
+
+CCamera::CCameraAdvancedSettings::TStabilizationAlgorithmComplexity CTestCamAdvSet::StabilizationComplexity() const
+ {
+ return KStabilizationComplexity;
+ }
+
+void CTestCamAdvSet::SetStabilizationComplexity(CCamera::CCameraAdvancedSettings::TStabilizationAlgorithmComplexity aComplexity)
+ {
+ TInt eventError = KErrNotSupported;
+
+ if(aComplexity == KStabilizationComplexity)
+ {
+ eventError = KErrAlreadyExists;
+ }
+
+ TECAMEvent ecamevent(KUidECamEventSettingsStabilizationAlgorithmComplexity, eventError);
+
+ iOwner.iECamEvent = ecamevent;
+ iOwner.iHandleEventAsync.CallBack();
+ }
+
+CCamera::CCameraAdvancedSettings::TWBUnits CTestCamAdvSet::SupportedWBUnits() const
+ {
+ return KSupportedWBUnits;
+ }
+
+void CTestCamAdvSet::SetWBRgbValue(const TRgb& /*aValue*/)
+ {
+ TECAMEvent ecamevent(KUidECamEventCameraSettingsWBValue, KErrNotSupported);
+
+ iOwner.iECamEvent = ecamevent;
+ iOwner.iHandleEventAsync.CallBack();
+ }
+
+void CTestCamAdvSet::GetWBRgbValue(TRgb& aValue) const
+ {
+ aValue = KRgbWhite;
+ }
+
+void CTestCamAdvSet::GetWBSupportedColorTemperaturesL(RArray<TInt>& aWBColorTemperatures, TValueInfo& aInfo) const
+ {
+ aWBColorTemperatures.Reset();
+ aInfo = ENotActive;
+ }
+
+void CTestCamAdvSet::SetWBColorTemperature(TInt /*aColorTemperature*/)
+ {
+ TECAMEvent ecamevent(KUidECamEventCameraSettingsWBValue, KErrNotSupported);
+
+ iOwner.iECamEvent = ecamevent;
+ iOwner.iHandleEventAsync.CallBack();
+ }
+
+TInt CTestCamAdvSet::WBColorTemperature() const
+ {
+ return KErrNotSupported;
+ }
+
+TInt CTestCamAdvSet::ContinuousAutoFocusTimeout() const
+ {
+ return KErrNotSupported;
+ }
+
+TInt CTestCamAdvSet::IsFlashReady(TBool& aReady) const
+ {
+ aReady = KFlashReadyState;
+ return KErrNone;
+ }
+
+void CTestCamAdvSet::GetCurrentFocusModeStepsL(RArray<TInt>& aFocusModeSteps, TValueInfo& aInfo) const
+ {
+ aFocusModeSteps.Reset();
+ aInfo = ENotActive;
+ }
+
+void CTestCamAdvSet::SetReferenceScreen(CWsScreenDevice& /*aScreenDevice*/)
+ {
+ TECAMEvent ecamevent(KUidECamEventCameraSettingReferenceScreen, KErrNotSupported);
+
+ iOwner.iECamEvent = ecamevent;
+ iOwner.iHandleEventAsync.CallBack();
+ }
+
+void CTestCamAdvSet::GetPreCaptureWarningSupportedL(CCamera::CCameraAdvancedSettings::TCameraMode /*aCameraMode*/, TInt& aPreCaptureWarningSupported) const
+ {
+ aPreCaptureWarningSupported = KPreCaptureWarning;
+ }
+
+void CTestCamAdvSet::SubscribeToPreCaptureWarningL(TInt /*aPreCaptureWarning*/)
+ {
+ User::Leave(KErrNotSupported);
+ }
+
+void CTestCamAdvSet::UnSubscribePreCaptureWarningL()
+ {
+ User::Leave(KErrNotSupported);
+ }
+
+void CTestCamAdvSet::GetPreCaptureWarningL(TInt& /*aPreCaptureWarning*/) const
+ {
+ User::Leave(KErrNotSupported);
+ }
+
+void CTestCamAdvSet::GetSupportedAFAssistantLightL(TInt& aSupportedAFAssistantLight) const
+ {
+ aSupportedAFAssistantLight = KAFAssisstantLight;
+ }
+
+void CTestCamAdvSet::GetAFAssistantLightL(CCamera::CCameraAdvancedSettings::TAFAssistantLight& /*aAFAssistantLight*/) const
+ {
+ User::Leave(KErrNotSupported);
+ }
+
+void CTestCamAdvSet::SetAFAssistantLight(CCamera::CCameraAdvancedSettings::TAFAssistantLight aAFAssistantLight)
+ {
+ TInt eventError = KErrNotSupported;
+
+ if(aAFAssistantLight == KAFAssisstantLight)
+ {
+ eventError = KErrAlreadyExists;
+ }
+
+ TECAMEvent ecamevent(KUidECamEventCameraSettingAFAssistantLight, eventError);
+
+ iOwner.iECamEvent = ecamevent;
+ iOwner.iHandleEventAsync.CallBack();
+ }
+
+/**********************************************************************************************************/
+/* CTestCamPresets */
+/**********************************************************************************************************/
+
+CTestCamPresets::CTestCamPresets(CTestCamera& aOwner): iOwner(aOwner),iCurrentPreset(KNullUid)
+ {}
+
+CTestCamPresets::~CTestCamPresets()
+ {
+ iSupportedPresets.Close();
+ iFactoryPresetAffectSettings.Close();
+
+ CDataGlobal* globalData = static_cast <CDataGlobal*> (Dll::Tls());
+ if(globalData != NULL)
+ {
+ if(!globalData->iTestCamAdvSet && !globalData->iTestCamSnapshot && !globalData->iTestCamImgProc)
+ {
+ delete globalData;
+ Dll::FreeTls();
+ }
+ else
+ {
+ globalData->iTestCamPresets = NULL;
+ Dll::SetTls(globalData);
+ }
+ }
+ }
+
+CTestCamPresets* CTestCamPresets::NewL(CTestCamera& aOwner)
+ {
+ CDataGlobal* globalData = static_cast <CDataGlobal*> (Dll::Tls());
+
+ if(globalData == NULL)
+ {
+ globalData = new (ELeave) CDataGlobal;
+ CleanupStack::PushL(globalData);
+ globalData->iPresetsReferenceCount = 0;
+ globalData->iTestCamPresets = new (ELeave) CTestCamPresets(aOwner);
+ globalData->iTestCamPresets->ConstructL();
+ globalData->iTestCamPresets->iRefCount = 1;
+ User::LeaveIfError(Dll::SetTls(globalData));
+ CleanupStack::Pop(globalData);
+ return globalData->iTestCamPresets;
+ }
+ else
+ {
+ if(globalData->iTestCamPresets == NULL)
+ {
+ globalData->iPresetsReferenceCount = 0;
+ globalData->iTestCamPresets = new (ELeave) CTestCamPresets(aOwner);
+ CleanupStack::PushL(globalData->iTestCamPresets);
+ globalData->iTestCamPresets->ConstructL();
+ globalData->iTestCamPresets->iRefCount = 1;
+ User::LeaveIfError(Dll::SetTls(globalData));
+ CleanupStack::Pop(globalData->iTestCamPresets);
+ return globalData->iTestCamPresets;
+ }
+
+ CTestCamPresets* self = globalData->iTestCamPresets;
+
+ globalData->iPresetsReferenceCount++;
+ self->iRefCount = globalData->iPresetsReferenceCount + 1;
+ if (globalData->iPresetsReferenceCount == KNumOfPresetExtensions-1 )
+ {
+ globalData->iTestCamPresets = NULL;
+ if(!globalData->iTestCamAdvSet && !globalData->iTestCamSnapshot && !globalData->iTestCamImgProc)
+ {
+ delete globalData;
+ Dll::FreeTls();
+ }
+ else
+ {
+ User::LeaveIfError(Dll::SetTls(globalData));
+ }
+ }
+ else
+ {
+ User::LeaveIfError(Dll::SetTls(globalData));
+ }
+ return self;
+ }
+ }
+
+void CTestCamPresets::Release()
+ {
+ iRefCount--;
+ if(iRefCount == 0)
+ {
+ delete this;
+ }
+ }
+
+void CTestCamPresets::ConstructL()
+ {
+ iSupportedPresets.Reset();
+ iSupportedPresets.AppendL(KUidECamPresetFactoryDefault);
+
+ iFactoryPresetAffectSettings.Reset();
+ iFactoryPresetAffectSettings.AppendL(KUidECamEventCameraSettingDriveMode);
+ iFactoryPresetAffectSettings.AppendL(KUidECamEventBurstImages);
+ }
+
+void CTestCamPresets::GetSupportedPresetsL(RArray<TUid>& aPresets) const
+ {
+ aPresets.Reset();
+ for (TInt index=0; index < iSupportedPresets.Count(); index++)
+ {
+ User::LeaveIfError(aPresets.Append(iSupportedPresets[index]));
+ }
+ }
+
+void CTestCamPresets::SetPreset(TUid aPreset)
+ {
+ TInt eventError = iOwner.CheckReserveAndPower();
+ if(eventError == KErrNone)
+ {
+ if(aPreset == iSupportedPresets[0])
+ {
+ //ResetBrightness, Contrast, Drivemode, No. of burst mode images
+ iOwner.iBrightness = 0;
+ iOwner.iContrast = 0;
+ iOwner.iImgProcBrightness = 0;
+ iOwner.iImgProcContrast = 0;
+ iOwner.iDriveMode = KDefaultDriveMode;
+ iOwner.iBurstImages = KBurstImages;
+ }
+ else
+ {
+ eventError = KErrNotSupported;
+ }
+ }
+
+ TECAMEvent ecamevent(aPreset, eventError);
+
+ iOwner.iECamEvent = ecamevent;
+ iOwner.iHandleEventAsync.CallBack();
+ }
+
+TUid CTestCamPresets::Preset() const
+ {
+ return iCurrentPreset;
+ }
+
+void CTestCamPresets::GetAffectedSettingsL(RArray<TUid>& aSettings) const
+ {
+ aSettings.Reset();
+
+ if(iCurrentPreset == iSupportedPresets[0])
+ {
+ for (TInt index=0; index < iFactoryPresetAffectSettings.Count(); index++)
+ {
+ User::LeaveIfError(aSettings.Append(iFactoryPresetAffectSettings[index]));
+ }
+ }
+ }
+
+void CTestCamPresets::GetAssociatedSettingsL(TUid aPreset, RArray<TUid>& aSettings) const
+ {
+ switch(aPreset.iUid)
+ {
+ case KUidECamPresetFactoryDefaultUidValue:
+ {
+ aSettings.Reset();
+ for (TInt index=0; index < iFactoryPresetAffectSettings.Count(); index++)
+ {
+ User::LeaveIfError(aSettings.Append(iFactoryPresetAffectSettings[index]));
+ }
+ break;
+ }
+
+ //fall through
+ case KUidECamPresetOutdoorUidValue:
+ case KUidECamPresetOutdoorSportUidValue:
+ case KUidECamPresetSnowUidValue:
+ case KUidECamPresetBeachUidValue:
+ case KUidECamPresetNightPortraitUidValue:
+ case KUidECamPresetNightFireworksUidValue:
+ case KUidECamPresetFogUidValue:
+ case KUidECamPresetIndoorUidValue:
+ case KUidECamPresetIndoorSportUidValue:
+ {
+ User::Leave(KErrNotSupported);
+ }
+ //fall through
+ case KUidECamPresetNightPartyIndoorUidValue:
+ case KUidECamPresetNightCloseUpUidValue:
+ case KUidECamPresetNightMacroUidValue:
+ case KUidECamPresetTextDocumentUidValue:
+ case KUidECamPresetBarcodeUidValue:
+ case KUidECamPresetAutoUidValue:
+ case KUidECamPresetPortraitUidValue:
+ case KUidECamPresetLandscapeUidValue:
+ case KUidECamPresetAmbienceMoodUidValue:
+ {
+ if(iOwner.CameraVersion() == KCameraDefaultVersion)
+ {
+ User::Leave(KErrArgument);
+ }
+ else
+ {
+ User::Leave(KErrNotSupported);
+ }
+ }
+
+ default:
+ User::Leave(KErrArgument);
+
+ }
+ }