/*

* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description: CaeTestSettingsClient.cpp

*

*/

#include <fbs.h>

#include "CaeTestSettingsClient.h"

//#include "mmcleanup.h"

//_LIT8(KVideoMimeType, "video/3gpp");

//_LIT(KVideoPreferredSupplier, "Nokia");

//_LIT8(KVideoType, "video/H263-2000");

//_LIT8(KVideoAudioType, " AMR");

const TUid KSdUidQltyLevels = {KNullUidValue};

const TUid KSdIllegalUidQltyLevels = {666};

CCaeTestSettingsClient::CCaeTestSettingsClient() 

    {

    }

CCaeTestSettingsClient::~CCaeTestSettingsClient()

    {

    }

CCaeTestSettingsClient* CCaeTestSettingsClient::NewL()

    {

    CCaeTestSettingsClient* self = new(ELeave) CCaeTestSettingsClient;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

void CCaeTestSettingsClient::ConstructL()

    {

    CCaeTestClient::ConstructL();

    iRunWithViewFinder = EFalse;

    }

void CCaeTestSettingsClient::RunTestActionL( TestClientActions aAction )

    {

	#ifdef _DEBUG

    RDebug::Print( _L( "Cae: CCaeTestVideoSettingsClient::RunTestActionL() entering" ) );

    #endif

    iAction = aAction;

	iSavedAction = aAction;

    // Initialize all state variables.

    InitStateVariables();

    iCamAppEngine->InitL( KSdUidQltyLevels );

	// Main part of program is a wait loop.

	// This function completes when the scheduler stops.

	CActiveScheduler::Start();

    if ( iError )

        {

    	#ifdef _DEBUG

        RDebug::Print( _L( "Cae: CCaeTestSettingsClient::RunTestActionL() leaving (error detected)" ) );

        #endif

        User::Leave( iError );

        }

    #ifdef _DEBUG

    RDebug::Print( _L( "Cae: CCaeTestSettingsClient::RunTestActionL() returning" ) );

    #endif

    }

void CCaeTestSettingsClient::RunTrappedL()

    {

	#ifdef _DEBUG

    RDebug::Print( _L( "Cae: CCaeTestSettingsClient::RunTrappedL() entering" ) );

    #endif

    if ( iStop ) 

        {

        if ( iCamAppEngine->IsViewFinding() )

	        {

            iCamAppEngine->StopViewFinder();

            iViewFinderStarted = EFalse;

            }

        iCamAppEngine->CancelCaptureStill();

        iCamAppEngine->CloseVideoRecording();

        delete iBitmapSave;

        iBitmapSave = NULL;

        delete iDataSave;

        iDataSave = NULL;

        CActiveScheduler::Stop();

        }

    else if ( iInitReady ) 

		{

        if ( iAction != ESetVideoFileNameWhenNotInitialized &&

             iAction != ESetAudioWhenVideoNotInitialized &&

             iAction != ESetClipMaxSizeWhenVideoNotInitialized &&

             iAction != EGetAudioWhenVideoNotInitialized )

            {

            iCamAppEngine->InitVideoRecorderL( KSdUidQltyLevels );

            }

        User::After( 1000000 ); // Give some time for camera drivers to settle.

        switch ( iAction )

            {

            case EGetInfo:

                iCamAppEngine->GetInfo( iInfo );

                iStop = ETrue;

                break;

            case ESetVideoFileNameWhenInitialized:

            case ESetVideoFileNameWhenNotInitialized:

                iCamAppEngine->SetVideoRecordingFileNameL( iVideoFileName );

                iStop = ETrue;

                break;

            case ESetEmptyVideoFileNameWhenInitialized:

                iCamAppEngine->SetVideoRecordingFileNameL( _L("") );

                iStop = ETrue;

                break;

            case ESetDigiZoomWhenInitialized:

                iAction = EDefault;

                iCamAppEngine->SetZoomModeL( static_cast<CCaeEngine::TZoomMode>( iZoomMode ) );

                iCamAppEngine->SetZoomValueL( iDigiZoomValue );

                break;

            case ESetBrightnessWhenInitialized:

                iAction = EDefault;

                iCamAppEngine->SetBrightnessL( iBrightness );

                break;

            case ESetContrastWhenInitialized:

                {

                iAction = EDefault;

                //Test before setting, value is unknown?

                TInt contrast = iCamAppEngine->Contrast();

                iCamAppEngine->SetContrastL( iContrast );

                //Test immediately that value is right

                contrast = iCamAppEngine->Contrast();

                if ( contrast != iContrast )

                    {

                    User::Leave ( KErrGetNotEqualToValuePreviouslySet );

                    }

                }

                break;

            case ESetExposureModeWhenInitialized:

                iAction = EDefault;

                iCamAppEngine->SetExposureModeL( static_cast<CCamera::TExposure>( iExposureMode ) );

                break;

            case ESetEvCompensationWhenInitialized:

                {

                // Read value before setting, should be zero if not supported

                TInt evCompensation = iCamAppEngine->EvCompensation();

                if ( evCompensation != 0 )

                    {

                    User::Leave ( KErrGetNotEqualToValuePreviouslySet );

                    }

                iCamAppEngine->SetEvCompensationL( iEvCompensation );

                }

                break;

            case ESetWhiteBalanceModeWhenInitialized:

                iAction = EDefault;

                iCamAppEngine->SetWhiteBalanceModeL( static_cast<CCamera::TWhiteBalance>( iWhiteBalanceMode ) );

                break;

            case ESetFlashModeWhenInitialized:

                iAction = EDefault;

                iCamAppEngine->SetFlashModeL( static_cast<CCamera::TFlash>( iFlashMode ) );

                break;

            case EResetToDefaults:

                // iAction = EDefault;

                iCamAppEngine->SetZoomModeL( static_cast<CCaeEngine::TZoomMode>( iZoomMode ) );

                iCamAppEngine->SetZoomValueL( iDigiZoomValue );

                if ( TCameraInfo::EBrightnessSupported & iInfo.iOptionsSupported )

		            {

                    iCamAppEngine->SetBrightnessL( iBrightness );

                    }

                if ( TCameraInfo::EContrastSupported & iInfo.iOptionsSupported )

		            {

                    iCamAppEngine->SetContrastL( iContrast );

                    }

                iCamAppEngine->SetExposureModeL( static_cast<CCamera::TExposure>( iExposureMode ) );

                iCamAppEngine->SetWhiteBalanceModeL( static_cast<CCamera::TWhiteBalance>( iWhiteBalanceMode ) );

                iCamAppEngine->SetFlashModeL( static_cast<CCamera::TFlash>( iFlashMode ) );

                break;

            case ESetViewFinderMirror:

                {

                TBool mirrorVF = iCamAppEngine->ViewFinderMirror();

                if ( mirrorVF )

                    {

                    User::Leave ( KErrGetNotEqualToValuePreviouslySet );

                    }

                }

                iAction = EDefault;

                iCamAppEngine->SetViewFinderMirrorL( ETrue );

                break;

            case EGetStillFrameSizeWhenInitialized:

                // Test with invalid quality level index.

                iCamAppEngine->GetStillFrameSize( -1, iStillFrameSizeSet );

                iCamAppEngine->GetStillFrameSize( 666, iStillFrameSizeSet );

                // Test with valid quality level index.

                iCamAppEngine->GetStillFrameSize( iStillQualityLevelIndex, iStillFrameSizeSet );

                iStop = ETrue;

                break;

            case EEstimatedStillSizeInBytesWhenInitialized:

                // Test with invalid quality level index.

                iEstimatedStillSizeInBytesSet = 

                    iCamAppEngine->EstimatedStillSizeInBytes( -1 );

                iEstimatedStillSizeInBytesSet = 

                    iCamAppEngine->EstimatedStillSizeInBytes( 666 );

                // Test with valid quality level index.

                iEstimatedStillSizeInBytesSet = 

                    iCamAppEngine->EstimatedStillSizeInBytes( iStillQualityLevelIndex );

                iStop = ETrue;

                break;

            case EGetVideoFrameSizeWhenInitialized:

                {

                // test first with invalid index values: negative and too big, should not modify data

                    TSize tempFrameSize1( KImgWidthQCIF, KImgHeightQCIF );

                    TSize tempFrameSize2( KImgWidthQCIF, KImgHeightQCIF );

                    iCamAppEngine->GetVideoFrameSize( -1, tempFrameSize1 );

                    if ( tempFrameSize1 != tempFrameSize2 )

                        {

                        User::Leave ( KErrArgument );

                        }

                    iCamAppEngine->GetVideoFrameSize( 666, tempFrameSize1 );

                    if ( tempFrameSize1 != tempFrameSize2 )

                        {

                        User::Leave ( KErrArgument );

                        }

                    iCamAppEngine->GetVideoFrameSize( iVideoQualityLevelIndex, iVideoFrameSizeSet );

                    iStop = ETrue;

                }

                break;

            case EVideoFrameRateWhenInitialized:

                {

                // test first with invalid index values: negative and too big, should return 0

                iVideoFrameRateSet = iCamAppEngine->VideoFrameRate( -1 );

                if ( iVideoFrameRateSet != 0 )

                    {

                    User::Leave ( KErrArgument );

                    }

                iVideoFrameRateSet = iCamAppEngine->VideoFrameRate( 666 );

                if ( iVideoFrameRateSet != 0 )

                    {

                    User::Leave ( KErrArgument );

                    }

                iVideoFrameRateSet = iCamAppEngine->VideoFrameRate( iVideoQualityLevelIndex );

                iStop = ETrue;

                }

                break;

            case EEstimatedVideoRecordingBitRateWhenInitialized:

                // test first with invalid index values: negative and too big, should return 0

                iEstimatedVideoBitRateSet = 

                    iCamAppEngine->EstimatedVideoRecordingBitRateL( -1 );

                if ( iEstimatedVideoBitRateSet != 0 )

                    {

                    User::Leave ( KErrArgument );

                    }

                iEstimatedVideoBitRateSet = 

                    iCamAppEngine->EstimatedVideoRecordingBitRateL( 666 );

                if ( iEstimatedVideoBitRateSet != 0 )

                    {

                    User::Leave ( KErrArgument );

                    }

                iEstimatedVideoBitRateSet = 

                    iCamAppEngine->EstimatedVideoRecordingBitRateL( iVideoQualityLevelIndex );

                iStop = ETrue;

                break;

            case ESetClipMaxSizeWhenVideoNotPrepared:

                iAction = EDefault;

                iCamAppEngine->SetVideoClipMaxSizeL( iVideoMaxClipSizeInBytes );

                break;

            /*

            case EPrepareAndSetStillBurstCaptureInterval:

                iAction = EDefault;

                iCamAppEngine->PrepareStillCaptureL( iStillQualityLevelIndex );

			    break;

            */

            case EInitUid:

                iCamAppEngine->InitL( KSdIllegalUidQltyLevels );// will leave

                iStop = ETrue;

                break;

            case ESetAudioWhenVideoNotInitialized:

                iAction = EDefault;

                iCamAppEngine->SetVideoAudioL( iVideoAudioEnabled );

                break;

            case ESetClipMaxSizeWhenVideoNotInitialized:

                iAction = ENone;

                iCamAppEngine->SetVideoClipMaxSizeL( iVideoMaxClipSizeInBytes );

                break;

            case EGetAudioWhenVideoNotInitialized:

                {

                iStop = ETrue;

                TBool audio = iCamAppEngine->VideoAudio();

                if ( audio != EFalse )

                    {

                    User::Leave ( KErrArgument );

                    }

                }

                break;

            case EEnumerateVideoFrameSize:

                {

                iStop = ETrue;

                TInt enumIndVGA;

                TInt enumIndCIF;

                TInt enumIndQCIF;

                TInt enumIndBIG;

                TInt enumIndZERO;

                TSize sizeVGA( KImgWidthVGA, KImgHeightVGA );

                TSize sizeCIF( KImgWidthCIF, KImgHeightCIF );

                TSize sizeQCIF( KImgWidthQCIF, KImgHeightQCIF );

                TSize sizeBIG( KImgWidthTooBig, KImgHeightTooBig );

                TSize sizeZERO( 0, 0 );

                enumIndVGA  = iCamAppEngine->EnumerateVideoFrameSizeL( sizeVGA );

                enumIndCIF  = iCamAppEngine->EnumerateVideoFrameSizeL( sizeCIF );

                enumIndQCIF = iCamAppEngine->EnumerateVideoFrameSizeL( sizeQCIF );

                enumIndBIG  = iCamAppEngine->EnumerateVideoFrameSizeL( sizeBIG );

                enumIndZERO = iCamAppEngine->EnumerateVideoFrameSizeL( sizeZERO );

                if ( ( enumIndVGA < 0 && enumIndCIF < 0 && enumIndQCIF < 0 ) ||

                    enumIndBIG >= 0 || enumIndZERO >= 0 )

                    {

                    User::Leave ( KErrNotSupported );

                    }

                }

                break;

            case EInstalledExtensionList:

                {

                RCaeOrderedFeatureList installedExtensions1;

                RCaeOrderedFeatureList installedExtensions2;

                TCaeOrderedFeatureListItem item;

                // call the get function

                iCamAppEngine->GetOrderL( installedExtensions1 );

                // test that cae resets the parameter before usage

                item.iFeatureUid = KSdIllegalUidQltyLevels;

                installedExtensions2.Append( item );

                iCamAppEngine->GetOrderL( installedExtensions2 );

                // Check that the both arrays are the same

                if ( installedExtensions1.Count() != installedExtensions2.Count() )

                    {

                    installedExtensions1.Reset();

                    installedExtensions2.Reset();

                    RDebug::Print( _L( "Cae: CCaeTestSettingsClient: CAE doesn't reset the array" ) );

                    User::Leave ( KErrArgument );

                    }

                for(TInt i=0; i < installedExtensions1.Count(); i++ )

                    {

                    if ( installedExtensions1[i].iServiceUid != installedExtensions2[i].iServiceUid ||

                        installedExtensions1[i].iFeatureUid != installedExtensions2[i].iFeatureUid )

                        {

                        installedExtensions1.Reset();

                        installedExtensions2.Reset();

                        RDebug::Print( _L( "Cae: CCaeTestSettingsClient: CAE the array is not same" ) );

                        User::Leave ( KErrArgument );

                        }

                    }

                installedExtensions1.Reset();

                installedExtensions2.Reset();

                iStop = ETrue;

                }

                break;

            case ESkippedExtensionList:

                {

                RCaeOrderedFeatureList skippedExtensions1;

                RCaeOrderedFeatureList skippedExtensions2;

                TCaeOrderedFeatureListItem item;

                // call get function twice

                iCamAppEngine->SkippedExtensionListL( skippedExtensions1 );

                // test that cae resets non-empty parameter

                item.iFeatureUid = KSdIllegalUidQltyLevels;

                skippedExtensions2.Append( item );

                iCamAppEngine->SkippedExtensionListL( skippedExtensions2 );

                // Check that the both arrays are the same

                if ( skippedExtensions1.Count() != skippedExtensions2.Count() )

                    {

                    skippedExtensions1.Reset();

                    skippedExtensions2.Reset();

                    RDebug::Print( _L( "Cae: CCaeTestSettingsClient: CAE doesn't reset the array" ) );

                    User::Leave ( KErrArgument );

                    }

                for(TInt i=0; i < skippedExtensions1.Count(); i++ )

                    {

                    if ( skippedExtensions1[i].iServiceUid != skippedExtensions2[i].iServiceUid ||

                        skippedExtensions1[i].iFeatureUid != skippedExtensions2[i].iFeatureUid )

                        {

                        skippedExtensions1.Reset();

                        skippedExtensions2.Reset();

                        RDebug::Print( _L( "Cae: CCaeTestSettingsClient: array is not same" ) );

                        User::Leave ( KErrArgument );

                        }

                    }

                skippedExtensions1.Reset();

                skippedExtensions2.Reset();

                iStop = ETrue;

                }

                break;

            case ESetSkippedExtensionList:

                {

                RCaeOrderedFeatureList skippedExtensions1;

                RCaeOrderedFeatureList skippedExtensions2;

                TCaeOrderedFeatureListItem item;

                // call set function twice

                iCamAppEngine->SetSkippedExtensionList( skippedExtensions1 );

                iCamAppEngine->SetSkippedExtensionList( skippedExtensions1 );

                // read and verify

                iCamAppEngine->SkippedExtensionListL( skippedExtensions1 );

                if ( skippedExtensions1.Count() != 0 )

                    {

                    skippedExtensions1.Reset();

                    RDebug::Print( _L( "Cae: CCaeTestSettingsClient: get/set error" ) );

                    User::Leave ( KErrArgument );

                    }

                // Add one UID

                item.iFeatureUid = KSdIllegalUidQltyLevels;

                skippedExtensions1.Append( item );

                iCamAppEngine->SetSkippedExtensionList( skippedExtensions1 );

                iCamAppEngine->SetSkippedExtensionList( skippedExtensions1 );

                // read and verify

                skippedExtensions1.Reset();

                iCamAppEngine->SkippedExtensionListL( skippedExtensions1 );

                if ( skippedExtensions1.Count() != 0 )

                    {

                    skippedExtensions1.Reset();

                    RDebug::Print( _L( "Cae: CCaeTestSettingsClient: set inv. error" ) );

                    User::Leave ( KErrArgument );

                    }

                // call the get function to get installed extensions

                iCamAppEngine->GetOrderL( skippedExtensions1 );

                // Add one invalid UID and set all skipped

                item.iFeatureUid = KSdIllegalUidQltyLevels;

                skippedExtensions1.Append( item );

                iCamAppEngine->SetSkippedExtensionList( skippedExtensions1 );

                // read and verify that both arrays are the same

                iCamAppEngine->SkippedExtensionListL( skippedExtensions1 );

                iCamAppEngine->GetOrderL( skippedExtensions2 );

                // Check that the both arrays are the same

                if ( skippedExtensions1.Count() != skippedExtensions2.Count() )

                    {

                    skippedExtensions1.Reset();

                    skippedExtensions2.Reset();

                    RDebug::Print( _L( "Cae: CCaeTestSettingsClient: CAE doesn't reset the array" ) );

                    User::Leave ( KErrArgument );

                    }

                for(TInt i=0; i < skippedExtensions1.Count(); i++ )

                    {

                    if ( skippedExtensions1[i].iServiceUid != skippedExtensions2[i].iServiceUid ||

                        skippedExtensions1[i].iFeatureUid != skippedExtensions2[i].iFeatureUid )

                        {

                        skippedExtensions1.Reset();

                        skippedExtensions2.Reset();

                        RDebug::Print( _L( "Cae: CCaeTestSettingsClient: array is not same" ) );

                        User::Leave ( KErrArgument );

                        }

                    }

                skippedExtensions1.Reset();

                skippedExtensions2.Reset();

                iStop = ETrue;

                }

                break;

            default:

                 //iVideoRecordingOn = EFalse;

                 //iCamAppEngine->StopVideoRecording();

                break;

            }

        User::After( 1000000 ); // Give some time for camera drivers to settle.

        if ( ( iAction != ENone ) && !iStop)

            {

            iInitReady = EFalse;

            iViewFinderStarted = EFalse;

            iStillPrepareReady = EFalse;

            iVideoPrepareReady = EFalse;

            switch ( iOpMode )

                {

                case EClientOpModeStill:

					switch ( iAction )

						{

						case ESetEvCompensationWhenInitialized:

						case ESetEvCompensationWhenStillPrepared:

						case ESetJpegQualityWhenStillPrepared:

						case EProcessExtCapturedImageBurst:

						case EProcessExtCapturedImageBurstTDesC8:

							if ( iAction == ESetEvCompensationWhenInitialized )

								{

								iAction = EDefault;

								}

							iCamAppEngine->PrepareStillCaptureL( iStillFrameSize, 

																 iStillDataFormat, 

																 iStillCompressionQuality );

							break;

						case ESetSnapImageSizeBeforePrepare: