/*

* 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 "badesca.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_5::CCamcTestClient_5 () : CTimer(CActive::EPriorityHigh)

    {

    }

CCamcTestClient_5::~CCamcTestClient_5 ()

    {

    Cancel();

    delete iCamc;

    delete iMMFMetaDataEntry;

    }

CCamcTestClient_5* CCamcTestClient_5::NewL()

    {

    CCamcTestClient_5* self = new(ELeave) CCamcTestClient_5;

    CleanupStack::PushL(self);

    self->ConstructL( );

    CleanupStack::Pop(self);

    return self;

    }

void CCamcTestClient_5::ConstructL( )

    {

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

    iOpenReady = EFalse;

    iPrepareReady = EFalse;

    iRecordingReady = EFalse;

    iPaused = EFalse;

    iPrepare2ndTime = EFalse;

    // Construct the MetaDataEntry

    iMMFMetaDataEntry = CMMFMetaDataEntry::NewL();

    CTimer::ConstructL();

    iTimeout = 0;

    iClosed = 0;

    CActiveScheduler::Add(this);

    }

void CCamcTestClient_5::Start_Active_ObjectL ( TestClient5Actions aAction, TInt aCameraHandle )

    {

    iUiLevelCameraHandle = aCameraHandle;

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

    TUid formatUid = {0};

    TUid formatUidG2 = {0x101F86D6};

    TUid formatUidMP4 = {0x101F873D};

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

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

    //	iTimeout = aTimeout;

    iTimeout = 1500000;

     if ( iAction == K_Tc5_StopWhenRecordingAfterOpenFileNew )

        {

        TFileName file;

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

        TRAPD(err,

            iCamc->OpenFileL( file, 

            iUiLevelCameraHandle, 

            controllerUid,

            formatUidG2,

            _L8("video/mp4v-es"),

            TC5_AUDIO_TYPE_1 ));

        if (err)

            {

            User::Leave(99);

            }

        }

    else if ( iAction == K_Tc5_StopWhenRecordingAfterOpenFileNew_MPEG4 )

        {

        TFileName file;

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

        TRAPD(err,

            iCamc->OpenFileL( file, 

            iUiLevelCameraHandle, 

            controllerUid,

            formatUidMP4,

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

            TC5_AUDIO_TYPE_3 ));

        if (err)

            {

            User::Leave(99);

            }

        }

    else

        {       

        TFileName file;

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

        TRAPD(err,

            iCamc->OpenFileL( file, 

            iUiLevelCameraHandle, 

            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_5::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_5::RunLTrappedL()

    {

     if ( iClosed )

        {

        iCamc->Stop();

        CActiveScheduler::Stop();

        return;

        }

    if ( iOpenReady ) 

        {

        iOpenReady = EFalse;

        switch (iAction)

            {

            case K_Tc5_GetPriorityWhenNotSet:

                {

                TInt priority;

                TMdaPriorityPreference pref;

                iCamc->GetPriorityL(priority, pref);

                // Currently we always set priority to KAudioPriorityVideoRecording to avoid problems caused by keypad tones if keys pressed during testing

                if (priority != KAudioPriorityVideoRecording || pref != EMdaPriorityPreferenceTimeAndQuality)

                    {

                    User::Leave(KErrExpectingADifferentValue);

                    }

                break;

                }

            case K_Tc5_VideoFrameRateWhenNotSet:

                {

                TReal32 aValue;

                aValue = iCamc->VideoFrameRateL();

                if (aValue != 15.0)

                    {

                    User::Leave(KErrExpectingADifferentValue);

                    }

                break;

                }

            case K_Tc5_VideoBitRateWhenNotSet:

                {

                TInt aBit;

                aBit = iCamc->VideoBitRateL();

                if (aBit != 64000)

                    {

                    User::Leave(KErrExpectingADifferentValue);

                    }

                break;

                }

            case K_Tc5_AudioBitRateWhenNotSet:

                {

                TInt aAudioBit;

                aAudioBit = iCamc->AudioBitRateL();

                if (aAudioBit <= 0)

                    {

                    User::Leave(KErrExpectingADifferentValue);

                    }

                break;

                }

            case K_Tc5_AudioEnabledWhenNotSet:

                {

                TBool aEnabled;

                aEnabled = iCamc->AudioEnabledL();

                // By default, audio are enabled.

                if ( !aEnabled )

                    {

                    User::Leave(KErrExpectingADifferentValue);

                    }

                break;

                }

            case K_Tc5_GetVideoFrameSizeWhenNotSet:

                {

                TSize aFrame;

                TSize expectedFrameSize(176,144);

                 iCamc->GetVideoFrameSizeL(aFrame);

                 if (aFrame != expectedFrameSize)

                    {

                    User::Leave(KErrExpectingADifferentValue);

                    }

                break;

                }

            case K_Tc5_GainWhenNotSet:

                {

                TInt aGain;

                aGain = iCamc->GainL();

                if ((aGain < 0) || (aGain >= 100))

                    {

                    User::Leave(KErrExpectingADifferentValue);

                    }

                break;

                }

            default:

                break;

            }

        // 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(ETrue); 

        switch (iAction)

            {

            case K_Tc5_NumberOfMetaDataEntriesWhenNotRecording:

                {

                TInt aValue;

                aValue = iCamc->NumberOfMetaDataEntriesL();

                // aValue should always be 0.

                if (aValue != 0)

                    {

                    User::Leave(KErrExpectingADifferentValue);

                    }

                break;

                }

            case K_Tc5_MetaDataEntryWhenNotRecording:

                {

                // Index 2 dosen't exist, should leave

                iCamc->MetaDataEntryL( 2 );

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

                User::Leave(KErrExpectingADifferentValue);

                break;

                }

            case K_Tc5_AddMetaDataEntryWhenNotRecording:

                {

                // 

                iCamc->AddMetaDataEntryL( *iMMFMetaDataEntry );      

                break;

                }

            case K_Tc5_RemoveMetaDataEntryWhenNotRecording:

                {

                // Index 2 dosen't exist, should leave

                iCamc->RemoveMetaDataEntryL( 2 );

                break;

                }

            case K_Tc5_ReplaceMetaDataEntryWhenNotRecording:

                {

                // Index 2 dosen't exist, should leave

                iCamc->ReplaceMetaDataEntryL( 2, *iMMFMetaDataEntry );

                break;

                }

            case K_Tc5_SetPriorityWhenNotRecording:

                {

                // Set Invalid Priority.

                iCamc->SetPriorityL( EMdaPriorityMin-100,EMdaPriorityPreferenceTime );

                break;

                }

            case K_Tc5_SetVideoFrameRateWhenOpenNotPrepared:

                {

                // 

                iCamc->SetVideoFrameRateL( TReal32(TC5_VIDEO_FRAME_RATE_WRONG) );

                break;

                }

            case K_Tc5_SetVideoBitRateWhenOpenNotPrepared:

                {

                // 

                iCamc->SetVideoBitRateL( TC5_VIDEO_BIT_RATE_WRONG );

                break;

                }

            case K_Tc5_SetAudioBitRateWhenOpenNotPrepared:

                {

                // 

                iCamc->SetAudioBitRateL( TC5_AUDIO_BIT_RATE_WRONG );

                break;

                }

            case K_Tc5_SetAudioEnabledWhenOpenNotPrepared:

                {

                // 

                iCamc->SetAudioEnabledL( TC5_AUDIO_ENABLED );

                break; 

                }

            case K_Tc5_SetVideoFrameSizeWhenOpenNotPrepared:

                {

                // 

                iCamc->SetVideoFrameSizeL( TC5_VIDEO_FRAME_SIZE_WRONG );

                break;

                }

            case K_Tc5_SetMaxClipSizeLWhenNotRecording:

                {

                iCamc->SetMaxClipSizeL( -10 ); // A wrong value	              

                break;

                }

            case K_Tc5_SetGainWhenNotRecording:

                {

                // 

                iCamc->SetGainL( 1 );

                break;

                }

            case K_Tc5_SetGainWhenNotRecordingAndSetWrong:

                {

                //

                TInt aSetGain;

                aSetGain = iCamc->MaxGainL();

                RDebug::Print(_L("CCamcTest_5::SetGain2 MaxGain is %d "), aSetGain );

                iCamc->SetGainL( aSetGain+1 );

                break; 

                }

            case K_Tc5_MaxGainWhenNotRecording:

                {

                TInt aGain;

                aGain = iCamc->MaxGainL();

                RDebug::Print(_L("CCamcTest_5::MaxGain MaxGain is %d (Should be 0-100)"), aGain );

                if ((aGain <= 0) || (aGain >= 100))

                    {

                    User::Leave(KErrExpectingADifferentValue);          

                    }

                break;

                }

            case K_Tc5_StopWhenNotRecording:

                {

                iCamc->Stop();

                //iAction = K_Tc5_none;

                break;

                }

            case K_Tc5_StopWhenRecordingAfterOpenFileNew_MPEG4:

                {

                iCamc->SetVideoFrameSizeL( TC5_CIF_VIDEO_FRAME_SIZE );

                break;

                }

            default:

                break;

            }

        iCamc->Prepare();

        }

    else if ( iPrepareReady ) 

        {      

        TBool prepare = ETrue;

        switch (iAction)

            {

            //Compare

            case K_Tc5_SetAudioEnabledWhenOpenNotPrepared:

                {

                TInt aEnabled;

                aEnabled = iCamc->AudioEnabledL();

                TBool ok = TC5_AUDIO_ENABLED; // To avoid a warning.

                if ( ( aEnabled && (!ok) ) || ( (!aEnabled) && ok ) ) 

                    {

                    User::Leave(KErrExpectingADifferentValue);

                    }

                break;

                }

            //Compare

            case K_Tc5_SetGainWhenNotRecording:

                {

                TInt aGain;

                aGain = iCamc->GainL();

                RDebug::Print(_L("CCamcTest_5::SetGain1 Gain is %d (Should be 1)"), aGain );

                // aSetGain should be the same with previously set 

                if (aGain != 1)

                    {

                    User::Leave(KErrExpectingADifferentValue);

                    }

                break;

                }

            case K_Tc5_StopWhenRecordingNewPrepareCorrect:

                {

                if ( iPrepare2ndTime )

                    {

                    // If we are here, the 2nd prepare was ready before the 

                    // 2s timeout ---> Test passed

                    iCamc->Stop();

                    CActiveScheduler::Stop();

                    prepare =EFalse;

                    }

                break;

                }

            case K_Tc5_GetSupportedVideoTypesWhenOpenNotRecording:

                {

                CDesC8ArrayFlat * spprtVideoTypes = new (ELeave) CDesC8ArrayFlat (1);

                CleanupStack::PushL(spprtVideoTypes);

                iCamc->GetSupportedVideoTypesL( *spprtVideoTypes );

                TInt index;

                if (spprtVideoTypes->Count() < 2)

                    {

                    User::Leave(KErrExpectingADifferentValue);

                    }         

                if ( spprtVideoTypes->Find(_L8("video/H263-2000"), index ) == KErrNotFound )

                    {

                    User::Leave(KErrExpectingADifferentValue);

                    }

                if (spprtVideoTypes->Find(_L8("video/H263-2000; profile=0") ,index ) == KErrNotFound )

                    {

                    User::Leave(KErrExpectingADifferentValue);

                    }

                CleanupStack::PopAndDestroy();

                break;                

                }

            case K_Tc5_GetSupportedVideoTypesWhenOpenNotRecordingNew:

                {

                CDesC8ArrayFlat * spprtVideoTypes = new (ELeave) CDesC8ArrayFlat (1);

                CleanupStack::PushL(spprtVideoTypes);

                iCamc->GetSupportedVideoTypesL( *spprtVideoTypes );

                TInt index;

                if (spprtVideoTypes->Count() < 4)

                    {

                    User::Leave(KErrExpectingADifferentValue);

                    }         

                if ( spprtVideoTypes->Find(_L8("video/H263-2000"), index ) == KErrNotFound )

                    {

                    User::Leave(KErrExpectingADifferentValue);

                    }

                if (spprtVideoTypes->Find(_L8("video/H263-2000; profile=0") ,index ) == KErrNotFound )

                    {

                    User::Leave(KErrExpectingADifferentValue);

                    }