1 /*

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

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

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

     6 * which accompanies this distribution, and is available

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

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description: CaeTestStatesClient.cpp

    15 *

    16 */

    17 #include <fbs.h>

    18 #include <w32std.h>

    19 

    20 #include "CaeTestStatesClient.h"

    21 

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

    23 //_LIT(KVideoPreferredSupplier, "Nokia");

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

    25 //_LIT8(KVideoAudioType, " AMR");

    26 _LIT8(KVideoAudioTypeInv, " TOYOTA");

    27 const TUid KIllegalUidQltyLevels = {666};

    28 

    29 

    30 CCaeTestStatesClient::CCaeTestStatesClient() 

    31     {

    32     }

    33 

    34 

    35 CCaeTestStatesClient::~CCaeTestStatesClient()

    36     {

    37     }

    38 

    39 

    40 CCaeTestStatesClient* CCaeTestStatesClient::NewL()

    41     {

    42     CCaeTestStatesClient* self = new(ELeave) CCaeTestStatesClient;

    43     CleanupStack::PushL( self );

    44     self->ConstructL();

    45     CleanupStack::Pop( self );

    46     return self;

    47     }

    48 

    49 

    50 void CCaeTestStatesClient::ConstructL()

    51     {

    52     CCaeTestClient::ConstructL();

    53 

    54     iRunWithViewFinder = EFalse;

    55     }

    56 

    57 

    58 void CCaeTestStatesClient::RunTestActionL( TestClientActions aAction )

    59     {

    60 

    61     iAction = aAction;

    62 

    63     iActionCycle = 0;

    64 

    65     // Initialize all state variables.

    66     InitStateVariables();

    67 

    68     #ifdef CAE_TEST_VERSION

    69     switch ( iAction )

    70 		{

    71         case EEncodingError:

    72             CaeSetMcaeseoHBufC8ImageReadyError( KErrAbort );

    73             break;

    74         case EDecodingError:

    75             CaeSetMcaesdoCFbsBitmapImageReadyError( KErrAbort );

    76             break;

    77         case EPowerError:

    78             CaeSetPowerOnCompleteError( KErrAbort );

    79             break;

    80         case EReserveError:

    81             CaeSetReserveCompleteError( KErrAbort );

    82             break;

    83         case EStillCaptureError:

    84             CaeSetImageReadyError( KErrAbort );

    85             break;

    86         case EVideoRecorderOpenError:

    87             CaeSetMvruoOpenCompleteError( KErrAbort );

    88             break;

    89         case EVideoRecorderPrepareError:

    90             CaeSetMvruoPrepareCompleteError( KErrAbort );

    91             break;

    92         case EVideoRecordingCompleteError:

    93             CaeSetMvruoRecordCompleteError( KErrAbort );

    94             break;

    95         case EPrepareVideoSettingsError:

    96             CaeSetPrepareVideoSettingsError( KErrAbort );

    97             break;

    98         case ESnapImageError:

    99             CaeSetCreateAndDeliverSnapImageError( KErrAbort );

   100             break;

   101         case EStillImageError:

   102             CaeSetCreateAndDeliverStillImageError( KErrAbort );

   103             break;

   104         case EStillConvertError1:

   105             CaeSetConvertCFbsBitmapToHBufC8Error( KErrAbort );

   106             break;

   107         case EStillConvertError3:

   108             CaeSetConvertHBufC8ToCFbsBitmapError( KErrAbort );

   109             break;

   110         case EStillConvertError2:

   111             CaeSetStillConvertError( KErrAbort );

   112             break;

   113         default:

   114             break;

   115         }

   116     #endif // CAE_TEST_VERSION

   117 

   118 

   119     switch (iAction)

   120         {

   121     case ESetDisplayIndex:

   122         {

   123         delete iCamAppEngine;

   124         iCamAppEngine = NULL;

   125         iCamAppEngine = CCaeEngine::NewL( 0, iDisplayIndex );

   126         iCamAppEngine->SetCamAppEngineObserver( *this );

   127         iCamAppEngine->SetCaeStillBurstObserver( *this );

   128 	    iCamAppEngine->GetInfo( iInfo );

   129         }

   130         break;

   131     case ESetCameraIndexLow:

   132         {

   133         delete iCamAppEngine;

   134         iCamAppEngine = NULL;

   135         iCamAppEngine = CCaeEngine::NewL( -1, iDisplayIndex );

   136         iCamAppEngine->SetCamAppEngineObserver( *this );

   137         iCamAppEngine->SetCaeStillBurstObserver( *this );

   138 	    iCamAppEngine->GetInfo( iInfo );

   139         }

   140         break;

   141     case ESetCameraIndexHigh:

   142         {

   143         delete iCamAppEngine;

   144         iCamAppEngine = NULL;

   145         iCamAppEngine = CCaeEngine::NewL( 123456, iDisplayIndex );

   146         iCamAppEngine->SetCamAppEngineObserver( *this );

   147         iCamAppEngine->SetCaeStillBurstObserver( *this );

   148 	    iCamAppEngine->GetInfo( iInfo );

   149         }

   150         break;

   151     case ESpecifiedPrepareAndCaptureStill2nd:

   152         {

   153         delete iCamAppEngine;

   154         iCamAppEngine = NULL;

   155         iCamAppEngine = CCaeEngine::NewL( 1 );

   156         iCamAppEngine->SetCamAppEngineObserver( *this );

   157         iCamAppEngine->SetCaeStillBurstObserver( *this );

   158 	    iCamAppEngine->GetInfo( iInfo );

   159         }

   160  

   161     default:

   162         break;

   163         }

   164 

   165     

   166 // If interface after S60 2.1.

   167 #ifndef CAE_INTERFACE_21

   168     if ( iAction != ESpecifiedPrepareAndCaptureStill &&

   169         iAction != ESpecifiedPrepareAndRecordVideoNoInit )

   170         {

   171         // Normal case

   172         // This starts operations and state changes.

   173         if ( iCreateSnapImage ) 

   174             {

   175             iCamAppEngine->InitL();

   176             }

   177         else 

   178             {

   179             iCamAppEngine->InitL();

   180             iCamAppEngine->SetSnapImageCreation( EFalse );

   181             }

   182         }

   183     else if ( iAction == ESpecifiedPrepareAndCaptureStill ||

   184             iAction == ESpecifiedPrepareAndCaptureStill2nd )

   185         {

   186         // 

   187         // This starts operations and state changes.

   188         if ( iCreateSnapImage ) 

   189             {

   190             iCamAppEngine->InitL( EFalse );

   191             iCamAppEngine->SetSnapImageCreation( ETrue );

   192             }

   193         else 

   194             {

   195             iCamAppEngine->InitL( ETrue );

   196             iCamAppEngine->SetSnapImageCreation( EFalse );

   197             }

   198         }

   199     else if ( iAction == ESpecifiedPrepareAndRecordVideoNoInit )

   200         {

   201         // No CAE init here, used in 3.2 in case only CAE video features are used

   202 

   203     	#ifdef _DEBUG

   204         RDebug::Print( _L( "Cae: CCaeTestStatesClient::RunTestActionL() reading cameraHandle" ) );

   205         #endif

   206 

   207         TInt cameraHandle = iCamAppEngine->CCameraHandle();

   208 

   209     	#ifdef _DEBUG

   210         RDebug::Print( _L( "Cae: CCaeTestStatesClient::RunTestActionL() creating obs2 NewDuplicate2L cameraHandle=%d" ),cameraHandle );

   211         #endif

   212 

   213         // Create a new Camera API duplicate object, if supported

   214         TRAPD( err, iCameraDup = CCamera::NewDuplicate2L( static_cast<MCameraObserver2&>(*this), cameraHandle ) );

   215         if ( err )

   216             {

   217         	#ifdef _DEBUG

   218             RDebug::Print( _L( "Cae: CCaeTestStatesClient::RunTestActionL() CCamera::NewDuplicate2L return code=%d" ), err ); 

   219             #endif

   220 

   221             // Create old Camera API duplicate object.

   222             iCameraDup = CCamera::NewDuplicateL( static_cast<MCameraObserver&>(*this), cameraHandle );

   223             }

   224         else

   225             {

   226         	#ifdef _DEBUG

   227             RDebug::Print( ( _L( "Cae: CCaeTestStatesClient::RunTestActionL() using duplicated MCameraObserver2" )) ); 

   228             #endif

   229             }

   230 

   231     	#ifdef _DEBUG

   232         RDebug::Print( _L( "Cae: CCaeTestStatesClient::RunTestActionL() calling reserve iCameraDup=%x" ),iCameraDup );

   233         #endif

   234 

   235         iCameraDup->Reserve(); // Poweron called after this in reservecomplete

   236 

   237         // Give C-API time to complete operation

   238         User::After( 500000 );

   239         

   240     	#ifdef _DEBUG

   241         RDebug::Print( _L( "Cae: CCaeTestStatesClient::RunTestActionL() calling cae disable/enable videorecording" ) );

   242         #endif

   243 

   244         // Let CAE know that camera HW reservation is done,

   245         // this will initialize some CAE flags so that video mode can be used

   246         iCamAppEngine->DisableVideoRecording(); // Just to test release before reserve

   247         iCamAppEngine->EnableVideoRecording(); // 

   248         iCamAppEngine->DisableVideoRecording(); // test release 

   249         iCamAppEngine->EnableVideoRecording(); // reserve again

   250         iCamAppEngine->EnableVideoRecording(); // double reserve

   251 

   252         } 

   253 #else   // CAE_INTERFACE_21

   254         // This starts operations and state changes.

   255         if ( iCreateSnapImage ) 

   256             {

   257             iCamAppEngine->InitL();

   258             }

   259         else 

   260             {

   261             iCamAppEngine->InitL( EFalse );

   262             }

   263 #endif

   264         

   265 	// Main part of program is a wait loop.

   266 	// This function completes when the scheduler stops.

   267 	CActiveScheduler::Start();

   268     

   269     if ( iError )

   270         {

   271     	#ifdef _DEBUG

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

   273         #endif

   274         User::Leave( iError );

   275         }

   276 	

   277     #ifdef _DEBUG

   278     RDebug::Print( _L( "Cae: CCaeTestStatesClient::RunTestActionL() returning" ) );

   279     #endif

   280     }

   281 

   282 

   283 void CCaeTestStatesClient::RunTrappedL()

   284     {

   285 	#ifdef _DEBUG

   286     RDebug::Print( _L( "Cae: CCaeTestStatesClient::RunTrappedL() entering, iAction=%d" ),iAction );

   287     #endif

   288 

   289     // This is for timing critical cases

   290     TTime currentTime; 

   291     currentTime.HomeTime();

   292     if ( iNextRunLTime.MicroSecondsFrom( currentTime ) > TTimeIntervalMicroSeconds(0) )

   293         {

   294         CTimer::At( iNextRunLTime );

   295         return;

   296         }

   297 

   298     if ( iAction == ENone || iStop ) 

   299         {

   300         if ( iCamAppEngine->IsViewFinding() )

   301 	        {

   302             iCamAppEngine->StopViewFinder();

   303             iViewFinderStarted = EFalse;

   304             }

   305         iCamAppEngine->CancelCaptureStill();

   306         iCancelCount++;

   307         iCamAppEngine->CloseVideoRecording();

   308         CActiveScheduler::Stop();

   309         }

   310     else if ( iInitReady ) 

   311 		{

   312         iInitReady = EFalse;

   313         iViewFinderStarted = EFalse;        

   314 

   315         switch ( iAction )

   316 		    {

   317             case EInit:

   318                 iStop = ETrue;

   319                 CTimer::After( KNormalTimingDelay );

   320                 break;

   321             case ECCameraHandle:

   322                 iStop = ETrue;

   323                 iCameraHandle = iCamAppEngine->CCameraHandle();

   324                 CTimer::After( KNormalTimingDelay );

   325                 break;

   326             case EInitVideoRecorder:

   327                 iCamAppEngine->InitVideoRecorderL();

   328                 iStop = ETrue;

   329                 CTimer::After( KNormalTimingDelay );

   330                 break;

   331             case EInitVideoRecorderWithUid:

   332                 iCamAppEngine->InitVideoRecorderL(KIllegalUidQltyLevels);

   333                 iStop = ETrue;

   334                 CTimer::After( KNormalTimingDelay );

   335                 break;

   336             case ESwitchPowerOnWhenInitialized:

   337                 if ( iStopWhenCompleted ) 

   338                     {

   339                     iStop = ETrue;

   340                     CTimer::After( KNormalTimingDelay );

   341                     }

   342                 else 

   343                     {

   344                     iStopWhenCompleted = ETrue;

   345                     iInitReady = ETrue;

   346                     iCamAppEngine->PowerOn();

   347                     CTimer::After( KNormalTimingDelay );

   348                     }

   349                 break;

   350             case ESwitchPowerOffAndOn:

   351                 if ( iStopWhenCompleted ) 

   352                     {

   353                     iStop = ETrue;

   354                     CTimer::After( KNormalTimingDelay );

   355                     }

   356                 else if ( iPowerOn ) 

   357                     {

   358                     iCamAppEngine->PowerOff();

   359                     iPowerOn = EFalse;

   360                     iInitReady = ETrue;

   361                     CTimer::After( KNormalTimingDelay );

   362                     }

   363                 else 

   364                     {

   365                     iStopWhenCompleted = ETrue;

   366                     iCamAppEngine->PowerOn();

   367                     }

   368                 break;

   369             case EPowerOffPowerOff:

   370                 iCamAppEngine->PowerOff();

   371                 iCamAppEngine->PowerOff();

   372                 iStop = ETrue;

   373                 CTimer::After( KNormalTimingDelay );

   374                 break;

   375             case EStartVfWhenPowerOff:

   376                 iCamAppEngine->PowerOff();

   377                 iViewFindingUsed = ETrue;

   378                 iCamAppEngine->StartViewFinderBitmapsL( iViewFinderSize );

   379                 if( iCamAppEngine->IsViewFinding() )

   380                     {

   381                     User::Leave ( KErrGeneral );

   382                     }

   383                 iStop = ETrue;

   384                 CTimer::After( KNormalTimingDelay ); // Give some time for all Active objects to react to this command.

   385                 break;

   386             case ERelease:

   387                 iCamAppEngine->Release();

   388                 iStop = ETrue;

   389                 CTimer::After( KNormalTimingDelay );

   390                 break;

   391             case EReleaseRelease:

   392                 iCamAppEngine->Release();

   393                 iCamAppEngine->Release();

   394                 iStop = ETrue;

   395                 CTimer::After( KNormalTimingDelay );

   396                 break;

   397             case EReserveReserve:

   398                 iCamAppEngine->Reserve();

   399                 iStop = ETrue;

   400                 CTimer::After( KNormalTimingDelay ); // needed because this Reserve after InitL does do nothing (no call-back)

   401                 break;

   402             case EReleaseReserve:

   403                 if ( iStopWhenCompleted ) 

   404                     {

   405                     iStop = ETrue;

   406                     CTimer::After( KNormalTimingDelay );

   407                     }

   408                 else if ( iPowerOn ) 

   409                     {

   410                     iCamAppEngine->Release();

   411                     iPowerOn = EFalse;

   412                     iInitReady = ETrue;

   413                     CTimer::After( KNormalTimingDelay );

   414                     }

   415                 else 

   416                     {

   417                     iStopWhenCompleted = ETrue;

   418                     iCamAppEngine->Reserve();

   419                     }

   420                 break;

   421             case EReleaseReserveCapture:

   422                 if ( iContinueWhenCompleted ) 

   423                     {

   424                     iStillPrepareReady = EFalse;

   425                     iVideoPrepareReady = EFalse;

   426                     iCamAppEngine->PrepareStillCaptureL( iStillQualityLevelIndex );

   427                     }

   428                 else if ( iPowerOn ) 

   429                     {

   430                     iCamAppEngine->Release();

   431                     iPowerOn = EFalse;

   432                     iInitReady = ETrue;

   433                     CTimer::After( KNormalTimingDelay );

   434                     }

   435                 else 

   436                     {

   437                     iContinueWhenCompleted = ETrue;

   438                     iCamAppEngine->Reserve();

   439                     }

   440                 break;

   441             case EReleaseReserveRecord:

   442                 if ( iContinueWhenCompleted ) 

   443                     {

   444                     iStillPrepareReady = EFalse;

   445                     iVideoPrepareReady = EFalse;

   446                     iCamAppEngine->InitVideoRecorderL();

   447                     iCamAppEngine->SetVideoRecordingFileNameL( iVideoFileName );

   448                     iCamAppEngine->PrepareVideoRecordingL( iVideoQualityLevelIndex );

   449                     }

   450                 else if ( iPowerOn ) 

   451                     {

   452                     iCamAppEngine->Release();

   453                     iPowerOn = EFalse;

   454                     iInitReady = ETrue;

   455                     CTimer::After( KNormalTimingDelay );

   456                     }

   457                 else 

   458                     {

   459                     iContinueWhenCompleted = ETrue;

   460                     iCamAppEngine->Reserve();

   461                     }

   462                 break;

   463             case EStartVideoRecordingWhenInitialized:

   464                 iCamAppEngine->StartVideoRecording();

   465                 break;

   466             case EStopVideoRecordingWhenInitialized:

   467                 iCamAppEngine->StopVideoRecording();

   468                 break;

   469             case EGetStillQualityIndexWhenEngineInitialized:

   470                 {

   471                 TInt stillQualityIndex = iCamAppEngine->StillQualityIndex();

   472                 if ( stillQualityIndex != -1 ) 

   473                     {

   474                     User::Leave( KErrGeneral );

   475                     }

   476                 }

   477                 iStop = ETrue;

   478                 CTimer::After( KNormalTimingDelay );

   479                 break;

   480             case EGetVideoQualityIndexWhenEngineInitialized:

   481                 {

   482                 TInt videoQualityIndex = iCamAppEngine->VideoQualityIndex();

   483                 if ( videoQualityIndex != -1 ) 

   484                     {

   485                     User::Leave( KErrGeneral );

   486                     }

   487                 }

   488                 iStop = ETrue;

   489                 CTimer::After( KNormalTimingDelay );

   490                 break;

   491             case EEnumerateCaptureSizes:

   492                 {

   493                 TSize stillFrameSize;

   494                 // Tests to get the largest image size (index value 0).

   495                 iCamAppEngine->EnumerateStillCaptureSizes( stillFrameSize, 0, iStillDataFormat );

   496                 if ( stillFrameSize != iStillFrameSize )

   497                     {

   498                     #ifdef _DEBUG

   499                     RDebug::Print( _L( "Cae: CCaeTestStatesClient::RunTrappedL() got stillFrameSize w=%d, h=%d, leaving -2" ), stillFrameSize.iWidth, stillFrameSize.iHeight );

   500                     #endif

   501                     

   502                     User::Leave( KErrGeneral );

   503                     }

   504                 }

   505                 iStop = ETrue;

   506                 CTimer::After( KNormalTimingDelay );

   507                 break;

   508             case EPrepareStillCapturing:

   509             case EPrepareStillCapturingWhenPrepared:

   510             case EPrepareAndCaptureStill:

   511             case EPrepareAndCaptureAndCancelStill:

   512             case EPrepareAndCaptureAndCancelStillAtSnap:

   513             // Burst

   514             case EPrepareAndCaptureStillBurst:

   515             case EPrepareAndCaptureStillBurstCaptureStill:

   516             case EPrepareAndCaptureAndCancelStillBurst:

   517             case EPrepareAndCaptureAndCancelStillBurstAtMoment:

   518             case EPrepareAndCaptureAndCancelStillBurstAtSnap:

   519             case EPrepareAndCaptureAndStopStillBurst:

   520             case EPrepareAndCaptureCaptureStillBurst:

   521             // 

   522             case EStartAndStopVfWhenStillPreparedAndCaptured:

   523             case ECaptureCapture:

   524             case ECaptureRecord:

   525             case ESwitchPowerOnWhenStillPrepared:

   526             case ESwitchPowerOffWhenStillPrepared:

   527             case EGetStillQualityIndexWhenPrepared:

   528             case EEncodingError:

   529             case EStillCaptureError:

   530             case EStillConvertError1:

   531             case EStillConvertError2:

   532             case EStillConvertError3:

   533                 iStillPrepareReady = EFalse;

   534                 iVideoPrepareReady = EFalse;

   535                 iCamAppEngine->PrepareStillCaptureL( iStillQualityLevelIndex );

   536 			    break;

   537             case EPrepareCroppedStillCapturing:

   538                 iStillPrepareReady = EFalse;

   539                 iVideoPrepareReady = EFalse;

   540                 {

   541                 TRect cropRect; 

   542                 iCamAppEngine->PrepareStillCaptureL( iStillQualityLevelIndex, cropRect );

   543                 }

   544 			    break;

   545             case EPrepareStillCaptureWhenPowerOff:

   546                 iCamAppEngine->PowerOff();

   547                 iStillPrepareReady = EFalse;

   548                 iVideoPrepareReady = EFalse;

   549                 iCamAppEngine->PrepareStillCaptureL( iStillQualityLevelIndex );

   550 			    break;

   551             case EPrepareVideoRecording:

   552             case EPrepareVideoRecordingWhenPrepared:

   553             case EPrepareAndRecordVideo:

   554             case EStartAndStopVfWhenVideoPreparedAndRecorded:

   555             case ERecordRecord:

   556             case ERecordCapture:

   557             case ERecordCaptureComplexSequence1:

   558             case ERecordCaptureComplexSequence2:

   559             case ESwitchPowerOnWhenVideoPrepared:

   560             case ESwitchPowerOffWhenVideoPrepared:

   561             case ESwitchPowerOnWhenRecordingVideo:

   562             case ESwitchPowerOffWhenRecordingVideo:

   563             case EStartVideoRecordingWhenRecording:

   564             case EStopVideoRecordingWhenPrepared:

   565             case EPauseVideoWhenPrepared:

   566             case EResumeVideoWhenPrepared:

   567             case EResumeVideoWhenNotPaused:

   568             case EPrepareRecordPauseStopVideo:

   569             case EPrepareRecordPauseResumeStopVideo:

   570             case EPrepareRecordPausePauseStopVideo:

   571             case EGetVideoQualityIndexWhenPrepared:

   572             case ERemainingTimeWhenVideoPrepared:

   573             case EVideoRecorderOpenError:

   574             case EVideoRecorderPrepareError:

   575             case EVideoRecordingCompleteError:

   576             case EPrepareVideoSettingsError:

   577             case EPrepareStillCaptureWhenRecording:

   578                 iStillPrepareReady = EFalse;

   579                 iVideoPrepareReady = EFalse;

   580                 iCamAppEngine->InitVideoRecorderL();

   581                 iCamAppEngine->SetVideoRecordingFileNameL( iVideoFileName );

   582                 iCamAppEngine->PrepareVideoRecordingL( iVideoQualityLevelIndex );

   583 			    break;

   584             case ESpecifiedPrepareStill:

   585             case ESpecPrepCaptureCapture:

   586             case ESpecifiedPrepareStillWhenPrepared:

   587             case ESpecifiedPrepareAndCaptureStill:

   588             case ESpecifiedPrepareAndCaptureStill2nd:

   589             case EPrepareAndCaptureStillBurstExif:

   590             case EPrepareAndCaptureAndCancelStillBurstExif:

   591             case EStartVfPrepareCaptureStillStartAndStopVfExif:

   592             case EStillImageError:

   593 		    case ESetDisplayIndex:

   594             // Burst

   595             case ESpecPrepAndCaptureStillBurst:

   596             case ESpecPrepAndCaptureCaptureStillBurst:

   597             case ESpecPrepAndCaptureStillBurstCaptureStill:

   598             // "Destroy Engine"

   599             case EDestroyEngineWhenStillPrepareReady:

   600             case EDestroyEngineWhenSnapImageReady:

   601             case EDestroyEngineWhenStillCaptureReady:

   602             case EDestroyEngineWhenStillBurstReady:

   603             case EDestroyEngineWhenSnapImageReadyInStillBurst:

   604             case EDestroyEngineWhenStillImageReadyInStillBurst:

   605             case ECaptureStillSetSnapSizeExif:

   606             case ECaptureStillAfterPowerOff:

   607             case ECaptureStillAfterPowerOffOn:

   608             case ESnapImageError:

   609                 iStillPrepareReady = EFalse;

   610                 iVideoPrepareReady = EFalse;

   611                 iCamAppEngine->PrepareStillCaptureL( iStillFrameSize, 

   612                                                      iStillDataFormat, 

   613                                                      iStillCompressionQuality );

   614 			    break;

   615 			case EStartVfPrepareCaptureStillStartAndStopVfSnapExif:

   616                 iStillPrepareReady = EFalse;

   617                 iVideoPrepareReady = EFalse;

   618                 iCamAppEngine->PrepareStillCaptureL( iStillFrameSize, 

   619                                                      iStillDataFormat, 

   620                                                      iStillCompressionQuality,

   621 													 iCropRect,

   622 													 iSnapImageSize);

   623 			    break;

   624             case ECaptureStillSetSnapColorModeExif:

   625                 iStillPrepareReady = EFalse;

   626                 iVideoPrepareReady = EFalse;

   627                 iCamAppEngine->PrepareStillCaptureL( iStillFrameSize, 

   628                                                      iStillDataFormat, 

   629                                                      iStillCompressionQuality );

   630 				iCamAppEngine->SetSnapImageColorMode( EColor16M );

   631 			    break;

   632             case ESpecifiedPrepareVideo: 

   633             case ESpecifiedPrepareVideoWhenPrepared: 

   634             case ESpecifiedPrepareAndRecordVideo: 

   635             case ESpecifiedPrepareAndRecordVideoNoInit: 

   636             // "Destroy Engine"

   637             case EDestroyEngineWhenVideoPrepareReady:

   638             case EDestroyEngineWhenVideoRecordingOn:

   639             case EDestroyEngineWhenVideoRecordingPaused:

   640             case EDestroyEngineWhenVideoRecordingReady:

   641                 iStillPrepareReady = EFalse;

   642                 iVideoPrepareReady = EFalse;

   643                 iCamAppEngine->InitVideoRecorderL();

   644                 iCamAppEngine->SetVideoRecordingFileNameL( iVideoFileName );

   645                 {

   646                 iCamAppEngine->PrepareVideoRecordingL( iVideoFrameSize, 

   647                                                        iVideoFrameRate, 

   648                                                        iVideoBitRate, 

   649                                                        iVideoAudioEnabled, 

   650                                                        *iMimeTypeSet[iVideoCodecSet], 

   651                                                        *iPreferredSupplierSet[iVideoCodecSet],

   652                                                        *iVideoTypeSet[iVideoCodecSet], 

   653                                                        *iAudioTypeSet[iVideoCodecSet] );

   654                 }

   655 			    break;

   656             case ESpecifiedPrepareAudioBrAndRecordVideo:

   657                 iStillPrepareReady = EFalse;

   658                 iVideoPrepareReady = EFalse;

   659                 iCamAppEngine->InitVideoRecorderL();

   660                 iCamAppEngine->SetVideoRecordingFileNameL( iVideoFileName );

   661                 {

   662                 iCamAppEngine->PrepareVideoRecordingL( iVideoFrameSize, 

   663                                                        iVideoFrameRate, 

   664                                                        iVideoBitRate, 

   665                                                        iVideoAudioEnabled,

   666                                                        iAudioBitRate,

   667                                                        *iMimeTypeSet[iVideoCodecSet], 

   668                                                        *iPreferredSupplierSet[iVideoCodecSet],

   669                                                        *iVideoTypeSet[iVideoCodecSet], 

   670                                                        *iAudioTypeSet[iVideoCodecSet] );

   671                 }

   672 			    break;

   673             case ESpecifiedPrepareAudioBrAndRecordVideoAT0:

   674                 iStillPrepareReady = EFalse;

   675                 iVideoPrepareReady = EFalse;

   676                 iCamAppEngine->InitVideoRecorderL();

   677                 iCamAppEngine->SetVideoRecordingFileNameL( iVideoFileName );

   678                 {

   679                 const TDesC8& audioType = KNullDesC8;

   680                 iCamAppEngine->PrepareVideoRecordingL( iVideoFrameSize, 

   681                                                        iVideoFrameRate, 

   682                                                        iVideoBitRate, 

   683                                                        iVideoAudioEnabled,

   684                                                        iAudioBitRate,

   685                                                        *iMimeTypeSet[iVideoCodecSet], 

   686                                                        *iPreferredSupplierSet[iVideoCodecSet],

   687                                                        *iVideoTypeSet[iVideoCodecSet], 

   688                                                        audioType );

   689                 }

   690 			    break;

   691             case ESpecifiedPrepareAudioBrAndRecordVideoATInv:

   692                 iStillPrepareReady = EFalse;

   693                 iVideoPrepareReady = EFalse;

   694                 iCamAppEngine->InitVideoRecorderL();

   695                 iCamAppEngine->SetVideoRecordingFileNameL( iVideoFileName );

   696                 {

   697                 const TDesC8& audioType = KVideoAudioTypeInv;

   698                 iCamAppEngine->PrepareVideoRecordingL( iVideoFrameSize, 

   699                                                        iVideoFrameRate, 

   700                                                        iVideoBitRate, 

   701                                                        iVideoAudioEnabled,

   702                                                        iAudioBitRate,

   703                                                        *iMimeTypeSet[iVideoCodecSet], 

   704                                                        *iPreferredSupplierSet[iVideoCodecSet],

   705                                                        *iVideoTypeSet[iVideoCodecSet], 

   706                                                        audioType );

   707                 }

   708 			    break;

   709             case EStartAndStopVf:  

   710                 iViewFindingUsed = ETrue;

   711                 iCamAppEngine->StartViewFinderBitmapsL( iViewFinderSize );

   712                 // Test IsViewFinding()

   713                 if ( !iCamAppEngine->IsViewFinding() )

   714                     {

   715                     User::Leave( KErrGeneral );

   716                     }

   717                 iStopViewFinder = ETrue;

   718                 CTimer::After( iTimeout );

   719                 break;

   720             case EStartAndStopCroppedVf:  

   721                 iViewFindingUsed = ETrue;

   722                 {

   723                 TRect emptyRect;

   724                 iCamAppEngine->StartViewFinderBitmapsL( iViewFinderSize, emptyRect );

   725                 }

   726                 // Test IsViewFinding()

   727                 if ( !iCamAppEngine->IsViewFinding() )

   728                     {

   729                     User::Leave( KErrGeneral );

   730                     }

   731                 iStopViewFinder = ETrue;

   732                 CTimer::After( iTimeout );

   733                 break;

   734             case EStartAndStopDirectVf:  

   735                 iViewFindingUsed = ETrue;

   736                 {

   737                 RWsSession*      wsSession = NULL;

   738                 CWsScreenDevice* wsScreenDevice = NULL;

   739                 RWindowBase*     windowBase = NULL;

   740                 TRect*           tRect = NULL;

   741                 iCamAppEngine->StartViewFinderDirectL( *wsSession,

   742                                                        *wsScreenDevice,

   743                                                        *windowBase,

   744                                                        *tRect);

   745                 }

   746                 // Test IsViewFinding()

   747                 if ( !iCamAppEngine->IsViewFinding() )

   748                     {

   749                     User::Leave( KErrGeneral );

   750                     }

   751                 iStopViewFinder = ETrue;

   752                 CTimer::After( iTimeout );

   753                 break;

   754             case EStartAndStopCroppedDirectVf:  

   755                 iViewFindingUsed = ETrue;

   756                 {

   757                 RWsSession*      wsSession = NULL;

   758                 CWsScreenDevice* wsScreenDevice = NULL;

   759                 RWindowBase*     windowBase = NULL;

   760                 TRect*           screenRect = NULL;

   761                 TRect*           cropRect = NULL;

   762                 iCamAppEngine->StartViewFinderDirectL( *wsSession,

   763                                                        *wsScreenDevice,

   764                                                        *windowBase,

   765                                                        *screenRect,

   766                                                        *cropRect );

   767                 }

   768                 // Test IsViewFinding()

   769                 if ( !iCamAppEngine->IsViewFinding() )

   770                     {

   771                     User::Leave( KErrGeneral );

   772                     }

   773                 iStopViewFinder = ETrue;

   774                 CTimer::After( iTimeout );

   775                 break;

   776             case ESwitchPowerOffWhenVfRunning:

   777                 iViewFindingUsed = ETrue;

   778                 iCamAppEngine->StartViewFinderBitmapsL( iViewFinderSize );

   779                 CTimer::After( iTimeout );

   780                 break;

   781             case EStartVfPrepareCaptureStillStartAndStopVf:

   782             case EStartVfPrepareRecordVideoStartAndStopVf:

   783             case ESetColorToneVideoRecording:

   784                 iViewFindingUsed = ETrue;

   785                 iCamAppEngine->InitVideoRecorderL();

   786                 iCamAppEngine->SetVideoRecordingFileNameL( iVideoFileName );

   787                 iCamAppEngine->StartViewFinderBitmapsL( iViewFinderSize );

   788                 CTimer::After( 500000 );

   789                 break;

   790             case EIsVideoRecordingWhenPrepared:

   791                 break;

   792             case ECaptureStillWhenEngineInitialized:

   793                 iCamAppEngine->CaptureStill();

   794                 break;

   795             case ECancelCaptureStillWhenInitialized:

   796                 iCamAppEngine->CancelCaptureStill();

   797                 iCancelCount++;

   798                 iStop = ETrue;

   799                 CTimer::After( KNormalTimingDelay );

   800                 break;            

   801             case EStartVfStartVf:

   802                 iViewFindingUsed = ETrue;

   803                 iCamAppEngine->StartViewFinderBitmapsL( iViewFinderSize );

   804                 iCamAppEngine->StartViewFinderBitmapsL( iViewFinderSize );

   805                 iStopViewFinder = ETrue;

   806                 CTimer::After( iTimeout );

   807                 break;

   808                 

   809 // If interface after S60 2.1.

   810 #ifndef CAE_INTERFACE_21

   811             case EGetCustomInterface:

   812                 iCustomInterfacePointer = iCamAppEngine->CustomInterface( iCustomInterfaceUid );

   813                 iStop = ETrue;

   814                 CTimer::After( KNormalTimingDelay );

   815                 break;

   816             case ESetColorTone:

   817             case ESetColorToneWrongParams:

   818             case ESetColorToneRelease:

   819                 if ( iAction == ESetColorToneRelease && iReleaseDone )

   820                     {

   821                     // Do the Reserve, note that engine will call

   822                     // CCaeTestClient::McaeoInitComplete when camera is ready

   823                     iReleaseDone = EFalse;

   824                     iReserveDone = ETrue;

   825                     iInitReady   = ETrue; // continue in this case on next run

   826                     iCamAppEngine->Reserve();

   827                     // No timer call here, McaeoInitComplete does it

   828                     }

   829                 else if ( iAction == ESetColorToneRelease && iReserveDone )

   830                     {

   831                     // state flags to defaults, release/reserve is done now

   832                     iReleaseDone = EFalse;

   833                     iReserveDone = EFalse;

   834 

   835                     // Verify that settings are reset to default after reserve

   836                     MCameraColorToneSettings* CTptr = NULL;

   837                     CTptr = static_cast<MCameraColorToneSettings*> ( iCustomInterfacePointer );

   838                     if ( CTptr->ColorTone() != MCameraColorToneSettings::ENormal )

   839                         {

   840                     	    #ifdef _DEBUG

   841                             RDebug::Print( _L( "Cae: CCaeTestStatesClient::RunTrappedL() Error:ColorTone settings not reset after release()" ));

   842                             #endif

   843                             iStop = ETrue;

   844                             CTimer::After( KNormalTimingDelay );

   845                         }

   846                     else

   847                         {

   848                         // all ok, capture a picture and verify manually normal settings

   849                         iCamAppEngine->PrepareStillCaptureL( iStillQualityLevelIndex );

   850                         }

   851                     }

   852                 else

   853                     {

   854                     iCustomInterfacePointer = iCamAppEngine->CustomInterface( iCustomInterfaceUid );

   855                     if ( !iCustomInterfacePointer )

   856                         {               // Interface not supported, exit test case

   857                 	    #ifdef _DEBUG

   858                         RDebug::Print( _L( "Cae: CCaeTestStatesClient::RunTrappedL() CustomInterface returns 0 for uid %x" ), iCustomInterfaceUid.iUid );

   859                         #endif

   860                         iStop = ETrue;

   861                         CTimer::After( KNormalTimingDelay );

   862                         }

   863                     else

   864                         {

   865                         MCameraColorToneSettings* CTptr = NULL;

   866                         TUint32 supportedCT = 0 ;

   867 

   868                         // cast the TAny pointer to the real color tone interface pointer and

   869                         // read the bitmap of supported color tones

   870                         CTptr = static_cast<MCameraColorToneSettings*> ( iCustomInterfacePointer );

   871                         supportedCT = CTptr->SupportedColorTones();

   872 

   873                         // Check that given parameter is supported by the interface

   874                         if ( (iColorToneValue & supportedCT) ||

   875                             iColorToneValue == MCameraColorToneSettings::ENormal ||

   876                             iAction == ESetColorToneWrongParams)

   877                             {

   878                             // then set the new color tone and verify that it has been set

   879                             CTptr->SetColorToneL( iColorToneValue );

   880                             if ( CTptr->ColorTone() == iColorToneValue )

   881                                 {

   882                                 if ( iAction == ESetColorToneRelease )

   883                                     {

   884                                     // Do now release and then on next run the reserve

   885                                     iCamAppEngine->Release();

   886                                     iReleaseDone = ETrue;

   887                                     iReserveDone = EFalse;

   888                                     iInitReady   = ETrue; // this keeps the same switch active

   889                                     CTimer::After( KNormalTimingDelay );

   890                                     }

   891                                 else

   892                                     {

   893                                     // all ok, capture a picture and verify manually changes

   894                                     iCamAppEngine->PrepareStillCaptureL( iStillQualityLevelIndex );

   895                                     }

   896                                 }

   897                             else // Value not set

   898                                 {

   899                             	#ifdef _DEBUG

   900                                 RDebug::Print( _L( "Cae: ESetColorTone: color iColorToneValue not set to: %d" ), iColorToneValue );

   901                                 #endif

   902                                 iStop = ETrue;

   903                                 CTimer::After( KNormalTimingDelay );

   904                                 }

   905                             }

   906                         else // Value not supported

   907                             {

   908                        	    #ifdef _DEBUG

   909                             RDebug::Print( _L( "Cae: ESetColorTone: color iColorToneValue not supported: %d" ), iColorToneValue );

   910                             #endif

   911                             iStop = ETrue;

   912                             CTimer::After( KNormalTimingDelay );

   913                             }

   914                         }

   915                     }

   916                 break;

   917 #endif

   918             case ERemainingTimeWhenVideoNotInitialized:

   919                 {

   920                 iAction = ENone;

   921                 TTimeIntervalMicroSeconds zeroRemainingTime( 0 );

   922                 TTimeIntervalMicroSeconds remainingTime( 1 );

   923                 remainingTime = iCamAppEngine->RemainingVideoRecordingTime();

   924                 if ( remainingTime != zeroRemainingTime )

   925                     {

   926                     User::Leave( KErrArgument );

   927                     }

   928                 CTimer::After( KNormalTimingDelay );

   929                 }

   930                 break;

   931             default:

   932 			    break;

   933 		    }

   934 		}

   935     else if ( iStillPrepareReady ) 

   936 		{

   937         

   938         if ( iRunWithViewFinder && !iCamAppEngine->IsViewFinding() )

   939 	        {

   940             iCamAppEngine->StartViewFinderBitmapsL( iViewFinderSize );

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

   942             }

   943 

   944         iStillPrepareReady = EFalse;

   945 

   946 		TBool capture = EFalse;

   947 

   948 		switch ( iAction )

   949 			{

   950             case ESwitchPowerOnWhenStillPrepared:

   951                 iAction = ENone;

   952                 iCamAppEngine->PowerOn();

   953                 CTimer::After( KNormalTimingDelay );

   954                 break;

   955             case ESwitchPowerOffWhenStillPrepared:

   956                 iAction = ENone;

   957                 iCamAppEngine->PowerOff();

   958                 CTimer::After( KNormalTimingDelay );

   959                 break;

   960             case EGetStillQualityIndexWhenPrepared:

   961                 {

   962                 TInt stillQualityIndex = iCamAppEngine->StillQualityIndex();

   963                 if ( stillQualityIndex != iStillQualityLevelIndex ) 

   964                     {

   965                     User::Leave( KErrGeneral );

   966                     }

   967                 }

   968                 iStop = ETrue;

   969                 CTimer::After( KNormalTimingDelay );

   970                 break;

   971             case EStartStillOpModeStopVf:

   972                 iStopViewFinder = ETrue;

   973                 CTimer::After( iTimeout );

   974                 break;

   975             case ESpecifiedPrepareStill:

   976             case EPrepareStillCapturing:

   977                 iAction = ENone;

   978                 CTimer::After( KNormalTimingDelay );

   979                 break;

   980             case EPrepareStillCapturingWhenPrepared:

   981                 if ( iStopWhenCompleted ) 

   982                     {

   983                     iStop = ETrue;

   984                     CTimer::After( KNormalTimingDelay );

   985                     }

   986                 else 

   987                     {

   988                     iStopWhenCompleted = ETrue;

   989                     iCamAppEngine->PrepareStillCaptureL( iStillQualityLevelIndex );

   990                     }

   991                 break;

   992             case ESpecifiedPrepareStillWhenPrepared:

   993                 if ( iStopWhenCompleted ) 

   994                     {

   995                     iStop = ETrue;

   996                     CTimer::After( KNormalTimingDelay );

   997                     }

   998                 else 

   999                     {

  1000                     iStopWhenCompleted = ETrue;

  1001                     iCamAppEngine->PrepareStillCaptureL( iStillFrameSize, 

  1002                                                          iStillDataFormat, 

  1003                                                          iStillCompressionQuality );

  1004                     }

  1005                 break;

  1006             // Burst

  1007             case EPrepareAndCaptureStillBurst:

  1008             case EPrepareAndCaptureStillBurstExif:

  1009             case EPrepareAndCaptureAndCancelStillBurstExif:

  1010             case ESpecPrepAndCaptureStillBurst:

  1011             case EPrepareAndCaptureAndCancelStillBurst:

  1012             case EPrepareAndCaptureAndCancelStillBurstAtMoment:

  1013             case EPrepareAndCaptureAndCancelStillBurstAtSnap:

  1014             case EPrepareAndCaptureAndStopStillBurst:

  1015             case EPrepareAndCaptureCaptureStillBurst:

  1016             case ESpecPrepAndCaptureCaptureStillBurst:

  1017             case EPrepareAndCaptureStillBurstCaptureStill:

  1018             case ESpecPrepAndCaptureStillBurstCaptureStill:

  1019             case EDestroyEngineWhenStillBurstReady:

  1020             case EDestroyEngineWhenSnapImageReadyInStillBurst:

  1021             case EDestroyEngineWhenStillImageReadyInStillBurst:

  1022                 if ( iImageCountToCapture == 1 ) 

  1023                     {

  1024                     iImageCountToCapture = iCamAppEngine->SetStillCaptureImageCountL( iStillBurstLength );

  1025                     }

  1026                 if ( iSnapImageSource != CCaeEngine::ESnapImageSourceOriginal )

  1027                     {

  1028                     iCamAppEngine->SetSnapImageSourceL( iSnapImageSource );

  1029                     }

  1030                 capture = ETrue;

  1031                 break;

  1032 			case ECaptureStillSetSnapSizeExif:

  1033 				iCamAppEngine->SetSnapImageSizeL( iSnapImageSize );

  1034                 capture = ETrue;

  1035 			    break;

  1036             case ECaptureStillAfterPowerOff:

  1037 				iCamAppEngine->PowerOff();

  1038                 capture = ETrue;

  1039                 iStop = ETrue;  // Engine cancels capture if power is not on

  1040                 CTimer::After( KNormalTimingDelay );

  1041 			    break;

  1042             case ECaptureStillAfterPowerOffOn:

  1043                 if ( iStopWhenCompleted ) 

  1044                     {

  1045                     if ( iCountStillPrepareComplete <= 1 )

  1046                         {

  1047                         iCamAppEngine->PrepareStillCaptureL( iStillFrameSize, 

  1048                                                              iStillDataFormat, 

  1049                                                              iStillCompressionQuality );

  1050                         }

  1051                     else

  1052                         {

  1053                         capture = ETrue;

  1054                         }

  1055                     //CTimer::After( KNormalTimingDelay );

  1056                     }

  1057                 else if ( iPowerOn ) 

  1058                     {

  1059                     iCamAppEngine->PowerOff();

  1060                     iPowerOn = EFalse;

  1061                     iStillPrepareReady = ETrue; // come back here on next run

  1062                     CTimer::After( KLongTimingDelay );

  1063                     }

  1064                 else 

  1065                     {

  1066                     iStopWhenCompleted = ETrue;

  1067                     iCamAppEngine->PowerOn();

  1068                     iStillPrepareReady = ETrue; // come back here on next run

  1069 //                    CTimer::After( KLongTimingDelay*100 );

  1070                     }

  1071 			    break;

  1072 			case EDestroyEngineWhenStillPrepareReady:

  1073                 delete iCamAppEngine;

  1074                 iCamAppEngine = NULL;

  1075                 CActiveScheduler::Stop();

  1076 			    break;

  1077 			default:

  1078                 capture = ETrue;

  1079                 break;

  1080 			}

  1081         

  1082         // Special treatments for some specific test actions:

  1083         switch ( iAction ) 

  1084             {

  1085             case EPrepareAndCaptureAndStopStillBurst:

  1086                 iStopStillBurst = ETrue;

  1087                 break;

  1088             case EPrepareAndCaptureAndCancelStillBurstAtMoment:

  1089                 iCancelStillBurst = ETrue;

  1090                 break;

  1091             case EPrepareAndCaptureAndCancelStillBurstExif:

  1092 				// Cancel still burst after next view finder frame

  1093                 iCancelStillBurstAfterVfFrame = ETrue; 

  1094                 break;

  1095             case EPrepareAndCaptureAndCancelStillAtSnap:

  1096                 iRunlForSnapImage = ETrue;

  1097                 // Added delay so that the encoder has always time to finish before the next RunTrappedL.

  1098                 // Before is was not so deterministic.

  1099                 iNextRunLTime.HomeTime();

  1100                 iNextRunLTime += TTimeIntervalMicroSeconds32(KLongTimingDelay*1000);

  1101                 break;  

  1102             case EPrepareAndCaptureAndCancelStillBurstAtSnap:

  1103             case EDestroyEngineWhenSnapImageReady:

  1104             case EDestroyEngineWhenSnapImageReadyInStillBurst:

  1105                 iRunlForSnapImage = ETrue;

  1106                 break;

  1107             case EDestroyEngineWhenStillImageReadyInStillBurst:

  1108                 iRunlForStillImage = ETrue; 

  1109                 break;

  1110             default:

  1111                 break;               

  1112             }

  1113         

  1114         // Capture still if requested for the test action.

  1115         if ( capture )

  1116 			{

  1117             iStillCaptureReady = EFalse;

  1118             iStillCapturingOn = ETrue;

  1119             iStillCaptured = ETrue;

  1120 	        #ifdef _DEBUG

  1121             RDebug::Print( _L( "Cae: CCaeTestStatesClient: calling iCamAppEngine->CaptureStill()" ) );

  1122             #endif

  1123 			iCamAppEngine->CaptureStill();

  1124 			}

  1125 

  1126         if ( iAction == EPrepareAndCaptureAndCancelStill || 

  1127              iAction == EPrepareAndCaptureAndCancelStillBurst )

  1128             {

  1129             iCamAppEngine->CancelCaptureStill();

  1130             iCancelCount++;

  1131             iStop = ETrue;

  1132             CTimer::After( KNormalTimingDelay );

  1133             }

  1134