diff -r 000000000000 -r bde4ae8d615e os/mm/imagingandcamerafws/cameraunittest/src/TSU_ECM_ADV/ECamEnhanceFuncTest.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/os/mm/imagingandcamerafws/cameraunittest/src/TSU_ECM_ADV/ECamEnhanceFuncTest.cpp Fri Jun 15 03:10:57 2012 +0200 @@ -0,0 +1,1760 @@ +// Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies). +// All rights reserved. +// This component and the accompanying materials are made available +// under the terms of "Eclipse Public License v1.0" +// which accompanies this distribution, and is available +// at the URL "http://www.eclipse.org/legal/epl-v10.html". +// +// Initial Contributors: +// Nokia Corporation - initial contribution. +// +// Contributors: +// +// Description: +// + +#include +#include +#include "ECamEnhanceFuncTest.h" +#include "ECamUnitTestPluginUids.hrh" +#include "ECamUnitTestPlugin.h" +#include +#include + +/*------------------------------------------------------ + Histogram : RECamHistTest + *------------------------------------------------------*/ +RECamHistTest* RECamHistTest::NewL(const TDesC& aTestStep) + { + RECamHistTest* self = new (ELeave) RECamHistTest(aTestStep); + return self; + } + +RECamHistTest::RECamHistTest(const TDesC& aTestStep) + { + iTestStepName.Copy(aTestStep); + } + +TVerdict RECamHistTest::DoTestStepL() + { + if(!iTestStepName.Compare(_L("MM-ECM-ADV-U-020-HP"))) + { + return DoTestStep_20L(); + } + else if(!iTestStepName.Compare(_L("MM-ECM-ADV-U-021-HP"))) + { + return DoTestStep_21L(); + } + else if(!iTestStepName.Compare(_L("MM-ECM-ADV-U-022-HP"))) + { + return DoTestStep_22L(); + } + return EInconclusive; + } + +TVerdict RECamHistTest::DoTestStep_20L() + { + TVerdict verdict = EFail; + INFO_PRINTF1(_L("Alloc test")); + TInt i; + TInt err; + for (i = 1 ; ; i++) + { + __MM_HEAP_MARK; + + if (i % 5 == 0) + { + INFO_PRINTF2(_L("Fail count = %d"), i); + } + + __UHEAP_SETFAIL(RHeap::EFailNext, i); + + TRAP(err, verdict = DoHistTestStepL()); + + TAny* testAlloc = User::Alloc(1); + TBool heapTestingComplete = (testAlloc == NULL) && (err==KErrNone); + User::Free(testAlloc); + + __UHEAP_RESET; + __MM_HEAP_MARKEND; + + if ((err != KErrNoMemory ) || heapTestingComplete) + { + INFO_PRINTF4(_L("err = %d, verdict = %d, Fail count = %d"), err, verdict, i); + INFO_PRINTF1(_L("Alloc testing completed successfully")); + verdict = EPass; + break; + } + } + return verdict; + } + +TVerdict RECamHistTest::DoHistTestStepL() + { + TVerdict result = EPass; + CCamera* camera = NULL; + + TInt error = KErrNone; + CCamera::CCameraHistogram* hist = NULL; + + // using observer 2 + MCameraObserver2* observer2 = NULL; + + __MM_HEAP_MARK; + INFO_PRINTF1(_L("Create camera using Camera::New2L() and MCameraObserver2")); + + TRAP(error, camera = CCamera::New2L(*observer2, 0,0)); + + if (error==KErrNone) + { + CleanupStack::PushL(camera); + INFO_PRINTF1(_L("KErrNone return from CCamera::New2L()")); + hist = static_cast (camera->CustomInterface(KECamHistogramUid)); + if (hist!= NULL) + { + CleanupStack::PushL(hist); + INFO_PRINTF1(_L("CCameraHistogram object was created")); + CleanupStack::PopAndDestroy(hist); + } + else + { + result = EFail; + User::Leave(KErrNoMemory); + } + CleanupStack::PopAndDestroy(camera); + } + else + { + INFO_PRINTF2(_L("Unexpected %d return from CCamera::New2L(): observer 2"), error); + result = EFail; + User::Leave(KErrNoMemory); + } + __MM_HEAP_MARKEND; + + // create a Hist object using New2L + __MM_HEAP_MARK; + INFO_PRINTF1(_L("Create camera using Camera::New2L() and MCameraObserver2")); + + TRAP(error, camera = CCamera::New2L(*observer2, 0,0)); + + if (error==KErrNone) + { + CleanupStack::PushL(camera); + INFO_PRINTF1(_L("KErrNone return from CCamera::New2L()")); + TRAP(error, hist = CCamera::CCameraHistogram::NewL(*camera)); + + if (error==KErrNone) + { + CleanupStack::PushL(hist); + INFO_PRINTF1(_L("CCameraHistogram object was created using NewL")); + CleanupStack::PopAndDestroy(hist); + } + else + { + INFO_PRINTF1(_L("CCameraHistogram object was not created using NewL")); + result = EFail; + User::Leave(KErrNoMemory); + } + CleanupStack::PopAndDestroy(camera); + } + else + { + INFO_PRINTF2(_L("Unexpected %d return from CCamera::New2L(): observer 2"), error); + result = EFail; + User::Leave(KErrNoMemory); + } + __MM_HEAP_MARKEND; + + return result; + } + +TVerdict RECamHistTest::DoTestStep_21L() + { + TVerdict result = EPass; + CCamera* camera = NULL; + + TInt error = KErrNone; + CCamera::CCameraHistogram* hist = NULL; + + // create a Hist object using New2L + __MM_HEAP_MARK; + MCameraObserver2* observer2 = NULL; + INFO_PRINTF1(_L("Create camera using Camera::New2L() and MCameraObserver2")); + + TRAP(error, camera = CCamera::New2L(*observer2, 0,0)); + + if (error==KErrNone) + { + CleanupStack::PushL(camera); + INFO_PRINTF1(_L("KErrNone return from CCamera::New2L()")); + TRAP(error, hist = CCamera::CCameraHistogram::NewL(*camera)); + + if (error==KErrNone) + { + INFO_PRINTF1(_L("CCameraHistogram object was created using NewL")); + } + else + { + INFO_PRINTF1(_L("CCameraHistogram object was not created using NewL")); + return EFail; + } + } + else + { + INFO_PRINTF2(_L("Unexpected %d return from CCamera::New2L(): observer 2"), error); + result = EFail; + } + + if (hist!= NULL) + { + CleanupStack::PushL(hist); + + // get the supported set of values + TUint32 suppformats = hist->SupportedHistograms(); + + // the array should not be empty + if (suppformats == 0) + { + result = EFail; + } + // Preapare DSA Based Histogram + TUint histhandle = 0; + TPoint orgPos(5,5); + TSize orgSize(90,50); + TRgb orgColor(100,100,100); + + TRAP(error, histhandle = hist->PrepareDSAHistogramL(CCamera::CCameraHistogram::ELuminance, orgPos, orgSize, orgColor)); + + if(error==KErrNone) + { + INFO_PRINTF1(_L("DSA Histogram Created")); + } + else + { + INFO_PRINTF2(_L("DSA Histogram Created- %d"), error); + return EFail; + } + + // set new value + TPoint curPos; + TSize curSize; + TRgb curColor; + TRAP(error, hist->GetDSAHistogramPropertiesL(histhandle, curPos, curSize, curColor)); + + if(error==KErrNone) + { + INFO_PRINTF1(_L("Get Histogram Properties")); + } + else + { + INFO_PRINTF2(_L("Get Histogram Properties- %d"), error); + return EFail; + } + + if(curPos != orgPos || curSize != orgSize || curColor != orgColor) + { + INFO_PRINTF1(_L("Properties dont match")); + return EFail; + } + + // new values for properties + orgPos = TPoint(10,10); + orgSize = TSize(80,40); + orgColor = TRgb(90,90,90); + + // Lets try update + TRAP(error, hist->UpdateDSAHistogramPropertiesL(histhandle, orgPos, orgSize, orgColor)); + if(error==KErrNone) + { + INFO_PRINTF1(_L("Update Histogram Proporties Successfull")); + } + else + { + INFO_PRINTF2(_L("Update Histogram Proporties- %d"), error); + return EFail; + } + + // Get and verify with new values + TRAP(error, hist->GetDSAHistogramPropertiesL(histhandle, curPos, curSize, curColor)); + + if(error==KErrNone) + { + INFO_PRINTF1(_L("Get Histogram Properties Successful")); + } + else + { + INFO_PRINTF2(_L("Get Histogram Properties- %d"), error); + return EFail; + } + + if(curPos != orgPos || curSize != orgSize || curColor != orgColor) + { + INFO_PRINTF1(_L("Properties dont match")); + return EFail; + } + + + TRAP(error, hist->DestroyHistogramL(histhandle)); + if(error==KErrNone) + { + INFO_PRINTF1(_L("Destroy Histogram Successful")); + } + else + { + INFO_PRINTF2(_L("Destroy Histogram - %d"), error); + return EFail; + } + CleanupStack::PopAndDestroy(hist); + } + CleanupStack::PopAndDestroy(camera); + + __MM_HEAP_MARKEND; + + return result; + } + +// Test step MM-ECM-ADV-U-022-HP +TVerdict RECamHistTest::DoTestStep_22L() + { + TVerdict result = EPass; + CCamera* camera = NULL; + + TInt error = KErrNone; + CCamera::CCameraHistogram* hist = NULL; + + // create a Hist object using NewL + __MM_HEAP_MARK; + MCameraObserver2* observer2 = NULL; + INFO_PRINTF1(_L("Create camera using Camera::New2L() and MCameraObserver2")); + + TRAP(error, camera = CCamera::New2L(*observer2, 0,0)); + + if (error==KErrNone) + { + CleanupStack::PushL(camera); + INFO_PRINTF1(_L("KErrNone return from CCamera::New2L()")); + TRAP(error, hist = CCamera::CCameraHistogram::NewL(*camera)); + + if (error==KErrNone) + { + INFO_PRINTF1(_L("CCameraHistogram object was created using NewL")); + } + else + { + INFO_PRINTF1(_L("CCameraHistogram object was not created using NewL")); + return EFail; + } + } + else + { + INFO_PRINTF2(_L("Unexpected %d return from CCamera::New2L(): observer 2"), error); + result = EFail; + } + + if (hist!= NULL) + { + CleanupStack::PushL(hist); + + // get the supported set of values + TUint32 suppformats = hist->SupportedHistograms(); + + // the array should not be empty + if (suppformats == 0) + { + result = EFail; + } + // Preapare Non-DSA Based Histogram + TUint histhandle = 0; + TPoint orgPos(5,5); + TSize orgSize(90,50); + TRgb orgColor(100,100,100); + + TRAP(error, histhandle = hist->PrepareHistogramL(CCamera::CCameraHistogram::ELuminance)); + + if(error==KErrNone) + { + INFO_PRINTF1(_L("Non-DSA Histogram Created Successful")); + } + else + { + INFO_PRINTF2(_L("Non-DSA Histogram Created- %d"), error); + return EFail; + } + + + hist->StartHistogramL(histhandle); + if(error==KErrNone) + { + INFO_PRINTF1(_L("Start Histogram Successful")); + } + else + { + INFO_PRINTF2(_L("Start Histogram - %d"), error); + return EFail; + } + + // Get a list of active histograms : This has not been implemented and so the count will be 0 + RArray activeHistograms; + TRAP(error, hist->GetActiveHistogramsL(activeHistograms)); + if(error==KErrNone) + { + INFO_PRINTF1(_L("Stop Histogram Successful")); + } + else + { + INFO_PRINTF2(_L("Stop Histogram - %d"), error); + return EFail; + } + + TRAP(error, hist->StopHistogramL(histhandle)); + if(error==KErrNone) + { + INFO_PRINTF1(_L("Stop Histogram Successful")); + } + else + { + INFO_PRINTF2(_L("Stop Histogram - %d"), error); + return EFail; + } + + TRAP(error, hist->DestroyHistogramL(histhandle)); + if(error==KErrNone) + { + INFO_PRINTF1(_L("Destroy Histogram Successful")); + } + else + { + INFO_PRINTF2(_L("Destroy Histogram - %d"), error); + return EFail; + } + CleanupStack::PopAndDestroy(hist); + } + CleanupStack::PopAndDestroy(camera); + + __MM_HEAP_MARKEND; + + return result; + } + +// +// RECamHistogramNotificationTest +// +RECamHistogramNotificationTest* RECamHistogramNotificationTest::NewL(TBool aAllocTest) + { + RECamHistogramNotificationTest* self = new (ELeave) RECamHistogramNotificationTest(aAllocTest); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + return self; + } + +void RECamHistogramNotificationTest::ConstructL() + { + iOriginalSet.Reset(); + iResultSet.Reset(); + + } +RECamHistogramNotificationTest::RECamHistogramNotificationTest(TBool /*aAllocTest*/) + { + iTestStepName = _L("MM-ECM-ADV-U-023-HP"); + } + +TVerdict RECamHistogramNotificationTest::DoTestStepL() + { + TVerdict result = EPass; + CCamera* camera = NULL; + + TInt error = KErrNone; + CCamera::CCameraHistogram* hist = NULL; + + __MM_HEAP_MARK; + INFO_PRINTF1(_L("Create camera using Camera::New2L() and MCameraObserver2")); + + TRAP(error, camera = CCamera::New2L(*this,0,0)); + + if (error==KErrNone) + { + CleanupStack::PushL(camera); + INFO_PRINTF1(_L("KErrNone return from CCamera::New2L()")); + + TRAP(error, hist = CCamera::CCameraHistogram::NewL(*camera)); + if (error==KErrNone) + { + INFO_PRINTF1(_L("CCameraHistogram object was created using NewL")); + } + else + { + INFO_PRINTF1(_L("CCameraHistogram object was not created using NewL")); + result = EFail; + } + + if (hist!= NULL) + { + CleanupStack::PushL(hist); + + // get the supported set of values + TUint32 suppformats = hist->SupportedHistograms(); + + // the array should not be empty + if (suppformats == 0) + { + result = EFail; + } + TUint histhandle = 0; + TRAP(error, histhandle = hist->PrepareHistogramL(CCamera::CCameraHistogram::ELuminance)); + + // set new value + iInputEventUid.iUid = KUidECamEventHistogramUidValue; + + hist->StartHistogramL(histhandle); + if(error==KErrNone) + { + INFO_PRINTF1(_L("Start Histogram Successful")); + } + else + { + INFO_PRINTF2(_L("Start Histogram - %d"), error); + result = EFail; + } + + CheckNotification(iInputEventUid, result); + + // Ignore the Data - check the function + TRAP(error, hist->HistogramDataL()); + if(error==KErrNone) + { + INFO_PRINTF1(_L("Histogram DataL Successful")); + } + else + { + INFO_PRINTF2(_L("Histogram DataL - %d"), error); + result = EFail; + } + + // Overload of HistogramDataL + TRAP(error, hist->HistogramDataL(histhandle)); + if(error==KErrNone) + { + INFO_PRINTF1(_L("Histogram DataL Successful")); + } + else + { + INFO_PRINTF2(_L("Histogram DataL - %d"), error); + result = EFail; + } + + TRAP(error, hist->StopHistogramL(histhandle)); + + if(error==KErrNone) + { + INFO_PRINTF1(_L("Stop Histogram Successful")); + } + else + { + INFO_PRINTF2(_L("Stop Histogram - %d"), error); + result = EFail; + } + + TRAP(error, hist->DestroyHistogramL(histhandle)); + if(error==KErrNone) + { + INFO_PRINTF1(_L("Destroy Histogram Successful")); + } + else + { + INFO_PRINTF2(_L("Destroy Histogram - %d"), error); + result = EFail; + } + + CleanupStack::PopAndDestroy(hist); + } + else + { + result = EFail; + } + CleanupStack::PopAndDestroy(camera); + } + else + { + INFO_PRINTF2(_L("Unexpected %d return from CCamera::New2L(): observer 2"), error); + result = EFail; + } + + __MM_HEAP_MARKEND; + + return result; + } + +/*------------------------------------------------------ + Overlay : RECamOvrlayTest + *------------------------------------------------------*/ + +RECamOvrlayTest* RECamOvrlayTest::NewL(const TDesC& aTestStep) + { + RECamOvrlayTest* self = new (ELeave) RECamOvrlayTest(aTestStep); + return self; + } + +RECamOvrlayTest::RECamOvrlayTest(const TDesC& aTestStep) + { + iTestStepName.Copy(aTestStep); + } + +TVerdict RECamOvrlayTest::DoTestStepL() + { + if(!iTestStepName.Compare(_L("MM-ECM-ADV-U-030-HP"))) + { + return DoTestStep_30L(); + } + else if(!iTestStepName.Compare(_L("MM-ECM-ADV-U-031-HP"))) + { + return DoTestStep_31L(); + } + return EFail; + } + +TVerdict RECamOvrlayTest::DoTestStep_30L() + { + TVerdict verdict = EFail; + INFO_PRINTF1(_L("Alloc test")); + TInt i; + TInt err; + for (i = 1 ; ; i++) + { + __MM_HEAP_MARK; + + if (i % 5 == 0) + { + INFO_PRINTF2(_L("Fail count = %d"), i); + } + + __UHEAP_SETFAIL(RHeap::EFailNext, i); + + TRAP(err, verdict = DoOverlayTestStepL()); + + TAny* testAlloc = User::Alloc(1); + TBool heapTestingComplete = (testAlloc == NULL) && (err==KErrNone); + User::Free(testAlloc); + + __UHEAP_RESET; + __MM_HEAP_MARKEND; + + if ((err != KErrNoMemory ) || heapTestingComplete) + { + INFO_PRINTF4(_L("err = %d, verdict = %d, Fail count = %d"), err, verdict, i); + INFO_PRINTF1(_L("Alloc testing completed successfully")); + verdict = EPass; + break; + } + } + return verdict; + } + +TVerdict RECamOvrlayTest::DoOverlayTestStepL() + { + TVerdict result = EPass; + CCamera* camera = NULL; + + TInt error = KErrNone; + CCamera::CCameraOverlay* ovrlay = NULL; + + // using observer 2 + MCameraObserver2* observer2 = NULL; + + __MM_HEAP_MARK; + INFO_PRINTF1(_L("Create camera using Camera::New2L() and MCameraObserver2")); + + TRAP(error, camera = CCamera::New2L(*observer2, 0,0)); + + if (error==KErrNone) + { + CleanupStack::PushL(camera); + INFO_PRINTF1(_L("KErrNone return from CCamera::New2L()")); + ovrlay = static_cast (camera->CustomInterface(KECamOverlayUid)); + if (ovrlay!= NULL) + { + CleanupStack::PushL(ovrlay); + INFO_PRINTF1(_L("CCameraOverlay object was created")); + CleanupStack::PopAndDestroy(ovrlay); + } + else + { + result = EFail; + User::Leave(KErrNoMemory); + } + CleanupStack::PopAndDestroy(camera); + } + else + { + INFO_PRINTF2(_L("Unexpected %d return from CCamera::New2L(): observer 2"), error); + result = EFail; + User::Leave(KErrNoMemory); + } + __MM_HEAP_MARKEND; + + // create overlay object using NewL + __MM_HEAP_MARK; + INFO_PRINTF1(_L("Create camera using Camera::New2L() and MCameraObserver2")); + + TRAP(error, camera = CCamera::New2L(*observer2, 0,0)); + + if (error==KErrNone) + { + CleanupStack::PushL(camera); + INFO_PRINTF1(_L("KErrNone return from CCamera::New2L()")); + TRAP(error, ovrlay = CCamera::CCameraOverlay::NewL(*camera)); + + if (error==KErrNone) + { + CleanupStack::PushL(ovrlay); + INFO_PRINTF1(_L("CCameraOverlay object was created using NewL")); + + CleanupStack::PopAndDestroy(ovrlay); + } + else + { + INFO_PRINTF1(_L("CCameraOverlay object was not created using NewL")); + result = EFail; + User::Leave(KErrNoMemory); + } + CleanupStack::PopAndDestroy(camera); + } + else + { + INFO_PRINTF2(_L("Unexpected %d return from CCamera::New2L(): observer 2"), error); + result = EFail; + User::Leave(KErrNoMemory); + } + __MM_HEAP_MARKEND; + + return result; + } + +TVerdict RECamOvrlayTest::DoTestStep_31L() + { + TVerdict result = EPass; + CCamera* camera = NULL; + TInt error = KErrNone; + CCamera::CCameraOverlay* ovrlay = NULL; + + // create a Overlay object using NewL + MCameraObserver2* observer2 = NULL; + INFO_PRINTF1(_L("Create camera using Camera::New2L() and MCameraObserver2")); + + __MM_HEAP_MARK; + TRAP(error, camera = CCamera::New2L(*observer2, 0,0)); + + if (error==KErrNone) + { + CleanupStack::PushL(camera); + INFO_PRINTF1(_L("KErrNone return from CCamera::New2L()")); + TRAP(error, ovrlay = CCamera::CCameraOverlay::NewL(*camera)); + + if (error==KErrNone) + { + INFO_PRINTF1(_L("CCameraOverlay object was created using NewL")); + } + else + { + INFO_PRINTF2(_L("CCameraOverlay object was not created using NewL - %d"), error); + result = EFail; + } + CleanupStack::PushL(ovrlay); + + + CCamera::CCameraOverlay::TOverlayParameters parameters; + parameters.iCurrentModes = CCamera::CCameraOverlay::EModeStillImage; + parameters.iCurrentTypes = CCamera::CCameraOverlay::EPerPixel; + parameters.iAlphaValue= 0; + parameters.iPosition = TPoint(2,2); + parameters.iZOrder = 1; + + TInt err = RFbsSession::Connect(); + if (err != KErrNone) + { + INFO_PRINTF2(_L("RFbsSession::Connect() failed, err = %d"), err); + return EInconclusive; + } + + CFbsBitmap* bitmap = new (ELeave) CFbsBitmap; + CleanupStack::PushL(bitmap); + + TUint ovrhandle =0; + + TRAP(error, ovrhandle = ovrlay->CreateOverlayL(parameters, bitmap)); + + if (error == KErrNone) + { + INFO_PRINTF1(_L("Create overlay was successful")); + } + else + { + INFO_PRINTF2(_L("Create overlay - Error - %d"), error); + result = EFail; + } + + TRAP(error, ovrlay->SetOverlayBitmapL(ovrhandle, bitmap)); + if (error == KErrNone) + { + INFO_PRINTF1(_L("Set Overlay Bitmap was successful")); + } + else + { + INFO_PRINTF2(_L("Set Overlay Bitmap - Error - %d"), error); + result = EFail; + } + + CFbsBitmap* modBitmap = new (ELeave) CFbsBitmap; + User::LeaveIfError(modBitmap->Create(TSize(1000,1000),EGray256)); + CleanupStack::PushL(modBitmap); + TRAP(error, ovrlay->SetModifiableOverlayBitmapL(ovrhandle, modBitmap)); + if (error == KErrNone) + { + INFO_PRINTF1(_L("Set Modifiable Overlay Bitmap was successful")); + } + else + { + INFO_PRINTF2(_L("Set Modifiable Overlay Bitmap - Error - %d"), error); + result = EFail; + } + + CFbsBitmap* getBitmap = new (ELeave) CFbsBitmap; + User::LeaveIfError(getBitmap->Create(TSize(1000,1000),EGray256)); + CleanupStack::PushL(getBitmap); + TRAP(error, ovrlay->GetOverlayBitmapL(ovrhandle, getBitmap)); + if (error == KErrNone) + { + INFO_PRINTF1(_L("Get Overlay Bitmap was successful")); + } + else + { + INFO_PRINTF2(_L("Get Overlay Bitmap - Error - %d"), error); + result = EFail; + } + + TRAP(error, ovrlay->GetOverlayParametersL(ovrhandle, parameters)); + if (error == KErrNone) + { + INFO_PRINTF1(_L("Get Overlay Parameters was successful")); + } + else + { + INFO_PRINTF2(_L("Get Overlay Parameters - Error - %d"), error); + result = EFail; + } + + TRAP(error, ovrlay->SetOverlayParametersL(ovrhandle, parameters)); + if (error == KErrNone) + { + INFO_PRINTF1(_L("Set Overlay Parameters was successful")); + } + else + { + INFO_PRINTF2(_L("Set Overlay Parameters - Error - %d"), error); + result = EFail; + } + + CCamera::CCameraOverlay::TOverlaySupportInfo SuppInfo; + TRAP(error, ovrlay->GetOverlaySupport(SuppInfo)); + if (error == KErrNone) + { + INFO_PRINTF1(_L("Get Overlay support was successful")); + } + else + { + INFO_PRINTF2(_L("Get Overlay support - Error - %d"), error); + result = EFail; + } + + RArray overlayHandles; + TRAP(error, ovrlay->GetAllOverlaysInZOrderL(overlayHandles)); + if (error == KErrNone) + { + INFO_PRINTF1(_L("Get All Overlays in Z order was successful")); + } + else + { + INFO_PRINTF2(_L("Get All Overlays in Z order - Error - %d"), error); + result = EFail; + } + + TRAP(error, ovrlay->GetAllOverlaysInZOrderL(CCamera::CCameraOverlay::EModeStillImage,1,overlayHandles)); + if (error == KErrNone) + { + INFO_PRINTF1(_L("Get 'Mode specific' All Overlays in Z order was successful")); + } + else + { + INFO_PRINTF2(_L("Get 'Mode specific' All Overlays in Z order - Error - %d"), error); + result = EFail; + } + + + TRAP(error, ovrlay->SetAllOverlaysInZOrderL(overlayHandles)); + if (error == KErrNone) + { + INFO_PRINTF1(_L("Set All Overlay in Z order was successful")); + } + else + { + INFO_PRINTF2(_L("Set All Overlay in Z order- Error - %d"), error); + result = EFail; + } + + TRAP(error, ovrlay->SetAllOverlaysInZOrderL(CCamera::CCameraOverlay::EModeStillImage,1,overlayHandles)); + if (error == KErrNone) + { + INFO_PRINTF1(_L("Set 'Mode specific' All Overlay in Z order was successful")); + } + else + { + INFO_PRINTF2(_L("Set 'Mode specific' All Overlay in Z order- Error - %d"), error); + result = EFail; + } + + overlayHandles.Close(); + + TRAP(error, ovrlay->ReleaseOverlay(ovrhandle)); + if (error == KErrNone) + { + INFO_PRINTF1(_L("Release Overlay was successful")); + } + else + { + INFO_PRINTF2(_L("Release Overlay - Error - %d"), error); + result = EFail; + } + + CleanupStack::PopAndDestroy(4, ovrlay); //bitmap, ovrlay + + TRAP(error, ovrlay = CCamera::CCameraOverlay::NewL(*camera)); + CleanupStack::PushL(ovrlay); + bitmap = new (ELeave) CFbsBitmap; + CleanupStack::PushL(bitmap); + ovrhandle =0; + + TRAP(error, ovrhandle = ovrlay->CreateOverlayL(parameters, bitmap)); + TSize originalSize = bitmap->SizeInPixels(); + + INFO_PRINTF1(_L("Test size change through CFbsbitmap")); + TSize modifiedSize(640, 480); + CFbsBitmap* modifiedBitmap = new (ELeave) CFbsBitmap; + User::LeaveIfError(modifiedBitmap->Create(modifiedSize,EColor4K)); + CleanupStack::PushL(modifiedBitmap); + originalSize = modifiedBitmap->SizeInPixels(); + TRAP(error, ovrlay->SetModifiableOverlayBitmapL(ovrhandle,modifiedBitmap)); + + CFbsBitmap* retrievedBitmap = new (ELeave) CFbsBitmap; + User::LeaveIfError(retrievedBitmap->Create(TSize(1000,1000),EGray256)); + CleanupStack::PushL(retrievedBitmap); + TRAP(error, ovrlay->GetOverlayBitmapL(ovrhandle, retrievedBitmap)); + + TSize retrievedSize = retrievedBitmap->SizeInPixels(); + + if(originalSize != retrievedSize) + { + INFO_PRINTF2(_L("Modifying overlay size - Error - %d"), error); + result = EFail; + } + + CleanupStack::PopAndDestroy(4, ovrlay); + } + else + { + INFO_PRINTF2(_L("Unexpected %d return from CCamera::New2L(): observer 2"), error); + result = EFail; + } + + RFbsSession::Disconnect(); + + CleanupStack::PopAndDestroy(camera); + __MM_HEAP_MARKEND; + + // + __MM_HEAP_MARK; + TRAP(error, camera = CCamera::New2L(*observer2, 0,0)); + + if (error==KErrNone) + { + CleanupStack::PushL(camera); + INFO_PRINTF1(_L("KErrNone return from CCamera::New2L()")); + TRAP(error, ovrlay = CCamera::CCameraOverlay::NewL(*camera)); + + if (error==KErrNone) + { + INFO_PRINTF1(_L("CCameraOverlay object was created using NewL")); + } + else + { + INFO_PRINTF2(_L("CCameraOverlay object was not created using NewL - %d"), error); + result = EFail; + } + CleanupStack::PushL(ovrlay); + + + CCamera::CCameraOverlay::TOverlayParameters parameters; + parameters.iCurrentModes = CCamera::CCameraOverlay::EModeStillImage; + parameters.iCurrentTypes = CCamera::CCameraOverlay::EPerPixel; + parameters.iAlphaValue= 0; + TSize size2(20,20); + parameters.iPosition = TPoint(2,2); + parameters.iZOrder = 1; + + CFbsBitmap* bitmap = new (ELeave) CFbsBitmap; + CleanupStack::PushL(bitmap); + + TUint ovrhandle =0; + + TRAP(error, ovrhandle = ovrlay->CreateOverlayL(parameters, bitmap)); + if (error == KErrNone) + { + INFO_PRINTF1(_L("Create overlay was successful")); + } + else + { + INFO_PRINTF2(_L("Create overlay - Error - %d"), error); + result = EFail; + } + + TRAP(error, ovrlay->GetOverlayParametersL(ovrhandle, parameters)); + if (error == KErrNone) + { + INFO_PRINTF1(_L("Get Overlay Parameters was successful")); + } + else + { + INFO_PRINTF2(_L("Get Overlay Parameters - Error - %d"), error); + result = EFail; + } + + if(parameters.iCurrentModes & CCamera::CCameraOverlay::EModeStillImageContinuous) + { + INFO_PRINTF1(_L("GetOverlayParametersL was successful")); + } + else + { + INFO_PRINTF1(_L("Get Overlay Parameters unexpected result")); + result = EFail; + } + + TRAP(error, ovrlay->SetOverlayParametersL(ovrhandle, parameters)); + if (error == KErrNone) + { + INFO_PRINTF1(_L("Set Overlay Parameters was successful")); + } + else + { + INFO_PRINTF2(_L("Set Overlay Parameters - Error - %d"), error); + result = EFail; + } + + CCamera::CCameraOverlay::TOverlaySupportInfo SuppInfo; + TRAP(error, ovrlay->GetOverlaySupport(SuppInfo)); + if (error == KErrNone) + { + INFO_PRINTF1(_L("Get Overlay support was successful")); + } + else + { + INFO_PRINTF2(_L("Get Overlay support - Error - %d"), error); + result = EFail; + } + + if(SuppInfo.iSupportedModes & CCamera::CCameraOverlay::EModeStillImageContinuous) + { + INFO_PRINTF1(_L("GetOverlaySupport values were successful")); + } + else + { + INFO_PRINTF1(_L("GetOverlaySupport values unexpected result")); + result = EFail; + } + + //conditional coverage for SetOverlay Parameter + parameters.iCurrentModes = CCamera::CCameraOverlay::EModeViewfinder; + TRAP(error, ovrlay->SetOverlayParametersL(ovrhandle, parameters)); + if (error == KErrNone) + { + INFO_PRINTF1(_L("Set Overlay Parameters was successful")); + } + else + { + INFO_PRINTF2(_L("Set Overlay Parameters - Error - %d"), error); + result = EFail; + } + + parameters.iCurrentModes = CCamera::CCameraOverlay::EModeNone; + TRAP(error, ovrlay->GetOverlayParametersL(ovrhandle, parameters)); + if (error == KErrNone) + { + INFO_PRINTF1(_L("Get Overlay Parameters was successful")); + } + else + { + INFO_PRINTF2(_L("Get Overlay Parameters - Error - %d"), error); + result = EFail; + } + + if(parameters.iCurrentModes & CCamera::CCameraOverlay::EModeClientViewfinder) + { + INFO_PRINTF1(_L("GetOverlayParametersL was successful")); + } + else + { + INFO_PRINTF1(_L("Get Overlay Parameters unexpected result")); + result = EFail; + } + + TRAP(error, ovrlay->ReleaseOverlay(ovrhandle)); + if (error == KErrNone) + { + INFO_PRINTF1(_L("Release Overlay was successful")); + } + else + { + INFO_PRINTF2(_L("Release Overlay - Error - %d"), error); + result = EFail; + } + + CleanupStack::PopAndDestroy(2, ovrlay); //bitmap, ovrlay + } + else + { + INFO_PRINTF2(_L("Unexpected %d return from CCamera::New2L(): observer 2"), error); + result = EFail; + } + CleanupStack::PopAndDestroy(camera); + __MM_HEAP_MARKEND; + // + + return result; + } + +/*------------------------------------------------------ + Snapshot : RECamSnapTest + *------------------------------------------------------*/ + +RECamSnapTest* RECamSnapTest::NewL(const TDesC& aTestStep) + { + RECamSnapTest* self = new (ELeave) RECamSnapTest(aTestStep); + return self; + } + +RECamSnapTest::RECamSnapTest(const TDesC& aTestStep) + { + iTestStepName.Copy(aTestStep); + } + +TVerdict RECamSnapTest::DoTestStepL() + { + if(!iTestStepName.Compare(_L("MM-ECM-ADV-U-040-HP"))) + { + return DoTestStep_40L(); + } + else if(!iTestStepName.Compare(_L("MM-ECM-ADV-U-041-HP"))) + { + return DoTestStep_41L(); + } + else if(!iTestStepName.Compare(_L("MM-ECM-ADV-U-042-HP"))) + { + return DoTestStep_42L(); + } + return EFail; + } + +TVerdict RECamSnapTest::DoTestStep_40L() + { + TVerdict verdict = EFail; + INFO_PRINTF1(_L("Alloc test")); + TInt i; + TInt err; + for (i = 1 ; ; i++) + { + __MM_HEAP_MARK; + + if (i % 5 == 0) + { + INFO_PRINTF2(_L("Fail count = %d"), i); + } + + __UHEAP_SETFAIL(RHeap::EFailNext, i); + + TRAP(err, verdict = DoSnapTestStepL()); + + TAny* testAlloc = User::Alloc(1); + TBool heapTestingComplete = (testAlloc == NULL) && (err==KErrNone); + User::Free(testAlloc); + + __UHEAP_RESET; + __MM_HEAP_MARKEND; + + if ((err != KErrNoMemory ) || heapTestingComplete) + { + INFO_PRINTF4(_L("err = %d, verdict = %d, Fail count = %d"), err, verdict, i); + INFO_PRINTF1(_L("Alloc testing completed successfully")); + verdict = EPass; + break; + } + } + return verdict; + } + +TVerdict RECamSnapTest::DoSnapTestStepL() + { + TVerdict result = EPass; + CCamera* camera = NULL; + + TInt error = KErrNone; + CCamera::CCameraSnapshot* snap = NULL; + + // using observer 2 + MCameraObserver2* observer2 = NULL; + + __MM_HEAP_MARK; + INFO_PRINTF1(_L("Create camera using Camera::New2L() and MCameraObserver2")); + + TRAP(error, camera = CCamera::New2L(*observer2, 0,0)); + + if (error==KErrNone) + { + CleanupStack::PushL(camera); + INFO_PRINTF1(_L("KErrNone return from CCamera::New2L()")); + snap = static_cast (camera->CustomInterface(KECamSnapshotUid)); + if (snap!= NULL) + { + CleanupStack::PushL(snap); + INFO_PRINTF1(_L("CCameraSnaphot object was created")); + CleanupStack::PopAndDestroy(snap); + } + else + { + result = EFail; + User::Leave(KErrNoMemory); + } + CleanupStack::PopAndDestroy(camera); + } + else + { + INFO_PRINTF2(_L("Unexpected %d return from CCamera::New2L(): observer 2"), error); + result = EFail; + User::Leave(KErrNoMemory); + } + __MM_HEAP_MARKEND; + + // create a Snapshot object using NewL + __MM_HEAP_MARK; + INFO_PRINTF1(_L("Create camera using Camera::New2L() and MCameraObserver2")); + + TRAP(error, camera = CCamera::New2L(*observer2, 0,0)); + + if (error==KErrNone) + { + CleanupStack::PushL(camera); + INFO_PRINTF1(_L("KErrNone return from CCamera::New2L()")); + TRAP(error, snap = CCamera::CCameraSnapshot::NewL(*camera)); + + if (error==KErrNone) + { + CleanupStack::PushL(snap); + INFO_PRINTF1(_L("CCameraSnapshot object was created using NewL")); + CleanupStack::PopAndDestroy(snap); + } + else + { + INFO_PRINTF1(_L("CCameraSnapshot object was not created using NewL")); + result = EFail; + User::Leave(KErrNoMemory); + } + CleanupStack::PopAndDestroy(camera); + } + else + { + INFO_PRINTF2(_L("Unexpected %d return from CCamera::New2L(): observer 2"), error); + result = EFail; + User::Leave(KErrNoMemory); + } + __MM_HEAP_MARKEND; + + return result; + } + +TVerdict RECamSnapTest::DoTestStep_41L() + { + TVerdict result = EPass; + CCamera* camera = NULL; + + TInt error = KErrNone; + CCamera::CCameraSnapshot* snap = NULL; + + // create a snapshot object using NewL + __MM_HEAP_MARK; + MCameraObserver2* observer2 = NULL; + INFO_PRINTF1(_L("Create camera using Camera::New2L() and MCameraObserver2")); + + TRAP(error, camera = CCamera::New2L(*observer2, 0,0)); + + if (error==KErrNone) + { + CleanupStack::PushL(camera); + INFO_PRINTF1(_L("KErrNone return from CCamera::New2L()")); + TRAP(error, snap = CCamera::CCameraSnapshot::NewL(*camera)); + + if (error==KErrNone) + { + INFO_PRINTF1(_L("CCameraSnapshot object was created using NewL")); + } + else + { + INFO_PRINTF1(_L("CCameraSnapshot object was not created using NewL")); + return EFail; + } + } + else + { + INFO_PRINTF2(_L("Unexpected %d return from CCamera::New2L(): observer 2"), error); + result = EFail; + } + + if (snap!= NULL) + { + CleanupStack::PushL(snap); + + // get the supported formats + TUint32 suppformats = snap->SupportedFormats(); + + CCamera::TFormat format = CCamera::EFormatMonochrome; + TSize orgSize(90,50); + TRgb orgColor(100,100,100); + TBool AspectRatio = ETrue; + TPoint orgPos(2,2); + + TRAP(error, snap->PrepareSnapshotL(format, orgPos, orgSize, orgColor,AspectRatio)); + + if(error==KErrNone) + { + INFO_PRINTF1(_L("Snapshot Creation Successful")); + } + else + { + INFO_PRINTF2(_L("Snapshot Creation Failed - %d"), error); + result = EFail; + } + + TBool isActive = EFalse; + TRAP(error, isActive = snap->IsSnapshotActive()); + if(error==KErrNone) + { + INFO_PRINTF1(_L("Is Snapshot Active Successful")); + } + else + { + INFO_PRINTF2(_L("Is Snapshot Active Failed - %d"), error); + result = EFail; + } + + if(isActive) + { + INFO_PRINTF1(_L("Snapshot must not be active")); + result = EFail; + } + + // Start Snapshot + TRAP(error, snap->StartSnapshot()); + if(error==KErrNone) + { + INFO_PRINTF1(_L("Start Snapshot Successful")); + } + else + { + INFO_PRINTF2(_L("Start Snapshot Failed - %d"), error); + return EFail; + } + + TRAP(error, isActive = snap->IsSnapshotActive()); + if(error==KErrNone) + { + INFO_PRINTF1(_L("Is Snapshot Active Successful")); + } + else + { + INFO_PRINTF2(_L("Is Snapshot Active Failed - %d"), error); + result = EFail; + } + + if(!isActive) + { + INFO_PRINTF1(_L("Snapshot must not be active")); + result = EFail; + } + + TRAP(error, snap->StopSnapshot()); + if(error==KErrNone) + { + INFO_PRINTF1(_L("Stop Snapshot Successful")); + } + else + { + INFO_PRINTF2(_L("Stop Snapshot Failed - %d"), error); + return EFail; + } + + // Test new snapshot methods. They shall leave with KErrNotSupported + INFO_PRINTF1(_L("Check New Snapshot methods leave with KErrNotSupported")); + CCamera::CCameraSnapshot::TSnapshotParameters snapshotParameters; + TRAP(error, snap->PrepareSnapshotL(snapshotParameters)); + if(error != KErrNotSupported) + { + INFO_PRINTF1(_L("PrepareSnapshotL unexpected result!")); + return EFail; + } + + TRAP(error, snap->GetSnapshotParametersL(snapshotParameters)); + if(error != KErrNotSupported) + { + INFO_PRINTF1(_L("GetSnapshotParametersL unexpected result!")); + return EFail; + } + + TRAP(error, snap->SetSnapshotParametersL(snapshotParameters)); + if(error != KErrNotSupported) + { + INFO_PRINTF1(_L("SetSnapshotParametersL unexpected result!")); + return EFail; + } + + CCamera::CCameraSnapshot::TSnapshotState snapshotState = CCamera::CCameraSnapshot::ESnapshotInactive; + TRAP(error, snap->GetSnapshotStatusL(snapshotState)); + if(error != KErrNotSupported) + { + INFO_PRINTF1(_L("GetSnapshotStatusL unexpected result!")); + return EFail; + } + + CCamera::CCameraSnapshot::TSnapshotVideoFrames snapshotVideoFrames = CCamera::CCameraSnapshot::ESnapshotVideoFirstFrame; + TRAP(error, snap->SelectSnapshotVideoFramesL(snapshotVideoFrames)); + if(error != KErrNotSupported) + { + INFO_PRINTF1(_L("SelectSnapshotVideoFramesL unexpected result!")); + return EFail; + } + + TRAP(error, snap->EnableSnapshotL()); + if(error != KErrNotSupported) + { + INFO_PRINTF1(_L("EnableSnapshotL unexpected result!")); + return EFail; + } + + TRAP(error, snap->DisableSnapshotL()); + if(error != KErrNotSupported) + { + INFO_PRINTF1(_L("DisableSnapshotL unexpected result!")); + return EFail; + } + + + CleanupStack::PopAndDestroy(snap); + } + CleanupStack::PopAndDestroy(camera); + + __MM_HEAP_MARKEND; + + return result; + } + +TVerdict RECamSnapTest::DoTestStep_42L() + { + TVerdict result = EPass; + CCamera* camera = NULL; + + TInt error = KErrNone; + CCamera::CCameraSnapshot* snap = NULL; + + // create a Hist object using NewL + __MM_HEAP_MARK; + MCameraObserver2* observer2 = NULL; + INFO_PRINTF1(_L("Create camera using Camera::New2L() and MCameraObserver2")); + + TRAP(error, camera = CCamera::New2L(*observer2, 0,0)); + + if (error==KErrNone) + { + CleanupStack::PushL(camera); + INFO_PRINTF1(_L("KErrNone return from CCamera::New2L()")); + TRAP(error, snap = CCamera::CCameraSnapshot::NewL(*camera)); + + if (error==KErrNone) + { + INFO_PRINTF1(_L("CCameraSnapshot object was created using NewL")); + } + else + { + INFO_PRINTF1(_L("CCameraSnapshot object was not created using NewL")); + return EFail; + } + } + else + { + INFO_PRINTF2(_L("Unexpected %d return from CCamera::New2L(): observer 2"), error); + result = EFail; + } + + if (snap!= NULL) + { + CleanupStack::PushL(snap); + + // get the supported formats + TUint32 suppformats = snap->SupportedFormats(); + + CCamera::TFormat format = CCamera::EFormatMonochrome; + TSize orgSize(90,50); + TRgb orgColor(100,100,100); + TBool AspectRatio = ETrue; + TPoint orgPos(2,2); + + // Test the other overload of PrepareSnapshotL + TRAP(error, snap->PrepareSnapshotL(format, orgSize, AspectRatio)); + + if(error==KErrNone) + { + INFO_PRINTF1(_L("Snapshot Creation Successful")); + } + else + { + INFO_PRINTF2(_L("Snapshot Creation Failed - %d"), error); + result = EFail; + } + + // Set Background color Snapshot + TRAP(error, snap->SetBgColorL(orgColor)); + if(error==KErrNone) + { + INFO_PRINTF1(_L("Set Background Color Successful")); + } + else + { + INFO_PRINTF2(_L("Set Background Color Failed - %d"), error); + result = EFail; + } + + // Set Position + TRAP(error, snap->SetPositionL(orgPos)); + if(error==KErrNone) + { + INFO_PRINTF1(_L("Set Snapshot Position Successful")); + } + else + { + INFO_PRINTF2(_L("Set Snapshot Position Failed - %d"), error); + result = EFail; + } + + // Start Snapshot + TRAP(error, snap->StartSnapshot()); + if(error==KErrNone) + { + INFO_PRINTF1(_L("Start Snapshot Successful")); + } + else + { + INFO_PRINTF2(_L("Start Snapshot Failed - %d"), error); + return EFail; + } + + // Is shapshot active + TBool isActive = EFalse; + TRAP(error, isActive = snap->IsSnapshotActive()); + if(error==KErrNone) + { + INFO_PRINTF1(_L("Is Snapshot Active Successful")); + } + else + { + INFO_PRINTF2(_L("Is Snapshot Active Failed - %d"), error); + result = EFail; + } + + if(!isActive) + { + INFO_PRINTF1(_L("Snapshot must not be active")); + result = EFail; + } + + // Stop Snapshot + TRAP(error, snap->StopSnapshot()); + if(error==KErrNone) + { + INFO_PRINTF1(_L("Stop Snapshot Successful")); + } + else + { + INFO_PRINTF2(_L("Stop Snapshot Failed - %d"), error); + return EFail; + } + + CleanupStack::PopAndDestroy(snap); + } + CleanupStack::PopAndDestroy(camera); + + __MM_HEAP_MARKEND; + + return result; + } +// +// RECamSnapNotificationTest +// +RECamSnapNotificationTest* RECamSnapNotificationTest::NewL(TBool aAllocTest) + { + RECamSnapNotificationTest* self = new (ELeave) RECamSnapNotificationTest(aAllocTest); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + return self; + } + +void RECamSnapNotificationTest::ConstructL() + { + iOriginalSet.Reset(); + iResultSet.Reset(); + + } +RECamSnapNotificationTest::RECamSnapNotificationTest(TBool /*aAllocTest*/) + { + iTestStepName = _L("MM-ECM-ADV-U-043-HP"); + } + +TVerdict RECamSnapNotificationTest::DoTestStepL() + { + TVerdict result = EPass; + CCamera* camera = NULL; + + TInt error = KErrNone; + CCamera::CCameraSnapshot* snap = NULL; + + __MM_HEAP_MARK; + INFO_PRINTF1(_L("Create camera using Camera::New2L() and MCameraObserver2")); + + TRAP(error, camera = CCamera::New2L(*this,0,0)); + + if (error==KErrNone) + { + CleanupStack::PushL(camera); + INFO_PRINTF1(_L("KErrNone return from CCamera::New2L()")); + + TRAP(error, snap = CCamera::CCameraSnapshot::NewL(*camera)); + if (error==KErrNone) + { + INFO_PRINTF1(_L("CCameraSnapshot object was created using NewL")); + } + else + { + INFO_PRINTF1(_L("CCameraSnapshot object was not created using NewL")); + result = EFail; + } + + if (snap!= NULL) + { + CleanupStack::PushL(snap); + + // get the supported set of values + TUint32 suppformats = snap->SupportedFormats(); + + CCamera::TFormat format = CCamera::EFormatMonochrome; + TSize orgSize(90,50); + TRgb orgColor(100,100,100); + TPoint orgPos(2,2); + TBool AspectRatio = ETrue; + + TRAP(error, snap->PrepareSnapshotL(format, orgPos, orgSize, orgColor,AspectRatio)); + + if(error==KErrNone) + { + INFO_PRINTF1(_L("Snapshot Creation Successful")); + } + else + { + INFO_PRINTF2(_L("Snapshot Creation Failed - %d"), error); + result = EFail; + } + + // set new value + iInputEventUid.iUid = KUidECamEventSnapshotUidValue; + + // Start Snapshot + TRAP(error, snap->StartSnapshot()); + if(error==KErrNone) + { + INFO_PRINTF1(_L("Start Snapshot Successful")); + } + else + { + INFO_PRINTF2(_L("Start Snapshot Failed - %d"), error); + return EFail; + } + + CheckNotification(iInputEventUid, result); + + RArray FrameIndexOrder; + + // Ignore the data + TRAP(error, snap->SnapshotDataL(FrameIndexOrder)); + if(error==KErrNone) + { + INFO_PRINTF1(_L("Snapshot DataL Successful")); + } + else + { + INFO_PRINTF2(_L("Snapshot DataL Failed - %d"), error); + return EFail; + } + FrameIndexOrder.Close(); + + TBool isActive = EFalse; + + TRAP(error, isActive = snap->IsSnapshotActive()); + if(error==KErrNone) + { + INFO_PRINTF1(_L("Is Snapshot Active Successful")); + } + else + { + INFO_PRINTF2(_L("Is Snapshot Active Failed - %d"), error); + return EFail; + } + + if(!isActive) + { + INFO_PRINTF1(_L("Snapshot must not be active")); + result = EFail; + } + + TRAP(error, snap->StopSnapshot()); + if(error==KErrNone) + { + INFO_PRINTF1(_L("Stop Snapshot Successful")); + } + else + { + INFO_PRINTF2(_L("Stop Snapshot Failed - %d"), error); + return EFail; + } + + CleanupStack::PopAndDestroy(snap); + } + else + { + result = EFail; + } + CleanupStack::PopAndDestroy(camera); + } + else + { + INFO_PRINTF2(_L("Unexpected %d return from CCamera::New2L(): observer 2"), error); + result = EFail; + } + + __MM_HEAP_MARKEND; + + return result; + } +