/*

* Copyright (c) 2002 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:  Camcorder MMF API Test DLL

*

*/

// INCLUDE FILES

#include "CamcTestClient_6.h"

#include "badesca.h"

#include "camctest.h"

#include <AudioPreference.h>

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES 

// CONSTANTS

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

CCamcTestClient_6::CCamcTestClient_6 () : CTimer(CActive::EPriorityHigh)

    {

    }

CCamcTestClient_6::~CCamcTestClient_6 ()

    {

    Cancel();

    delete iCamc;

    }

CCamcTestClient_6* CCamcTestClient_6::NewL()

    {

    CCamcTestClient_6* self = new(ELeave) CCamcTestClient_6;

    CleanupStack::PushL(self);

    self->ConstructL( );

    CleanupStack::Pop(self);

    return self;

    }

void CCamcTestClient_6::ConstructL( )

    {

    iCamc = CVideoRecorderUtility::NewL( *this, KAudioPriorityVideoRecording, EMdaPriorityPreferenceTimeAndQuality );

    iOpenReady = EFalse;

    iPrepareReady = EFalse;

    iRecordingReady = EFalse;

    iPaused = EFalse;

    iResumeRecording = EFalse;

       CTimer::ConstructL();

    iTimeout = 0;

    iClosed = 0;

    CActiveScheduler::Add(this);

    }

void CCamcTestClient_6::Start_Active_ObjectL ( TestClient6Actions aAction, TInt aCameraHandle )

    {

    TInt camHandle = aCameraHandle;

    TUid controllerUid = {0x101F8503};	//implementation uid

    TUid formatUid = {0};

    iAction = aAction;                  //iAction might be set to NULL after action has been executed

    iSavedAction = aAction;             //SavedAction will never be changed.

    //	iTimeout = aTimeout;

    iTimeout = 1500000;

    switch ( iAction )

        {

        case K_Tc6_VideoTypeLWhenOpenWithoutSpecifyingVideoTypeAndNotRecording :

        case K_Tc6_AudioTypeLWhenOpenWithoutSpecifyingAudioTypeAndNotRecording :

        case K_Tc6_SetVideoTypeLWhenOpenWithoutSpecifyingVideoTypeAndNotRecording :

        case K_Tc6_SetAudioTypeLWhenOpenWithoutSpecifyingAudioTypeAndNotRecording :

            {

            TFileName file;

            AddDriveLetterToPath(_L("recordQCIF.3gp"),file);

            TRAPD(err,

                iCamc->OpenFileL( file, camHandle, 

                controllerUid,

                formatUid ));

            if (err)

                {

                User::Leave(99);

                }

            break;    

            }

        case K_Tc6_VideoTypeLWhenOpenWithNULLAndNotRecording :

            {

            TFileName file;

            AddDriveLetterToPath(_L("recordQCIF.3gp"),file);

            TRAPD(err,

                iCamc->OpenFileL( file, camHandle, 

                controllerUid,

                formatUid,

                _L8("") ));

            if (err)

                {

                User::Leave(99);

                }

            break;   

            }

        default:

            {

            switch ( iAction )

                {

                case K_Tc6_ControllerImplementationInformationWhenNotOpen:

                    {

                    iCamc->ControllerImplementationInformationL();

                    // Test case should have left already.    

                    // There is a problem if we haven't left already

                    User::Leave(KErrCorrupt);

                    break;

                    }

                case K_Tc6_VideoTypeLWhenOpenWithMimeAndNotRecordingNewFormat:

                    {

                    TFileName file;

                    AddDriveLetterToPath(_L("recordQCIF.3gp"),file);

                    TRAPD(err,

                        iCamc->OpenFileL( file, camHandle, 

                        controllerUid,

                        formatUid,

                        _L8("video/mp4v-es"),

                        TFourCC(' ', 'A', 'M', 'R') ));

                    if (err)

                        {

                        User::Leave(99);

                        }

                    break;

                    }

                case K_Tc6_ControllerImplementationInformationWhenOpenNew_MPEG4:

                case K_Tc6_SetVideoTypeLWithProfile3:

                    {

                    TFileName file;

                    AddDriveLetterToPath(_L("recordQCIF.mp4"),file);

                    TRAPD(err,

                        iCamc->OpenFileL( file, camHandle, 

                        controllerUid,

                        formatUid,

                        _L8("video/mp4v-es; profile-level-id=3"),

                        TFourCC(' ', 'A', 'M', 'R') ));

                    if (err)

                        {

                        User::Leave(99);

                        }

                    break;

                    }

                default:

                    {

                    TFileName file;

                    AddDriveLetterToPath(_L("recordQCIF.3gp"),file);

                    TRAPD(err,

                        iCamc->OpenFileL( file, camHandle, 

                        controllerUid,

                        formatUid,

                        _L8("video/H263-2000"),

                        TFourCC(' ', 'A', 'M', 'R') ));

                    if (err)

                        {

                        User::Leave(99);

                        }

                    break;

                    }

                }

/*            TFileName file;

            AddDriveLetterToPath(_L("recordQCIF.3gp"),file);

            TRAPD(err,

                iCamc->OpenFileL( file, camHandle, 

                controllerUid,

                formatUid,

                _L8("video/H263-2000"),

                TFourCC(' ', 'A', 'M', 'R') ));

            if (err)

                {

                User::Leave(99);

                }*/

            }

        }

    iOpenReady = EFalse;

    // Main part of program is a wait loop

    // This function completes when the scheduler stops

    CActiveScheduler::Start();

    if ( iError )

        {

        User::Leave( iError );

        }

    }

