1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/mm/mmplugins/cameraplugins/source/testcamera/test_advanced_settings.cpp Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,1602 @@
1.4 +// Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).
1.5 +// All rights reserved.
1.6 +// This component and the accompanying materials are made available
1.7 +// under the terms of "Eclipse Public License v1.0"
1.8 +// which accompanies this distribution, and is available
1.9 +// at the URL "http://www.eclipse.org/legal/epl-v10.html".
1.10 +//
1.11 +// Initial Contributors:
1.12 +// Nokia Corporation - initial contribution.
1.13 +//
1.14 +// Contributors:
1.15 +//
1.16 +// Description:
1.17 +// testadvancedsettings.cpp
1.18 +//
1.19 +//
1.20 +
1.21 +#include "test_advanced_settings.h"
1.22 +#include <ecamerrors.h>
1.23 +#include "ecamversion.h"
1.24 +
1.25 +CTestCamAdvSet::CTestCamAdvSet(CTestCamera& aOwner): iOwner(aOwner)
1.26 + {
1.27 + Init();
1.28 + }
1.29 +
1.30 +CTestCamAdvSet::~CTestCamAdvSet()
1.31 + {
1.32 + iSupportedISORates.Close();
1.33 + iSupportedApertures.Close();
1.34 + iSupportedShutterSpeeds.Close();
1.35 +
1.36 + CDataGlobal* globalData = static_cast <CDataGlobal*> (Dll::Tls());
1.37 + if(globalData != NULL)
1.38 + {
1.39 + if(!globalData->iTestCamPresets && !globalData->iTestCamSnapshot && !globalData->iTestCamImgProc)
1.40 + {
1.41 + delete globalData;
1.42 + Dll::FreeTls();
1.43 + }
1.44 + else
1.45 + {
1.46 + globalData->iTestCamAdvSet = NULL;
1.47 + Dll::SetTls(globalData);
1.48 + }
1.49 + }
1.50 + }
1.51 +
1.52 +CTestCamAdvSet* CTestCamAdvSet::NewL(CTestCamera& aOwner)
1.53 + {
1.54 + CDataGlobal* globalData = static_cast <CDataGlobal*> (Dll::Tls());
1.55 +
1.56 + if(globalData == NULL)
1.57 + {
1.58 + globalData = new (ELeave) CDataGlobal;
1.59 + CleanupStack::PushL(globalData);
1.60 + globalData->iAdvSetReferenceCount = 0;
1.61 + globalData->iTestCamAdvSet = new (ELeave) CTestCamAdvSet(aOwner);
1.62 + CleanupStack::PushL(globalData->iTestCamAdvSet);
1.63 + globalData->iTestCamAdvSet->ConstructL();
1.64 + globalData->iTestCamAdvSet->iRefCount = 1;
1.65 + User::LeaveIfError(Dll::SetTls(globalData));
1.66 + CleanupStack::Pop(globalData->iTestCamAdvSet);
1.67 + CleanupStack::Pop(globalData);
1.68 + return globalData->iTestCamAdvSet;
1.69 + }
1.70 + else
1.71 + {
1.72 + if(globalData->iTestCamAdvSet == NULL)
1.73 + {
1.74 + globalData->iAdvSetReferenceCount = 0;
1.75 + globalData->iTestCamAdvSet = new (ELeave) CTestCamAdvSet(aOwner);
1.76 + CleanupStack::PushL(globalData->iTestCamAdvSet);
1.77 + globalData->iTestCamAdvSet->ConstructL();
1.78 + globalData->iTestCamAdvSet->iRefCount = 1;
1.79 + User::LeaveIfError(Dll::SetTls(globalData));
1.80 + CleanupStack::Pop(globalData->iTestCamAdvSet);
1.81 + return globalData->iTestCamAdvSet;
1.82 + }
1.83 +
1.84 + CTestCamAdvSet* self = globalData->iTestCamAdvSet;
1.85 +
1.86 + globalData->iAdvSetReferenceCount++;
1.87 + self->iRefCount = globalData->iAdvSetReferenceCount + 1;
1.88 + if (globalData->iAdvSetReferenceCount == KNumOfAdvSetExtensions-1 )
1.89 + {
1.90 + globalData->iTestCamAdvSet = NULL;
1.91 + if(!globalData->iTestCamPresets && !globalData->iTestCamSnapshot && !globalData->iTestCamImgProc)
1.92 + {
1.93 + delete globalData;
1.94 + Dll::FreeTls();
1.95 + }
1.96 + else
1.97 + {
1.98 + User::LeaveIfError(Dll::SetTls(globalData));
1.99 + }
1.100 + }
1.101 + else
1.102 + {
1.103 + User::LeaveIfError(Dll::SetTls(globalData));
1.104 + }
1.105 + return self;
1.106 + }
1.107 + }
1.108 +
1.109 +void CTestCamAdvSet::Release()
1.110 + {
1.111 + iRefCount--;
1.112 + if(iRefCount == 0)
1.113 + {
1.114 + iOwner.iAdvSettingsImpl = NULL;
1.115 + delete this;
1.116 + }
1.117 + }
1.118 +
1.119 +void CTestCamAdvSet::Init()
1.120 + {
1.121 + for(TUint i=0; i< KNumAvailableCameras; i++)
1.122 + {
1.123 + iCameraTypes[i] = CCamera::CCameraAdvancedSettings::ECameraPluggable;
1.124 + }
1.125 +
1.126 + iFocusDistance = KDefaultFocusDistance;
1.127 + iIsoRate = KDefaultIsoRate;
1.128 + iISORateType = CCamera::CCameraAdvancedSettings::EISOManual;
1.129 + iAperture = KDefaultAperture;
1.130 + iShutterSpeed = KDefaultShutterSpeed;
1.131 + }
1.132 +
1.133 +void CTestCamAdvSet::ConstructL()
1.134 + {
1.135 + iSupportedISORates.Reset();
1.136 + iSupportedISORates.AppendL(KDefaultIsoRate);
1.137 +
1.138 + iSupportedApertures.Reset();
1.139 + iSupportedApertures.AppendL(KDefaultAperture);
1.140 +
1.141 + iSupportedShutterSpeeds.Reset();
1.142 + iSupportedShutterSpeeds.AppendL(KDefaultShutterSpeed);
1.143 + }
1.144 +
1.145 +CCamera::CCameraAdvancedSettings::TCameraType CTestCamAdvSet::CameraType() const
1.146 + {
1.147 + return CCamera::CCameraAdvancedSettings::ECameraPluggable;
1.148 + }
1.149 +
1.150 +CCamera::CCameraAdvancedSettings::TCameraType CTestCamAdvSet::CameraType(TInt aCameraIndex) const
1.151 + {
1.152 + if (aCameraIndex >= KNumAvailableCameras || aCameraIndex < 0)
1.153 + {
1.154 + return CCamera::CCameraAdvancedSettings::ECameraUnknown;
1.155 + }
1.156 + else
1.157 + {
1.158 + return iCameraTypes[aCameraIndex];
1.159 + }
1.160 + }
1.161 +
1.162 +TBool CTestCamAdvSet::IsCameraPresent() const
1.163 + {
1.164 + return ETrue;
1.165 + }
1.166 +
1.167 +TBool CTestCamAdvSet::IsCameraPresent(TInt aCameraIndex) const
1.168 + {
1.169 + if (aCameraIndex >= KNumAvailableCameras || aCameraIndex < 0)
1.170 + {
1.171 + return EFalse;
1.172 + }
1.173 + else
1.174 + {
1.175 + return ETrue;
1.176 + }
1.177 + }
1.178 +
1.179 +TInt CTestCamAdvSet::CameraIndex() const
1.180 + {
1.181 + return iOwner.iCameraIndex;
1.182 + }
1.183 +
1.184 +TInt CTestCamAdvSet::SupportedStabilizationModes() const
1.185 + {
1.186 + return KFeatureNotSupported;
1.187 + }
1.188 +
1.189 +CCamera::CCameraAdvancedSettings::TStabilizationMode CTestCamAdvSet::StabilizationMode() const
1.190 + {
1.191 + return CCamera::CCameraAdvancedSettings::EStabilizationModeOff;
1.192 + }
1.193 +
1.194 +void CTestCamAdvSet::SetStabilizationMode(CCamera::CCameraAdvancedSettings::TStabilizationMode aStabilizationMode)
1.195 + {
1.196 + TInt eventError = KErrNotSupported;
1.197 + if(aStabilizationMode == CCamera::CCameraAdvancedSettings::EStabilizationModeOff)
1.198 + {
1.199 + eventError = KErrAlreadyExists;
1.200 + }
1.201 +
1.202 + TECAMEvent ecamevent(KUidECamEventCameraSettingStabilizationMode, eventError);
1.203 +
1.204 + iOwner.iECamEvent = ecamevent;
1.205 + iOwner.iHandleEventAsync.CallBack();
1.206 + }
1.207 +
1.208 +TInt CTestCamAdvSet::SupportedFocusModes() const
1.209 + {
1.210 + return KFeatureNotSupported;
1.211 + }
1.212 +
1.213 +CCamera::CCameraAdvancedSettings::TFocusMode CTestCamAdvSet::FocusMode() const
1.214 + {
1.215 + return CCamera::CCameraAdvancedSettings::EFocusModeAuto;
1.216 + }
1.217 +
1.218 +void CTestCamAdvSet::SetFocusMode(CCamera::CCameraAdvancedSettings::TFocusMode aFocusMode)
1.219 + {
1.220 + TInt eventError = KErrNotSupported;
1.221 + if(aFocusMode == CCamera::CCameraAdvancedSettings::EFocusModeAuto)
1.222 + {
1.223 + eventError = KErrAlreadyExists;
1.224 + }
1.225 +
1.226 + TECAMEvent ecamevent(KUidECamEventCameraSettingFocusMode, eventError);
1.227 +
1.228 + iOwner.iECamEvent = ecamevent;
1.229 + iOwner.iHandleEventAsync.CallBack();
1.230 + }
1.231 +
1.232 +TInt CTestCamAdvSet::SupportedFocusRanges() const
1.233 + {
1.234 + return KFeatureNotSupported;
1.235 + }
1.236 +
1.237 +CCamera::CCameraAdvancedSettings::TFocusRange CTestCamAdvSet::FocusRange() const
1.238 + {
1.239 + return CCamera::CCameraAdvancedSettings::EFocusRangeAuto;
1.240 + }
1.241 +
1.242 +void CTestCamAdvSet::SetFocusRange(CCamera::CCameraAdvancedSettings::TFocusRange aFocusRange)
1.243 + {
1.244 + TInt eventError = KErrNotSupported;
1.245 + if(aFocusRange == CCamera::CCameraAdvancedSettings::EFocusRangeAuto)
1.246 + {
1.247 + eventError = KErrAlreadyExists;
1.248 + }
1.249 +
1.250 + TECAMEvent ecamevent1(KUidECamEventCameraSettingFocusRange2, eventError);
1.251 + TECAMEvent ecamevent2(KUidECamEventCameraSettingFocusRange, eventError);
1.252 +
1.253 + iOwner.iECamEvent = ecamevent1;
1.254 + iOwner.iHandleEventAsync.CallBack();
1.255 +
1.256 + iOwner.iECamEvent = ecamevent2;
1.257 + iOwner.iHandleEventAsync.CallBack();
1.258 + }
1.259 +
1.260 +TInt CTestCamAdvSet::SupportedAutoFocusTypes() const
1.261 + {
1.262 + return KFeatureNotSupported;
1.263 + }
1.264 +
1.265 +CCamera::CCameraAdvancedSettings::TAutoFocusType CTestCamAdvSet::AutoFocusType() const
1.266 + {
1.267 + return CCamera::CCameraAdvancedSettings::EAutoFocusTypeOff;
1.268 + }
1.269 +
1.270 +void CTestCamAdvSet::SetAutoFocusType(CCamera::CCameraAdvancedSettings::TAutoFocusType aAutoFocusType)
1.271 + {
1.272 + TInt eventError = KErrNotSupported;
1.273 + if(aAutoFocusType == CCamera::CCameraAdvancedSettings::EAutoFocusTypeOff)
1.274 + {
1.275 + eventError = KErrAlreadyExists;
1.276 + }
1.277 +
1.278 + TECAMEvent ecamevent1(KUidECamEventCameraSettingAutoFocusType2, eventError);
1.279 + TECAMEvent ecamevent2(KUidECamEventCameraSettingAutoFocusType, eventError);
1.280 +
1.281 + iOwner.iECamEvent = ecamevent1;
1.282 + iOwner.iHandleEventAsync.CallBack();
1.283 +
1.284 + iOwner.iECamEvent = ecamevent2;
1.285 + iOwner.iHandleEventAsync.CallBack();
1.286 + }
1.287 +
1.288 +TInt CTestCamAdvSet::SupportedAutoFocusAreas() const
1.289 + {
1.290 + return KFeatureNotSupported;
1.291 + }
1.292 +
1.293 +CCamera::CCameraAdvancedSettings::TAutoFocusArea CTestCamAdvSet::AutoFocusArea() const
1.294 + {
1.295 + return CCamera::CCameraAdvancedSettings::EAutoFocusTypeAuto;
1.296 + }
1.297 +
1.298 +void CTestCamAdvSet::SetAutoFocusArea(CCamera::CCameraAdvancedSettings::TAutoFocusArea aAutoFocusArea)
1.299 + {
1.300 + TInt eventError = KErrNotSupported;
1.301 + if(aAutoFocusArea == CCamera::CCameraAdvancedSettings::EAutoFocusTypeAuto)
1.302 + {
1.303 + eventError = KErrAlreadyExists;
1.304 + }
1.305 +
1.306 + TECAMEvent ecamevent(KUidECamEventCameraSettingAutoFocusArea, eventError);
1.307 +
1.308 + iOwner.iECamEvent = ecamevent;
1.309 + iOwner.iHandleEventAsync.CallBack();
1.310 + }
1.311 +
1.312 +TInt CTestCamAdvSet::FocusDistance() const
1.313 + {
1.314 + return iFocusDistance;
1.315 + }
1.316 +
1.317 +void CTestCamAdvSet::SetFocusDistance(TInt aDistance)
1.318 + {
1.319 + TInt eventError = KErrNone;
1.320 + if(aDistance < 0)
1.321 + {
1.322 + eventError = KErrNotSupported;
1.323 + }
1.324 + else
1.325 + {
1.326 + iFocusDistance = aDistance;
1.327 + }
1.328 +
1.329 + TECAMEvent ecamevent(KUidECamEventCameraSettingFocusDistance, eventError);
1.330 +
1.331 + iOwner.iECamEvent = ecamevent;
1.332 + iOwner.iHandleEventAsync.CallBack();
1.333 + }
1.334 +
1.335 +TInt CTestCamAdvSet::GetMinFocalLength() const
1.336 + {
1.337 + return KErrNotSupported;
1.338 + }
1.339 +
1.340 +void CTestCamAdvSet::GetSupportedIsoRatesL(RArray<TInt>& aSupportedIsoRates) const
1.341 + {
1.342 + if(iSupportedISORates.Count() == 0)
1.343 + {
1.344 + User::Leave(KErrNotSupported);
1.345 + }
1.346 +
1.347 + for(TInt index=0; index < iSupportedISORates.Count(); index++)
1.348 + {
1.349 + aSupportedIsoRates.AppendL(iSupportedISORates[index]);
1.350 + }
1.351 + }
1.352 +
1.353 +TInt CTestCamAdvSet::IsoRate() const
1.354 + {
1.355 + return iIsoRate;
1.356 + }
1.357 +
1.358 +void CTestCamAdvSet::SetIsoRate(TInt aRate)
1.359 + {
1.360 + TInt eventError = KErrNone;
1.361 + if(iSupportedISORates.Find(aRate) == KErrNotFound)
1.362 + {
1.363 + eventError = KErrECamParameterNotInRange;
1.364 + }
1.365 + else
1.366 + {
1.367 + //set the ISO type to Manual
1.368 + iISORateType = CCamera::CCameraAdvancedSettings::EISOManual;
1.369 + iIsoRate = aRate;
1.370 + }
1.371 +
1.372 + TECAMEvent ecamevent(KUidECamEventCameraSettingIsoRate, eventError);
1.373 +
1.374 + iOwner.iECamEvent = ecamevent;
1.375 + iOwner.iHandleEventAsync.CallBack();
1.376 + }
1.377 +
1.378 +void CTestCamAdvSet::GetSupportedISORateTypeL(TInt& aSupportedISORateTypes) const
1.379 + {
1.380 + aSupportedISORateTypes = KSupportedISORateTypes;
1.381 + }
1.382 +
1.383 +void CTestCamAdvSet::SetISORate(CCamera::CCameraAdvancedSettings::TISORateType aISORateType, TInt aParam)
1.384 + {
1.385 + TInt eventError = KErrNone;
1.386 +
1.387 + if(!(aISORateType & KSupportedISORateTypes) || iSupportedISORates.Count() == 0)
1.388 + {
1.389 + eventError = KErrNotSupported;
1.390 + }
1.391 + else
1.392 + {
1.393 + switch(aISORateType)
1.394 + {
1.395 + case CCamera::CCameraAdvancedSettings::EISOManual:
1.396 + {
1.397 + if(iSupportedISORates.Find(aParam) == KErrNotFound)
1.398 + {
1.399 + eventError = KErrECamParameterNotInRange;
1.400 + }
1.401 + else
1.402 + {
1.403 + iISORateType = aISORateType;
1.404 + if(aParam == iIsoRate)
1.405 + {
1.406 + eventError = KErrAlreadyExists;
1.407 + }
1.408 + else
1.409 + {
1.410 + iIsoRate = aParam;
1.411 + }
1.412 + }
1.413 + break;
1.414 + }
1.415 + case CCamera::CCameraAdvancedSettings::EISOAutoUnPrioritised:
1.416 + {
1.417 + eventError = KErrNotSupported;
1.418 + break;
1.419 + }
1.420 + case CCamera::CCameraAdvancedSettings::EISOAutoISOPrioritised:
1.421 + {
1.422 + eventError = KErrNotSupported;
1.423 + break;
1.424 + }
1.425 + case CCamera::CCameraAdvancedSettings::EISOAutoShutterSpeedPrioritised:
1.426 + {
1.427 + eventError = KErrNotSupported;
1.428 + break;
1.429 + }
1.430 + case CCamera::CCameraAdvancedSettings::EISOAutoAperturePrioritised:
1.431 + {
1.432 + eventError = KErrNotSupported;
1.433 + break;
1.434 + }
1.435 + default:
1.436 + eventError = KErrNotSupported;
1.437 + }
1.438 + }
1.439 +
1.440 + TECAMEvent ecamevent(KUidECamEventCameraSettingIsoRateType, eventError);
1.441 +
1.442 + iOwner.iECamEvent = ecamevent;
1.443 + iOwner.iHandleEventAsync.CallBack();
1.444 + }
1.445 +
1.446 +void CTestCamAdvSet::GetISORateL(CCamera::CCameraAdvancedSettings::TISORateType& aISORateType, TInt& /*aParam*/, TInt& aISORate) const
1.447 + {
1.448 + //If camera has no ISO rate supported, then leave
1.449 + if(iSupportedISORates.Count() == 0)
1.450 + {
1.451 + User::Leave(KErrNotSupported);
1.452 + }
1.453 +
1.454 + aISORateType = iISORateType;
1.455 + aISORate = iIsoRate;
1.456 +// aParam is redundant for manual ISO.
1.457 + }
1.458 +
1.459 +void CTestCamAdvSet::GetAperturesL(RArray<TInt>& aFStops, TValueInfo& aInfo) const
1.460 + {
1.461 + if(iSupportedApertures.Count() == 0)
1.462 + {
1.463 + aFStops.Reset();
1.464 + aInfo = ENotActive;
1.465 + }
1.466 +
1.467 + for(TInt index=0; index < iSupportedApertures.Count(); index++)
1.468 + {
1.469 + aFStops.AppendL(iSupportedApertures[index]);
1.470 + }
1.471 +
1.472 + aInfo = EDiscreteSteps;
1.473 + }
1.474 +
1.475 +TInt CTestCamAdvSet::Aperture() const
1.476 + {
1.477 + return iAperture;
1.478 + }
1.479 +
1.480 +void CTestCamAdvSet::SetAperture(TInt aFStop)
1.481 + {
1.482 + TInt eventError = KErrNone;
1.483 + if(iSupportedApertures.Find(aFStop) == KErrNotFound)
1.484 + {
1.485 + eventError = KErrECamParameterNotInRange;
1.486 + }
1.487 + else
1.488 + {
1.489 + iAperture = aFStop;
1.490 + }
1.491 +
1.492 + TECAMEvent ecamevent(KUidECamEventCameraSettingAperture, eventError);
1.493 +
1.494 + iOwner.iECamEvent = ecamevent;
1.495 + iOwner.iHandleEventAsync.CallBack();
1.496 + }
1.497 +
1.498 +void CTestCamAdvSet::GetShutterSpeedsL(RArray<TInt>& aShutterSpeeds, TValueInfo& aInfo) const
1.499 + {
1.500 + if(iSupportedShutterSpeeds.Count() == 0)
1.501 + {
1.502 + aShutterSpeeds.Reset();
1.503 + aInfo = ENotActive;
1.504 + }
1.505 +
1.506 + for(TInt index=0; index < iSupportedShutterSpeeds.Count(); index++)
1.507 + {
1.508 + aShutterSpeeds.AppendL(iSupportedShutterSpeeds[index]);
1.509 + aInfo = EDiscreteSteps;
1.510 + }
1.511 + }
1.512 +
1.513 +TInt CTestCamAdvSet::ShutterSpeed() const
1.514 + {
1.515 + return iShutterSpeed;
1.516 + }
1.517 +
1.518 +void CTestCamAdvSet::SetShutterSpeed(TInt aShutterSpeed)
1.519 + {
1.520 + TInt eventError = KErrNone;
1.521 + if(iSupportedShutterSpeeds.Find(aShutterSpeed) == KErrNotFound)
1.522 + {
1.523 + eventError = KErrECamParameterNotInRange;
1.524 + }
1.525 + else
1.526 + {
1.527 + iShutterSpeed = aShutterSpeed;
1.528 + }
1.529 +
1.530 + TECAMEvent ecamevent(KUidECamEventCameraSettingShutterSpeed, eventError);
1.531 +
1.532 + iOwner.iECamEvent = ecamevent;
1.533 + iOwner.iHandleEventAsync.CallBack();
1.534 + }
1.535 +
1.536 +TInt CTestCamAdvSet::SupportedMeteringModes() const
1.537 + {
1.538 + return KFeatureNotSupported;
1.539 + }
1.540 +
1.541 +CCamera::CCameraAdvancedSettings::TMeteringMode CTestCamAdvSet::MeteringMode() const
1.542 + {
1.543 + return CCamera::CCameraAdvancedSettings::EMeteringModeAuto;
1.544 + }
1.545 +
1.546 +void CTestCamAdvSet::SetMeteringMode(CCamera::CCameraAdvancedSettings::TMeteringMode aMeteringMode)
1.547 + {
1.548 + TInt eventError = KErrNotSupported;
1.549 + if(aMeteringMode == CCamera::CCameraAdvancedSettings::EMeteringModeAuto)
1.550 + {
1.551 + eventError = KErrAlreadyExists;
1.552 + }
1.553 +
1.554 + TECAMEvent ecamevent(KUidECamEventCameraSettingMeteringMode, eventError);
1.555 +
1.556 + iOwner.iECamEvent = ecamevent;
1.557 + iOwner.iHandleEventAsync.CallBack();
1.558 + }
1.559 +
1.560 +TInt CTestCamAdvSet::SupportedDriveModes() const
1.561 + {
1.562 + return KSupportedDriveModes;
1.563 + }
1.564 +
1.565 +CCamera::CCameraAdvancedSettings::TDriveMode CTestCamAdvSet::DriveMode() const
1.566 + {
1.567 + return iOwner.iDriveMode;
1.568 + }
1.569 +
1.570 +void CTestCamAdvSet::SetDriveMode(CCamera::CCameraAdvancedSettings::TDriveMode aDriveMode)
1.571 + {
1.572 + TInt eventError = KErrNone;
1.573 + if(iOwner.iVideoCaptureActive || iOwner.iImageCaptureActive)
1.574 + {
1.575 + eventError = KErrNotReady;
1.576 + }
1.577 + else
1.578 + {
1.579 + if(!(aDriveMode & KSupportedDriveModes))
1.580 + {
1.581 + eventError = KErrNotSupported;
1.582 + }
1.583 + else
1.584 + {
1.585 + if(eventError == KErrNone)
1.586 + {
1.587 + iOwner.iDriveMode = aDriveMode;
1.588 + }
1.589 + }
1.590 + }
1.591 +
1.592 + TECAMEvent ecamevent(KUidECamEventCameraSettingDriveMode, eventError);
1.593 +
1.594 + iOwner.iECamEvent = ecamevent;
1.595 + iOwner.iHandleEventAsync.CallBack();
1.596 + }
1.597 +
1.598 +TInt CTestCamAdvSet::SupportedBracketModes() const
1.599 + {
1.600 + return KFeatureNotSupported;
1.601 + }
1.602 +
1.603 +CCamera::CCameraAdvancedSettings::TBracketMode CTestCamAdvSet::BracketMode() const
1.604 + {
1.605 + return CCamera::CCameraAdvancedSettings::EBracketModeOff;
1.606 + }
1.607 +
1.608 +void CTestCamAdvSet::SetBracketMode(CCamera::CCameraAdvancedSettings::TBracketMode aBracketMode)
1.609 + {
1.610 + TInt eventError = KErrNotSupported;
1.611 + if(aBracketMode == CCamera::CCameraAdvancedSettings::EBracketModeOff)
1.612 + {
1.613 + eventError = KErrAlreadyExists;
1.614 + }
1.615 +
1.616 + TECAMEvent ecamevent(KUidECamEventCameraSettingBracketMode, eventError);
1.617 +
1.618 + iOwner.iECamEvent = ecamevent;
1.619 + iOwner.iHandleEventAsync.CallBack();
1.620 + }
1.621 +
1.622 +TInt CTestCamAdvSet::SupportedBracketParameters() const
1.623 + {
1.624 + return KFeatureNotSupported;
1.625 + }
1.626 +
1.627 +CCamera::CCameraAdvancedSettings::TBracketParameter CTestCamAdvSet::BracketParameter() const
1.628 + {
1.629 + return CCamera::CCameraAdvancedSettings::EBracketParameterNone;
1.630 + }
1.631 +
1.632 +void CTestCamAdvSet::SetBracketParameter(CCamera::CCameraAdvancedSettings::TBracketParameter aBracketParameter)
1.633 + {
1.634 + TInt eventError = KErrNotSupported;
1.635 + if(aBracketParameter == CCamera::CCameraAdvancedSettings::EBracketParameterNone)
1.636 + {
1.637 + eventError = KErrAlreadyExists;
1.638 + }
1.639 +
1.640 + TECAMEvent ecamevent(KUidECamEventCameraSettingBracketParameter, eventError);
1.641 +
1.642 + iOwner.iECamEvent = ecamevent;
1.643 + iOwner.iHandleEventAsync.CallBack();
1.644 + }
1.645 +
1.646 +TInt CTestCamAdvSet::SupportedBracketSteps() const
1.647 + {
1.648 + return KFeatureNotSupported;
1.649 + }
1.650 +
1.651 +CCamera::CCameraAdvancedSettings::TBracketStep CTestCamAdvSet::BracketStep() const
1.652 + {
1.653 + return CCamera::CCameraAdvancedSettings::EBracketStepNonConfig;
1.654 + }
1.655 +
1.656 +void CTestCamAdvSet::SetBracketStep(CCamera::CCameraAdvancedSettings::TBracketStep aBracketStep)
1.657 + {
1.658 + TInt eventError = KErrNotSupported;
1.659 + if(aBracketStep == CCamera::CCameraAdvancedSettings::EBracketStepNonConfig)
1.660 + {
1.661 + eventError = KErrAlreadyExists;
1.662 + }
1.663 +
1.664 + TECAMEvent ecamevent(KUidECamEventCameraSettingBracketStep, eventError);
1.665 +
1.666 + iOwner.iECamEvent = ecamevent;
1.667 + iOwner.iHandleEventAsync.CallBack();
1.668 + }
1.669 +
1.670 +void CTestCamAdvSet::GetBracketMerge(TInt& aStartIndex, TInt& aFrames) const
1.671 + {
1.672 + aStartIndex = KFeatureNotSupported;
1.673 + aFrames = KFeatureNotSupported;
1.674 + }
1.675 +
1.676 +void CTestCamAdvSet::SetBracketMerge(TInt /*aStartIndex*/ , TInt /*aFrames*/)
1.677 + {
1.678 + TECAMEvent ecamevent(KUidECamEventBracketMerge, KErrNotSupported);
1.679 +
1.680 + iOwner.iECamEvent = ecamevent;
1.681 + iOwner.iHandleEventAsync.CallBack();
1.682 + }
1.683 +
1.684 +TInt CTestCamAdvSet::SupportedFlashModes() const
1.685 + {
1.686 + return KFeatureNotSupported;
1.687 + }
1.688 +
1.689 +CCamera::TFlash CTestCamAdvSet::FlashMode() const
1.690 + {
1.691 + return CCamera::EFlashNone;
1.692 + }
1.693 +
1.694 +void CTestCamAdvSet::SetFlashMode(CCamera::TFlash /*aMode*/)
1.695 + {
1.696 + TECAMEvent ecamevent(KUidECamEventCameraSettingFlashMode, KErrNotSupported);
1.697 +
1.698 + iOwner.iECamEvent = ecamevent;
1.699 + iOwner.iHandleEventAsync.CallBack();
1.700 + }
1.701 +
1.702 +TBool CTestCamAdvSet::RedEyeReduceOn() const
1.703 + {
1.704 + return KDefaultRedEyeReduce;
1.705 + }
1.706 +
1.707 +void CTestCamAdvSet::SetRedEyeReduceOn(TBool /*aState*/)
1.708 + {
1.709 + TECAMEvent ecamevent(KUidECamEventCameraSettingFlashRedEyeReduce, KErrNotSupported);
1.710 +
1.711 + iOwner.iECamEvent = ecamevent;
1.712 + iOwner.iHandleEventAsync.CallBack();
1.713 + }
1.714 +
1.715 +void CTestCamAdvSet::GetFlashCompensationStepsL(RArray<TInt>& aFlashCompensationSteps, TValueInfo& aInfo) const
1.716 + {
1.717 + aFlashCompensationSteps.Reset();
1.718 + aInfo = ENotActive;
1.719 + }
1.720 +
1.721 +TInt CTestCamAdvSet::FlashCompensationStep() const
1.722 + {
1.723 + return KFlashCompensationStep;
1.724 + }
1.725 +
1.726 +TInt CTestCamAdvSet::GetFlashCompensationStep(TInt& aFlashCompensationStep) const
1.727 + {
1.728 + aFlashCompensationStep = KFlashCompensationStep;
1.729 + return KErrNone;
1.730 + }
1.731 +
1.732 +void CTestCamAdvSet::GetFlashCompensationRangeInSteps(TInt& aNegativeCompensation, TInt& aPositiveCompensation) const
1.733 + {
1.734 + aNegativeCompensation = KFlashCompensationStep;
1.735 + aPositiveCompensation = KFlashCompensationStep;
1.736 + }
1.737 +
1.738 +void CTestCamAdvSet::SetFlashCompensationStep(TInt /*aFlashCompensationStep*/)
1.739 + {
1.740 + TECAMEvent ecamevent(KUidECamEventCameraSettingFlashCompensationStep, KErrNotSupported);
1.741 +
1.742 + iOwner.iECamEvent = ecamevent;
1.743 + iOwner.iHandleEventAsync.CallBack();
1.744 + }
1.745 +
1.746 +TInt CTestCamAdvSet::FlashCompensation() const
1.747 + {
1.748 + return KFlashCompensationStep;
1.749 + }
1.750 +
1.751 +TInt CTestCamAdvSet::GetFlashCompensation(TInt& aFlashCompensation) const
1.752 + {
1.753 + aFlashCompensation = KFlashCompensationStep;
1.754 + return KErrNone;
1.755 + }
1.756 +
1.757 +void CTestCamAdvSet::SetFlashCompensation(TInt /*aFlashCompensation*/)
1.758 + {
1.759 + TECAMEvent ecamevent(KUidECamEventCameraSettingFlashCompensation, KErrNotSupported);
1.760 +
1.761 + iOwner.iECamEvent = ecamevent;
1.762 + iOwner.iHandleEventAsync.CallBack();
1.763 + }
1.764 +
1.765 +TBool CTestCamAdvSet::IsExternalFlashPresent() const
1.766 + {
1.767 + return KExternalFlashPresentState;
1.768 + }
1.769 +
1.770 +void CTestCamAdvSet::GetManualFlashPowerLevelsL(RArray<TInt>& aManualFlashPowerLevels, TValueInfo& aInfo) const
1.771 + {
1.772 + aManualFlashPowerLevels.Reset();
1.773 + aInfo = ENotActive;
1.774 + }
1.775 +
1.776 +TInt CTestCamAdvSet::ManualFlashPowerLevel() const
1.777 + {
1.778 + return KErrNotSupported;
1.779 + }
1.780 +
1.781 +void CTestCamAdvSet::SetManualFlashPowerLevel(TInt /*aManualFlashPowerLevel*/)
1.782 + {
1.783 + TECAMEvent ecamevent(KUidECamEventCameraSettingFlashManualPower, KErrNotSupported);
1.784 +
1.785 + iOwner.iECamEvent = ecamevent;
1.786 + iOwner.iHandleEventAsync.CallBack();
1.787 + }
1.788 +
1.789 +TInt CTestCamAdvSet::SupportedExposureModes() const
1.790 + {
1.791 + return CCamera::EExposureAuto;
1.792 + }
1.793 +
1.794 +CCamera::TExposure CTestCamAdvSet::ExposureMode() const
1.795 + {
1.796 + return CCamera::EExposureAuto;
1.797 + }
1.798 +
1.799 +void CTestCamAdvSet::SetExposureMode(CCamera::TExposure aExposureMode)
1.800 + {
1.801 + TInt eventError = KErrNotSupported;
1.802 + if(aExposureMode == CCamera::EExposureAuto)
1.803 + {
1.804 + eventError = KErrAlreadyExists;
1.805 + }
1.806 +
1.807 + TECAMEvent ecamevent(KUidECamEventCameraSettingExposureMode, eventError);
1.808 +
1.809 + iOwner.iECamEvent = ecamevent;
1.810 + iOwner.iHandleEventAsync.CallBack();
1.811 + }
1.812 +
1.813 +void CTestCamAdvSet::GetExposureCompensationStepsL(RArray<TInt>& aExposureCompensationSteps, TValueInfo& aInfo) const
1.814 + {
1.815 + aExposureCompensationSteps.Reset();
1.816 + aInfo = ENotActive;
1.817 + }
1.818 +
1.819 +void CTestCamAdvSet::GetExposureCompensationRangeInSteps(TInt& aNegativeCompensation, TInt& aPositiveCompensation) const
1.820 + {
1.821 + aNegativeCompensation = KExposureCompensationStep;
1.822 + aPositiveCompensation = KExposureCompensationStep;
1.823 + }
1.824 +
1.825 +TInt CTestCamAdvSet::ExposureCompensationStep() const
1.826 + {
1.827 + return KExposureCompensationStep;
1.828 + }
1.829 +
1.830 +TInt CTestCamAdvSet::GetExposureCompensationStep(TInt& aExposureCompensationStep) const
1.831 + {
1.832 + aExposureCompensationStep = KExposureCompensationStep;
1.833 + return KErrNone;
1.834 + }
1.835 +
1.836 +void CTestCamAdvSet::SetExposureCompensationStep(TInt /*aExposureCompensationStep*/)
1.837 + {
1.838 + TECAMEvent ecamevent(KUidECamEventCameraSettingExposureCompensationStep, KErrNotSupported);
1.839 +
1.840 + iOwner.iECamEvent = ecamevent;
1.841 + iOwner.iHandleEventAsync.CallBack();
1.842 + }
1.843 +
1.844 +TInt CTestCamAdvSet::ExposureCompensation() const
1.845 + {
1.846 + return KExposureCompensationStep;
1.847 + }
1.848 +
1.849 +TInt CTestCamAdvSet::GetExposureCompensation(TInt& aExposureCompensation) const
1.850 + {
1.851 + aExposureCompensation = KExposureCompensationStep;
1.852 + return KErrNone;
1.853 + }
1.854 +
1.855 +void CTestCamAdvSet::SetExposureCompensation(TInt /*aExposureCompensation*/)
1.856 + {
1.857 + TECAMEvent ecamevent(KUidECamEventCameraSettingExposureCompensation, KErrNotSupported);
1.858 +
1.859 + iOwner.iECamEvent = ecamevent;
1.860 + iOwner.iHandleEventAsync.CallBack();
1.861 + }
1.862 +
1.863 +TInt CTestCamAdvSet::SupportedWhiteBalanceModes() const
1.864 + {
1.865 + return KFeatureNotSupported;
1.866 + }
1.867 +
1.868 +CCamera::TWhiteBalance CTestCamAdvSet::WhiteBalanceMode() const
1.869 + {
1.870 + return CCamera::EWBAuto;
1.871 + }
1.872 +
1.873 +void CTestCamAdvSet::SetWhiteBalanceMode(CCamera::TWhiteBalance aWhiteBalanceMode)
1.874 + {
1.875 + TInt eventError = KErrNotSupported;
1.876 + if(aWhiteBalanceMode == CCamera::EWBAuto)
1.877 + {
1.878 + eventError = KErrAlreadyExists;
1.879 + }
1.880 +
1.881 + TECAMEvent ecamevent(KUidECamEventCameraSettingWhiteBalanceMode, eventError);
1.882 +
1.883 + iOwner.iECamEvent = ecamevent;
1.884 + iOwner.iHandleEventAsync.CallBack();
1.885 + }
1.886 +
1.887 +TBool CTestCamAdvSet::ApertureExposureLockOn() const
1.888 + {
1.889 + return KApertureExposureLockOn;
1.890 + }
1.891 +
1.892 +void CTestCamAdvSet::SetApertureExposureLockOn(TBool /*aAELock*/)
1.893 + {
1.894 + TECAMEvent ecamevent(KUidECamEventAELock, KErrNotSupported);
1.895 +
1.896 + iOwner.iECamEvent = ecamevent;
1.897 + iOwner.iHandleEventAsync.CallBack();
1.898 + }
1.899 +
1.900 +TBool CTestCamAdvSet::ShootClickOn() const
1.901 + {
1.902 + return KShootClickOn;
1.903 + }
1.904 +
1.905 +void CTestCamAdvSet::SetShootClickOn(TBool /*aShootClickOn*/)
1.906 + {
1.907 + TECAMEvent ecamevent(KUidECamEventSoundClick, KErrNotSupported);
1.908 +
1.909 + iOwner.iECamEvent = ecamevent;
1.910 + iOwner.iHandleEventAsync.CallBack();
1.911 + }
1.912 +
1.913 +void CTestCamAdvSet::GetTimerIntervalsL(RArray<TInt>& aTimerIntervals, TValueInfo& aInfo) const
1.914 + {
1.915 + aTimerIntervals.Reset();
1.916 + aInfo = ENotActive;
1.917 + }
1.918 +
1.919 +TInt CTestCamAdvSet::TimerInterval() const
1.920 + {
1.921 + return KErrNotSupported;
1.922 + }
1.923 +
1.924 +void CTestCamAdvSet::SetTimerInterval(TInt /*aTimerInterval*/)
1.925 + {
1.926 + TECAMEvent ecamevent(KUidECamEventCameraSettingTimerInterval, KErrNotSupported);
1.927 +
1.928 + iOwner.iECamEvent = ecamevent;
1.929 + iOwner.iHandleEventAsync.CallBack();
1.930 + }
1.931 +
1.932 +void CTestCamAdvSet::GetTimeLapsePeriodRange(TTime& aTimeLapseMin, TTime& aTimeLapseMax) const
1.933 + {
1.934 + TTime timeLapse(KTimeLapse);
1.935 + aTimeLapseMin = aTimeLapseMax = timeLapse;
1.936 + }
1.937 +
1.938 +void CTestCamAdvSet::GetTimeLapse(TTime& aStart, TTime& aEnd, TTime& aInterval) const
1.939 + {
1.940 + TTime timeLapse(KTimeLapse);
1.941 + aStart = aEnd = aInterval = timeLapse;
1.942 + }
1.943 +
1.944 +void CTestCamAdvSet::SetTimeLapse(const TTime& /*aStart*/, const TTime& /*aEnd*/, const TTime& /*aInterval*/)
1.945 + {
1.946 + TECAMEvent ecamevent(KUidECamEventCameraSettingTimeLapse, KErrNotSupported);
1.947 +
1.948 + iOwner.iECamEvent = ecamevent;
1.949 + iOwner.iHandleEventAsync.CallBack();
1.950 + }
1.951 +
1.952 +CCamera::CCameraAdvancedSettings::TPictureOrientation CTestCamAdvSet::PictureOrientation() const
1.953 + {
1.954 + return CCamera::CCameraAdvancedSettings::EPictureOrientationUnknown;
1.955 + }
1.956 +
1.957 +void CTestCamAdvSet::SetPictureOrientation(CCamera::CCameraAdvancedSettings::TPictureOrientation aOrientation)
1.958 + {
1.959 + TInt eventError = KErrNotSupported;
1.960 +
1.961 + if(iOwner.iVideoCaptureActive || iOwner.iImageCaptureActive)
1.962 + {
1.963 + eventError = KErrNotReady;
1.964 + }
1.965 + else
1.966 + {
1.967 + if(aOrientation == CCamera::CCameraAdvancedSettings::EPictureOrientationUnknown)
1.968 + {
1.969 + eventError = KErrAlreadyExists;
1.970 + }
1.971 + }
1.972 +
1.973 + TECAMEvent ecamevent(KUidECamEventCameraSettingPictureOrientation, eventError);
1.974 +
1.975 + iOwner.iECamEvent = ecamevent;
1.976 + iOwner.iHandleEventAsync.CallBack();
1.977 + }
1.978 +
1.979 +TInt CTestCamAdvSet::SupportedPixelAspectRatios() const
1.980 + {
1.981 + return KSupportedPixelAspectRatio;
1.982 + }
1.983 +
1.984 +CCamera::CCameraAdvancedSettings::TPixelAspectRatio CTestCamAdvSet::PixelAspectRatio() const
1.985 + {
1.986 + return CCamera::CCameraAdvancedSettings::EPixelAspectUnknown;
1.987 + }
1.988 +
1.989 +void CTestCamAdvSet::SetPixelAspectRatio(CCamera::CCameraAdvancedSettings::TPixelAspectRatio aPixelAspectRatio)
1.990 + {
1.991 + TInt eventError = KErrNotSupported;
1.992 +
1.993 + if(aPixelAspectRatio == CCamera::CCameraAdvancedSettings::EPixelAspectUnknown)
1.994 + {
1.995 + eventError = KErrAlreadyExists;
1.996 + }
1.997 +
1.998 + TECAMEvent ecamevent(KUidECamEventPixelAspectRatio, eventError);
1.999 +
1.1000 + iOwner.iECamEvent = ecamevent;
1.1001 + iOwner.iHandleEventAsync.CallBack();
1.1002 + }
1.1003 +
1.1004 +TInt CTestCamAdvSet::SupportedYuvRanges() const
1.1005 + {
1.1006 + return KSupportedYuvRange;
1.1007 + }
1.1008 +
1.1009 +CCamera::CCameraAdvancedSettings::TYuvRange CTestCamAdvSet::YuvRange() const
1.1010 + {
1.1011 + return CCamera::CCameraAdvancedSettings::EYuvRangeUnknown;
1.1012 + }
1.1013 +
1.1014 +void CTestCamAdvSet::SetYuvRange(CCamera::CCameraAdvancedSettings::TYuvRange aYuvRange)
1.1015 + {
1.1016 + TInt eventError = KErrNotSupported;
1.1017 +
1.1018 + if(aYuvRange == CCamera::CCameraAdvancedSettings::EYuvRangeUnknown)
1.1019 + {
1.1020 + eventError = KErrAlreadyExists;
1.1021 + }
1.1022 +
1.1023 + TECAMEvent ecamevent(KUidECamEventYuvRange, eventError);
1.1024 +
1.1025 + iOwner.iECamEvent = ecamevent;
1.1026 + iOwner.iHandleEventAsync.CallBack();
1.1027 + }
1.1028 +
1.1029 +TInt CTestCamAdvSet::BurstImages() const
1.1030 + {
1.1031 + return iOwner.iBurstImages;
1.1032 + }
1.1033 +
1.1034 +void CTestCamAdvSet::SetBurstImages(TInt aImages)
1.1035 + {
1.1036 + TInt eventError = iOwner.CheckReserveAndPower();
1.1037 +
1.1038 + if(eventError == KErrNone)
1.1039 + {
1.1040 + if(aImages == iOwner.iBurstImages)
1.1041 + {
1.1042 + eventError = KErrAlreadyExists;
1.1043 + }
1.1044 + else
1.1045 + {
1.1046 + if(aImages<1)
1.1047 + {
1.1048 + eventError = KErrArgument;
1.1049 + }
1.1050 + }
1.1051 + }
1.1052 +
1.1053 + if(eventError != KErrNone)
1.1054 + {
1.1055 + TECAMEvent ecamevent(KUidECamEventBurstImages, eventError);
1.1056 +
1.1057 + iOwner.iECamEvent = ecamevent;
1.1058 + iOwner.iHandleEventAsync.CallBack();
1.1059 + return;
1.1060 + }
1.1061 +
1.1062 + if(aImages > KMaxBurstImages)
1.1063 + {
1.1064 + iOwner.iBurstImages = KMaxBurstImages;
1.1065 + }
1.1066 + else
1.1067 + {
1.1068 + iOwner.iBurstImages = aImages;
1.1069 + }
1.1070 +
1.1071 + TECAMEvent ecamevent(KUidECamEventBurstImages, eventError);
1.1072 +
1.1073 + iOwner.iECamEvent = ecamevent;
1.1074 + iOwner.iHandleEventAsync.CallBack();
1.1075 + }
1.1076 +
1.1077 +void CTestCamAdvSet::GetOpticalZoomStepsL(RArray<TInt>& aOpticalZoomSteps, TValueInfo& aInfo) const
1.1078 + {
1.1079 + aOpticalZoomSteps.Reset();
1.1080 + aOpticalZoomSteps.AppendL(KECamFineResolutionFactor);
1.1081 + aInfo = EDiscreteSteps;
1.1082 + }
1.1083 +
1.1084 +TInt CTestCamAdvSet::OpticalZoom() const
1.1085 + {
1.1086 + return KECamFineResolutionFactor;
1.1087 + }
1.1088 +
1.1089 +void CTestCamAdvSet::SetOpticalZoom(TInt aOpticalZoom)
1.1090 + {
1.1091 + TInt eventError = KErrNotSupported;
1.1092 +
1.1093 + if(aOpticalZoom == KECamFineResolutionFactor)
1.1094 + {
1.1095 + eventError = KErrAlreadyExists;
1.1096 + }
1.1097 +
1.1098 + TECAMEvent ecamevent(KUidECamEventCameraSettingOpticalZoom, eventError);
1.1099 +
1.1100 + iOwner.iECamEvent = ecamevent;
1.1101 + iOwner.iHandleEventAsync.CallBack();
1.1102 + }
1.1103 +
1.1104 +void CTestCamAdvSet::GetDigitalZoomStepsL(RArray<TInt>& aDigitalZoomSteps,
1.1105 + TValueInfo& aInfo) const
1.1106 + {
1.1107 + aDigitalZoomSteps.Reset();
1.1108 + aDigitalZoomSteps.AppendL(KECamFineResolutionFactor);
1.1109 + aInfo = EDiscreteSteps;
1.1110 + }
1.1111 +
1.1112 +void CTestCamAdvSet::GetDigitalZoomStepsForStillL(RArray<TInt>& aDigitalZoomSteps, TValueInfo& aInfo, TInt /*aSizeIndex*/,
1.1113 + CCamera::TFormat /*aFormat*/, TBool& /*aIsInfluencePossible*/) const
1.1114 + {
1.1115 + aDigitalZoomSteps.Reset();
1.1116 + aDigitalZoomSteps.AppendL(KECamFineResolutionFactor);
1.1117 + aInfo = EDiscreteSteps;
1.1118 + }
1.1119 +
1.1120 +void CTestCamAdvSet::GetDigitalZoomStepsForVideoL(RArray<TInt>& aDigitalZoomSteps, TValueInfo& aInfo, TInt /*aFrameRateIndex*/,
1.1121 + TInt /*aSizeIndex*/, CCamera::TFormat /*aFormat*/, TBool& /*aIsInfluencePossible*/, CCamera::TExposure /*aExposure*/) const
1.1122 + {
1.1123 + aDigitalZoomSteps.Reset();
1.1124 + aDigitalZoomSteps.AppendL(KECamFineResolutionFactor);
1.1125 + aInfo = EDiscreteSteps;
1.1126 + }
1.1127 +
1.1128 +TInt CTestCamAdvSet::DigitalZoom() const
1.1129 + {
1.1130 + return KECamFineResolutionFactor;
1.1131 + }
1.1132 +
1.1133 +void CTestCamAdvSet::SetDigitalZoom(TInt aDigitalZoom)
1.1134 + {
1.1135 + TInt eventError = KErrNotSupported;
1.1136 +
1.1137 + if(aDigitalZoom == KECamFineResolutionFactor)
1.1138 + {
1.1139 + eventError = KErrAlreadyExists;
1.1140 + }
1.1141 +
1.1142 + TECAMEvent ecamevent(KUidECamEventCameraSettingDigitalZoom, eventError);
1.1143 +
1.1144 + iOwner.iECamEvent = ecamevent;
1.1145 + iOwner.iHandleEventAsync.CallBack();
1.1146 + }
1.1147 +
1.1148 +TBool CTestCamAdvSet::ExposureLockOn() const
1.1149 + {
1.1150 + return KExposureLockOn;
1.1151 + }
1.1152 +
1.1153 +void CTestCamAdvSet::SetExposureLockOn(TBool aState)
1.1154 + {
1.1155 + TInt eventError = KErrNotSupported;
1.1156 +
1.1157 + if(aState == KExposureLockOn)
1.1158 + {
1.1159 + eventError = KErrAlreadyExists;
1.1160 + }
1.1161 +
1.1162 + TECAMEvent ecamevent(KUidECamEventCameraSettingExposureLock, eventError);
1.1163 +
1.1164 + iOwner.iECamEvent = ecamevent;
1.1165 + iOwner.iHandleEventAsync.CallBack();
1.1166 + }
1.1167 +
1.1168 +TBool CTestCamAdvSet::AutoFocusLockOn() const
1.1169 + {
1.1170 + return KAutoFocusLockOn;
1.1171 + }
1.1172 +
1.1173 +void CTestCamAdvSet::SetAutoFocusLockOn(TBool aState)
1.1174 + {
1.1175 + TInt eventError = KErrNotSupported;
1.1176 +
1.1177 + if(aState == KAutoFocusLockOn)
1.1178 + {
1.1179 + eventError = KErrAlreadyExists;
1.1180 + }
1.1181 +
1.1182 + TECAMEvent ecamevent(KUidECamEventCameraSettingAutoFocusLock, eventError);
1.1183 +
1.1184 + iOwner.iECamEvent = ecamevent;
1.1185 + iOwner.iHandleEventAsync.CallBack();
1.1186 + }
1.1187 +
1.1188 +void CTestCamAdvSet::GetSupportedSettingsL(RArray<TUid>& aSettings) const
1.1189 + {
1.1190 + aSettings.Reset();
1.1191 + User::Leave(KErrNotSupported);
1.1192 + }
1.1193 +
1.1194 +void CTestCamAdvSet::GetActiveSettingsL(RArray<TUid>& aActiveSettings) const
1.1195 + {
1.1196 + aActiveSettings.Reset();
1.1197 + User::Leave(KErrNotSupported);
1.1198 + }
1.1199 +
1.1200 +void CTestCamAdvSet::GetDisabledSettingsL(RArray<TUid>& aDisbledSettings) const
1.1201 + {
1.1202 + aDisbledSettings.Reset();
1.1203 + User::Leave(KErrNotSupported);
1.1204 + }
1.1205 +
1.1206 +void CTestCamAdvSet::SetAutomaticSizeSelectionChangeOn(TBool aSetOn)
1.1207 + {
1.1208 + TInt eventError = KErrNotSupported;
1.1209 +
1.1210 + if(aSetOn == KAutomaticSizeSelectionChangeOn)
1.1211 + {
1.1212 + eventError = KErrAlreadyExists;
1.1213 + }
1.1214 +
1.1215 + TECAMEvent ecamevent(KUidECamEventCameraSettingAutomaticSizeSelection, eventError);
1.1216 +
1.1217 + iOwner.iECamEvent = ecamevent;
1.1218 + iOwner.iHandleEventAsync.CallBack();
1.1219 + }
1.1220 +
1.1221 +TBool CTestCamAdvSet::AutomaticSizeSelectionChangeOn() const
1.1222 + {
1.1223 + return KAutomaticSizeSelectionChangeOn;
1.1224 + }
1.1225 +
1.1226 +void CTestCamAdvSet::GetSupportedContinuousAutoFocusTimeoutsL(RArray<TInt>& aTimeouts, TValueInfo& aInfo) const
1.1227 + {
1.1228 + aTimeouts.Reset();
1.1229 + aInfo = ENotActive;
1.1230 + }
1.1231 +
1.1232 +void CTestCamAdvSet::SetContinuousAutoFocusTimeout(TInt /*aTimeout*/)
1.1233 + {
1.1234 + TECAMEvent ecamevent(KUidECamEventCameraSettingsContinuousAutoFocusTimeout, KErrNotSupported);
1.1235 +
1.1236 + iOwner.iECamEvent = ecamevent;
1.1237 + iOwner.iHandleEventAsync.CallBack();
1.1238 + }
1.1239 +
1.1240 +void CTestCamAdvSet::SetStabilizationEffect(CCamera::CCameraAdvancedSettings::TStabilizationEffect aEffect)
1.1241 + {
1.1242 + TInt eventError = KErrNotSupported;
1.1243 +
1.1244 + if(aEffect == KStabilizationEffect)
1.1245 + {
1.1246 + eventError = KErrAlreadyExists;
1.1247 + }
1.1248 +
1.1249 + TECAMEvent ecamevent(KUidECamEventCameraSettingsStabilizationEffect, eventError);
1.1250 +
1.1251 + iOwner.iECamEvent = ecamevent;
1.1252 + iOwner.iHandleEventAsync.CallBack();
1.1253 + }
1.1254 +
1.1255 +CCamera::CCameraAdvancedSettings::TStabilizationEffect CTestCamAdvSet::StabilizationEffect() const
1.1256 + {
1.1257 + return KStabilizationEffect;
1.1258 + }
1.1259 +
1.1260 +TInt CTestCamAdvSet::SupportedStabilizationEffects() const
1.1261 + {
1.1262 + return KStabilizationEffect;
1.1263 + }
1.1264 +
1.1265 +TInt CTestCamAdvSet::SupportedStabilizationComplexityValues() const
1.1266 + {
1.1267 + return KStabilizationComplexity;
1.1268 + }
1.1269 +
1.1270 +CCamera::CCameraAdvancedSettings::TStabilizationAlgorithmComplexity CTestCamAdvSet::StabilizationComplexity() const
1.1271 + {
1.1272 + return KStabilizationComplexity;
1.1273 + }
1.1274 +
1.1275 +void CTestCamAdvSet::SetStabilizationComplexity(CCamera::CCameraAdvancedSettings::TStabilizationAlgorithmComplexity aComplexity)
1.1276 + {
1.1277 + TInt eventError = KErrNotSupported;
1.1278 +
1.1279 + if(aComplexity == KStabilizationComplexity)
1.1280 + {
1.1281 + eventError = KErrAlreadyExists;
1.1282 + }
1.1283 +
1.1284 + TECAMEvent ecamevent(KUidECamEventSettingsStabilizationAlgorithmComplexity, eventError);
1.1285 +
1.1286 + iOwner.iECamEvent = ecamevent;
1.1287 + iOwner.iHandleEventAsync.CallBack();
1.1288 + }
1.1289 +
1.1290 +CCamera::CCameraAdvancedSettings::TWBUnits CTestCamAdvSet::SupportedWBUnits() const
1.1291 + {
1.1292 + return KSupportedWBUnits;
1.1293 + }
1.1294 +
1.1295 +void CTestCamAdvSet::SetWBRgbValue(const TRgb& /*aValue*/)
1.1296 + {
1.1297 + TECAMEvent ecamevent(KUidECamEventCameraSettingsWBValue, KErrNotSupported);
1.1298 +
1.1299 + iOwner.iECamEvent = ecamevent;
1.1300 + iOwner.iHandleEventAsync.CallBack();
1.1301 + }
1.1302 +
1.1303 +void CTestCamAdvSet::GetWBRgbValue(TRgb& aValue) const
1.1304 + {
1.1305 + aValue = KRgbWhite;
1.1306 + }
1.1307 +
1.1308 +void CTestCamAdvSet::GetWBSupportedColorTemperaturesL(RArray<TInt>& aWBColorTemperatures, TValueInfo& aInfo) const
1.1309 + {
1.1310 + aWBColorTemperatures.Reset();
1.1311 + aInfo = ENotActive;
1.1312 + }
1.1313 +
1.1314 +void CTestCamAdvSet::SetWBColorTemperature(TInt /*aColorTemperature*/)
1.1315 + {
1.1316 + TECAMEvent ecamevent(KUidECamEventCameraSettingsWBValue, KErrNotSupported);
1.1317 +
1.1318 + iOwner.iECamEvent = ecamevent;
1.1319 + iOwner.iHandleEventAsync.CallBack();
1.1320 + }
1.1321 +
1.1322 +TInt CTestCamAdvSet::WBColorTemperature() const
1.1323 + {
1.1324 + return KErrNotSupported;
1.1325 + }
1.1326 +
1.1327 +TInt CTestCamAdvSet::ContinuousAutoFocusTimeout() const
1.1328 + {
1.1329 + return KErrNotSupported;
1.1330 + }
1.1331 +
1.1332 +TInt CTestCamAdvSet::IsFlashReady(TBool& aReady) const
1.1333 + {
1.1334 + aReady = KFlashReadyState;
1.1335 + return KErrNone;
1.1336 + }
1.1337 +
1.1338 +void CTestCamAdvSet::GetCurrentFocusModeStepsL(RArray<TInt>& aFocusModeSteps, TValueInfo& aInfo) const
1.1339 + {
1.1340 + aFocusModeSteps.Reset();
1.1341 + aInfo = ENotActive;
1.1342 + }
1.1343 +
1.1344 +void CTestCamAdvSet::SetReferenceScreen(CWsScreenDevice& /*aScreenDevice*/)
1.1345 + {
1.1346 + TECAMEvent ecamevent(KUidECamEventCameraSettingReferenceScreen, KErrNotSupported);
1.1347 +
1.1348 + iOwner.iECamEvent = ecamevent;
1.1349 + iOwner.iHandleEventAsync.CallBack();
1.1350 + }
1.1351 +
1.1352 +void CTestCamAdvSet::GetPreCaptureWarningSupportedL(CCamera::CCameraAdvancedSettings::TCameraMode /*aCameraMode*/, TInt& aPreCaptureWarningSupported) const
1.1353 + {
1.1354 + aPreCaptureWarningSupported = KPreCaptureWarning;
1.1355 + }
1.1356 +
1.1357 +void CTestCamAdvSet::SubscribeToPreCaptureWarningL(TInt /*aPreCaptureWarning*/)
1.1358 + {
1.1359 + User::Leave(KErrNotSupported);
1.1360 + }
1.1361 +
1.1362 +void CTestCamAdvSet::UnSubscribePreCaptureWarningL()
1.1363 + {
1.1364 + User::Leave(KErrNotSupported);
1.1365 + }
1.1366 +
1.1367 +void CTestCamAdvSet::GetPreCaptureWarningL(TInt& /*aPreCaptureWarning*/) const
1.1368 + {
1.1369 + User::Leave(KErrNotSupported);
1.1370 + }
1.1371 +
1.1372 +void CTestCamAdvSet::GetSupportedAFAssistantLightL(TInt& aSupportedAFAssistantLight) const
1.1373 + {
1.1374 + aSupportedAFAssistantLight = KAFAssisstantLight;
1.1375 + }
1.1376 +
1.1377 +void CTestCamAdvSet::GetAFAssistantLightL(CCamera::CCameraAdvancedSettings::TAFAssistantLight& /*aAFAssistantLight*/) const
1.1378 + {
1.1379 + User::Leave(KErrNotSupported);
1.1380 + }
1.1381 +
1.1382 +void CTestCamAdvSet::SetAFAssistantLight(CCamera::CCameraAdvancedSettings::TAFAssistantLight aAFAssistantLight)
1.1383 + {
1.1384 + TInt eventError = KErrNotSupported;
1.1385 +
1.1386 + if(aAFAssistantLight == KAFAssisstantLight)
1.1387 + {
1.1388 + eventError = KErrAlreadyExists;
1.1389 + }
1.1390 +
1.1391 + TECAMEvent ecamevent(KUidECamEventCameraSettingAFAssistantLight, eventError);
1.1392 +
1.1393 + iOwner.iECamEvent = ecamevent;
1.1394 + iOwner.iHandleEventAsync.CallBack();
1.1395 + }
1.1396 +
1.1397 +/**********************************************************************************************************/
1.1398 +/* CTestCamPresets */
1.1399 +/**********************************************************************************************************/
1.1400 +
1.1401 +CTestCamPresets::CTestCamPresets(CTestCamera& aOwner): iOwner(aOwner),iCurrentPreset(KNullUid)
1.1402 + {}
1.1403 +
1.1404 +CTestCamPresets::~CTestCamPresets()
1.1405 + {
1.1406 + iSupportedPresets.Close();
1.1407 + iFactoryPresetAffectSettings.Close();
1.1408 +
1.1409 + CDataGlobal* globalData = static_cast <CDataGlobal*> (Dll::Tls());
1.1410 + if(globalData != NULL)
1.1411 + {
1.1412 + if(!globalData->iTestCamAdvSet && !globalData->iTestCamSnapshot && !globalData->iTestCamImgProc)
1.1413 + {
1.1414 + delete globalData;
1.1415 + Dll::FreeTls();
1.1416 + }
1.1417 + else
1.1418 + {
1.1419 + globalData->iTestCamPresets = NULL;
1.1420 + Dll::SetTls(globalData);
1.1421 + }
1.1422 + }
1.1423 + }
1.1424 +
1.1425 +CTestCamPresets* CTestCamPresets::NewL(CTestCamera& aOwner)
1.1426 + {
1.1427 + CDataGlobal* globalData = static_cast <CDataGlobal*> (Dll::Tls());
1.1428 +
1.1429 + if(globalData == NULL)
1.1430 + {
1.1431 + globalData = new (ELeave) CDataGlobal;
1.1432 + CleanupStack::PushL(globalData);
1.1433 + globalData->iPresetsReferenceCount = 0;
1.1434 + globalData->iTestCamPresets = new (ELeave) CTestCamPresets(aOwner);
1.1435 + globalData->iTestCamPresets->ConstructL();
1.1436 + globalData->iTestCamPresets->iRefCount = 1;
1.1437 + User::LeaveIfError(Dll::SetTls(globalData));
1.1438 + CleanupStack::Pop(globalData);
1.1439 + return globalData->iTestCamPresets;
1.1440 + }
1.1441 + else
1.1442 + {
1.1443 + if(globalData->iTestCamPresets == NULL)
1.1444 + {
1.1445 + globalData->iPresetsReferenceCount = 0;
1.1446 + globalData->iTestCamPresets = new (ELeave) CTestCamPresets(aOwner);
1.1447 + CleanupStack::PushL(globalData->iTestCamPresets);
1.1448 + globalData->iTestCamPresets->ConstructL();
1.1449 + globalData->iTestCamPresets->iRefCount = 1;
1.1450 + User::LeaveIfError(Dll::SetTls(globalData));
1.1451 + CleanupStack::Pop(globalData->iTestCamPresets);
1.1452 + return globalData->iTestCamPresets;
1.1453 + }
1.1454 +
1.1455 + CTestCamPresets* self = globalData->iTestCamPresets;
1.1456 +
1.1457 + globalData->iPresetsReferenceCount++;
1.1458 + self->iRefCount = globalData->iPresetsReferenceCount + 1;
1.1459 + if (globalData->iPresetsReferenceCount == KNumOfPresetExtensions-1 )
1.1460 + {
1.1461 + globalData->iTestCamPresets = NULL;
1.1462 + if(!globalData->iTestCamAdvSet && !globalData->iTestCamSnapshot && !globalData->iTestCamImgProc)
1.1463 + {
1.1464 + delete globalData;
1.1465 + Dll::FreeTls();
1.1466 + }
1.1467 + else
1.1468 + {
1.1469 + User::LeaveIfError(Dll::SetTls(globalData));
1.1470 + }
1.1471 + }
1.1472 + else
1.1473 + {
1.1474 + User::LeaveIfError(Dll::SetTls(globalData));
1.1475 + }
1.1476 + return self;
1.1477 + }
1.1478 + }
1.1479 +
1.1480 +void CTestCamPresets::Release()
1.1481 + {
1.1482 + iRefCount--;
1.1483 + if(iRefCount == 0)
1.1484 + {
1.1485 + delete this;
1.1486 + }
1.1487 + }
1.1488 +
1.1489 +void CTestCamPresets::ConstructL()
1.1490 + {
1.1491 + iSupportedPresets.Reset();
1.1492 + iSupportedPresets.AppendL(KUidECamPresetFactoryDefault);
1.1493 +
1.1494 + iFactoryPresetAffectSettings.Reset();
1.1495 + iFactoryPresetAffectSettings.AppendL(KUidECamEventCameraSettingDriveMode);
1.1496 + iFactoryPresetAffectSettings.AppendL(KUidECamEventBurstImages);
1.1497 + }
1.1498 +
1.1499 +void CTestCamPresets::GetSupportedPresetsL(RArray<TUid>& aPresets) const
1.1500 + {
1.1501 + aPresets.Reset();
1.1502 + for (TInt index=0; index < iSupportedPresets.Count(); index++)
1.1503 + {
1.1504 + User::LeaveIfError(aPresets.Append(iSupportedPresets[index]));
1.1505 + }
1.1506 + }
1.1507 +
1.1508 +void CTestCamPresets::SetPreset(TUid aPreset)
1.1509 + {
1.1510 + TInt eventError = iOwner.CheckReserveAndPower();
1.1511 + if(eventError == KErrNone)
1.1512 + {
1.1513 + if(aPreset == iSupportedPresets[0])
1.1514 + {
1.1515 + //ResetBrightness, Contrast, Drivemode, No. of burst mode images
1.1516 + iOwner.iBrightness = 0;
1.1517 + iOwner.iContrast = 0;
1.1518 + iOwner.iImgProcBrightness = 0;
1.1519 + iOwner.iImgProcContrast = 0;
1.1520 + iOwner.iDriveMode = KDefaultDriveMode;
1.1521 + iOwner.iBurstImages = KBurstImages;
1.1522 + }
1.1523 + else
1.1524 + {
1.1525 + eventError = KErrNotSupported;
1.1526 + }
1.1527 + }
1.1528 +
1.1529 + TECAMEvent ecamevent(aPreset, eventError);
1.1530 +
1.1531 + iOwner.iECamEvent = ecamevent;
1.1532 + iOwner.iHandleEventAsync.CallBack();
1.1533 + }
1.1534 +
1.1535 +TUid CTestCamPresets::Preset() const
1.1536 + {
1.1537 + return iCurrentPreset;
1.1538 + }
1.1539 +
1.1540 +void CTestCamPresets::GetAffectedSettingsL(RArray<TUid>& aSettings) const
1.1541 + {
1.1542 + aSettings.Reset();
1.1543 +
1.1544 + if(iCurrentPreset == iSupportedPresets[0])
1.1545 + {
1.1546 + for (TInt index=0; index < iFactoryPresetAffectSettings.Count(); index++)
1.1547 + {
1.1548 + User::LeaveIfError(aSettings.Append(iFactoryPresetAffectSettings[index]));
1.1549 + }
1.1550 + }
1.1551 + }
1.1552 +
1.1553 +void CTestCamPresets::GetAssociatedSettingsL(TUid aPreset, RArray<TUid>& aSettings) const
1.1554 + {
1.1555 + switch(aPreset.iUid)
1.1556 + {
1.1557 + case KUidECamPresetFactoryDefaultUidValue:
1.1558 + {
1.1559 + aSettings.Reset();
1.1560 + for (TInt index=0; index < iFactoryPresetAffectSettings.Count(); index++)
1.1561 + {
1.1562 + User::LeaveIfError(aSettings.Append(iFactoryPresetAffectSettings[index]));
1.1563 + }
1.1564 + break;
1.1565 + }
1.1566 +
1.1567 + //fall through
1.1568 + case KUidECamPresetOutdoorUidValue:
1.1569 + case KUidECamPresetOutdoorSportUidValue:
1.1570 + case KUidECamPresetSnowUidValue:
1.1571 + case KUidECamPresetBeachUidValue:
1.1572 + case KUidECamPresetNightPortraitUidValue:
1.1573 + case KUidECamPresetNightFireworksUidValue:
1.1574 + case KUidECamPresetFogUidValue:
1.1575 + case KUidECamPresetIndoorUidValue:
1.1576 + case KUidECamPresetIndoorSportUidValue:
1.1577 + {
1.1578 + User::Leave(KErrNotSupported);
1.1579 + }
1.1580 + //fall through
1.1581 + case KUidECamPresetNightPartyIndoorUidValue:
1.1582 + case KUidECamPresetNightCloseUpUidValue:
1.1583 + case KUidECamPresetNightMacroUidValue:
1.1584 + case KUidECamPresetTextDocumentUidValue:
1.1585 + case KUidECamPresetBarcodeUidValue:
1.1586 + case KUidECamPresetAutoUidValue:
1.1587 + case KUidECamPresetPortraitUidValue:
1.1588 + case KUidECamPresetLandscapeUidValue:
1.1589 + case KUidECamPresetAmbienceMoodUidValue:
1.1590 + {
1.1591 + if(iOwner.CameraVersion() == KCameraDefaultVersion)
1.1592 + {
1.1593 + User::Leave(KErrArgument);
1.1594 + }
1.1595 + else
1.1596 + {
1.1597 + User::Leave(KErrNotSupported);
1.1598 + }
1.1599 + }
1.1600 +
1.1601 + default:
1.1602 + User::Leave(KErrArgument);
1.1603 +
1.1604 + }
1.1605 + }