void CCamcTestClient_6::RunL()

    {

    // Trap RunL, to catch if the AO leaves.

    // A Walkaround...

    // RunError() should be used in this case, but

    // Apparently, it is not possible to use the AO RunError() virtual function

    // for that purpose, it is not called.

    TRAPD( err,RunLTrappedL() );

    if ( err )

        {

        SomethingInActiveObjectIsLeaving(err);

        }

    }

void CCamcTestClient_6::RunLTrappedL()

    {

    if ( iOpenReady ) 

        {

        iOpenReady = EFalse;

        // Set default parameters. They can be overwritten depending on the test case. 

        iCamc->SetVideoFrameSizeL(TSize(176,144));

        iCamc->SetVideoFrameRateL(TReal32(15));

        iCamc->SetVideoBitRateL(TInt(50000));

        iCamc->SetAudioEnabledL(EFalse); 

        TBool prepare = ETrue;

        switch ( iAction )

            {

            case K_Tc6_SetAudioEnabledLWhenControllerReady :

                {

                iCamc->SetAudioEnabledL( ETrue );	

                break;

                }

            case K_Tc6_SetMaxClipSizeLWhenControllerReady :

                {

                // -55 is invalide size

                iCamc->SetMaxClipSizeL( -55 );	

                // Should have left already

                // Don't go on, to prevent a panic

                User::Leave(K_Tc6_ErrExpectingToLeave);

                break;

                }                

            case K_Tc6_VideoTypeLWhenOpenWithMimeAndNotRecording :   

                {

                TPtrC8 returnedVideoType = iCamc->VideoFormatMimeType();

                TBool found = 0;

                TPtrC8 expectedVideoType[TC6_VIDEO_TYPES_ARRAY_LENGTH] = TC6_VIDEO_TYPES_ARRAY ;

                for (TInt i=0; i<TC6_VIDEO_TYPES_ARRAY_LENGTH ; i++)

                    {

                    if (expectedVideoType[i] == returnedVideoType)

                        {

                        found = 1;

                        }

                    }

                if (!found)

                    {

                    User::Leave(K_Tc6_ErrExpectingADifferentValue);

                    }

                break;

                }

            case K_Tc6_VideoTypeLWhenOpenWithMimeAndNotRecordingNewFormat :   

                {

                TPtrC8 returnedVideoType = iCamc->VideoFormatMimeType();

                TBool found = 0;

                TPtrC8 expectedVideoType[TC6_VIDEO_TYPES_ARRAY_LENGTH_NEW] = TC6_VIDEO_TYPES_ARRAY_NEW ;

                for (TInt i=0; i<TC6_VIDEO_TYPES_ARRAY_LENGTH_NEW ; i++)

                    {

                    if (expectedVideoType[i] == returnedVideoType)

                        {

                        found = 1;

                        }

                    }

                if (!found)

                    {

                    User::Leave(K_Tc6_ErrExpectingADifferentValue);

                    }

                break;

                }

            case K_Tc6_VideoTypeLWhenOpenWithoutSpecifyingVideoTypeAndNotRecording :

            case K_Tc6_VideoTypeLWhenOpenWithNULLAndNotRecording :

                {

                TPtrC8 returnedVideoType = iCamc->VideoFormatMimeType();

                TBool found = 0;

                TPtrC8 expectedVideoType[TC6_VIDEO_TYPES_ARRAY_LENGTH] = TC6_VIDEO_TYPES_ARRAY ;

                for (TInt i=0; i<TC6_VIDEO_TYPES_ARRAY_LENGTH ; i++)

                    {

                    if (expectedVideoType[i] == returnedVideoType)

                        {

                        found = 1;

                        }

                    }

                if (!found)

                    {

                    User::Leave(K_Tc6_ErrExpectingADifferentValue);

                    }

                break;

                }

            case K_Tc6_AudioTypeLWhenOpenWithfourCCAndNotRecording :

            case K_Tc6_AudioTypeLWhenOpenWithoutSpecifyingAudioTypeAndNotRecording :

                {

                TFourCC expectedAudioType = TFourCC( ' ', 'A', 'M', 'R' );

                TFourCC returnedAudioType = iCamc->AudioTypeL(  );

                if (expectedAudioType != returnedAudioType)

                    {

                    User::Leave(K_Tc6_ErrExpectingADifferentValue);

                    }

                break;

                }                           

            case K_Tc6_SetVideoTypeLWhenOpenWithoutSpecifyingVideoTypeAndNotRecording:

                {

                iCamc->SetVideoTypeL( TC6_VIDEO_TYPE );

                break;

                }                

            case K_Tc6_SetVideoTypeLWhenNotRecording :

                {

                iCamc->SetVideoTypeL( TC6_VIDEO_TYPE_WRONG );

                break;

                }               

            case K_Tc6_SetVideoTypeLWithProfile :

                {

                iCamc->SetVideoTypeL( TC6_VIDEO_TYPE_PROFILE0 );

                break;

                }         

            case K_Tc6_SetVideoTypeLWithProfile8 :

                {

                iCamc->SetVideoTypeL( TC6_VIDEO_TYPE_PROFILE8 );

                TPtrC8 returnedVideoType = iCamc->VideoFormatMimeType();

                TBool found = 0;

                TPtrC8 expectedVideoType[TC6_VIDEO_TYPES_ARRAY_LENGTH_NEW] = TC6_VIDEO_TYPES_ARRAY_NEW ;

                for (TInt i=0; i<TC6_VIDEO_TYPES_ARRAY_LENGTH_NEW ; i++)

                    {

                    if (expectedVideoType[i] == returnedVideoType)

                        {

                        found = 1;

                        }

                    }

                if (!found)

                    {

                    User::Leave(K_Tc6_ErrExpectingADifferentValue);

                    }

                break;

                }         

            case K_Tc6_SetVideoTypeLWithProfile3 :

                {

                iCamc->SetVideoTypeL( TC6_VIDEO_TYPE_PROFILE3 );

                TPtrC8 returnedVideoType = iCamc->VideoFormatMimeType();

                TBool found = 0;

                TPtrC8 expectedVideoType[TC6_VIDEO_TYPES_ARRAY_LENGTH_NEW] = TC6_VIDEO_TYPES_ARRAY_NEW ;

                for (TInt i=0; i<TC6_VIDEO_TYPES_ARRAY_LENGTH_NEW ; i++)

                    {

                    if (expectedVideoType[i] == returnedVideoType)

                        {

                        found = 1;

                        }

                    }

                if (!found)

                    {

                    User::Leave(K_Tc6_ErrExpectingADifferentValue);

                    }

                // set CIF size since level = 3

                iCamc->SetVideoFrameSizeL( TC6_CIF_VIDEO_FRAME_SIZE );

                break;

                }         

            case K_Tc6_SetAudioTypeLWhenOpenWithoutSpecifyingAudioTypeAndNotRecording :

                {

                iCamc->SetAudioTypeL( TC6_AUDIO_TYPE );

                break;

                }       

            case K_Tc6_SetAudioTypeLWhenOpenWithfourCCAndNotRecording_AAC :

                {

                iCamc->SetAudioTypeL( TC6_AAC_AUDIO_TYPE );

                break;

                }            

            case K_Tc6_SetAudioTypeLWhenNotRecording :

                {

                iCamc->SetAudioTypeL( TC6_AUDIO_TYPE_WRONG );

                break;

                }

            case K_Tc6_ControllerImplementationInformationWhenOpen:

                { 

                const CMMFControllerImplementationInformation & returnedResult = iCamc->ControllerImplementationInformationL();

                CheckControllerImplementationInformationL ( returnedResult ); 

                break;

                }

            case K_Tc6_ControllerImplementationInformationWhenOpenNew:

                { 

                const CMMFControllerImplementationInformation & returnedResult = iCamc->ControllerImplementationInformationL();

                CheckControllerImplementationInformationNewL ( returnedResult ); 

                break;

                }

            case K_Tc6_ControllerImplementationInformationWhenOpenNew_MPEG4:

                { 

                const CMMFControllerImplementationInformation & returnedResult = iCamc->ControllerImplementationInformationL();

                CheckControllerImplementationInformationNewMPEG4L ( returnedResult ); 

                // set CIF size since level = 3

                iCamc->SetVideoFrameSizeL( TC6_CIF_VIDEO_FRAME_SIZE );

                break;

                }

            case K_Tc6_DurationWhenRecording:

                {

                // Use a more realistic frame rate

                // The duration test is quite affected by AO scheduling.

                iCamc->SetVideoFrameRateL(TReal32(5));

#if ( defined ( __WINS__ ) || defined ( __WINSCW__) )

                // Give some help to the wins case.

                iCamc->SetAudioEnabledL(EFalse); 

#endif

                break;

                }

            default:

                break;

            }

            if ( prepare )           

                {

                iCamc->Prepare();

                }

        }

        else if ( iPrepareReady ) 

            {    

            switch (iAction)

                {

                case K_Tc6_SetAudioEnabledLWhenControllerReady :

                    {

                    //Compare

                    TBool aAudioEnabled;

                    aAudioEnabled = iCamc->AudioEnabledL();

                    //aSetAudioEnable should be the same with previously set

                    if (!aAudioEnabled )

                        {

                        User::Leave(K_Tc6_ErrExpectingADifferentValue);

                        }

                    break;

                    }

                case K_Tc6_SetVideoTypeLWhenOpenWithoutSpecifyingVideoTypeAndNotRecording :

                    //Compare

                    {

                    TPtrC8 returnedSetVideoType = iCamc->VideoFormatMimeType();

                    TBool found = 0;

                    TPtrC8 expectedVideoType[TC6_VIDEO_TYPES_ARRAY_LENGTH] = TC6_VIDEO_TYPES_ARRAY ;

                    for (TInt i=0; i<TC6_VIDEO_TYPES_ARRAY_LENGTH ; i++)

                        {

                        if (expectedVideoType[i] == returnedSetVideoType)

                            {

                            found = 1;

                            }

                        }

                    if (!found)

                        {

                        User::Leave(K_Tc6_ErrExpectingADifferentValue);

                        }

                    break;

                    }                

                case K_Tc6_SetAudioTypeLWhenOpenWithoutSpecifyingAudioTypeAndNotRecording :

                    //Compare

                    {

                    TFourCC returnedSetAudioType;

                    returnedSetAudioType = iCamc->AudioTypeL( );

                    if (returnedSetAudioType != TC6_AUDIO_TYPE)

                        {

                        User::Leave(K_Tc6_ErrExpectingADifferentValue);

                        }

                    break;

                    }               

                case K_Tc6_SetAudioTypeLWhenOpenWithfourCCAndNotRecording_AAC :

                    //Compare

                    {

                    TFourCC returnedSetAudioType;

                    returnedSetAudioType = iCamc->AudioTypeL( );

                    if (returnedSetAudioType != TC6_AAC_AUDIO_TYPE)

                        {

                        User::Leave(K_Tc6_ErrExpectingADifferentValue);

                        }

                    break;

                    }

                case K_Tc6_DurationWhenNotRecording:

                    {

                    TTimeIntervalMicroSeconds aValue = iCamc->DurationL();

                    TTimeIntervalMicroSeconds expected (0);

                    //aValue should always be 0. 

                    if (aValue != expected)

                        {

                        User::Leave(K_Tc6_ErrExpectingADifferentValue);

                        }

                    break;

                    }

                default:

                    break;

                }