/*

* 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_7.h"

#include "camctest.h"

#include <AudioPreference.h>

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES 

// CONSTANTS

// MACROS

#ifdef _DEBUG

#include <e32svr.h>

#define PRINT(x) RDebug::Print x

#else

#define PRINT(x)

#endif

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

CCamcTestClient_7::CCamcTestClient_7 () : CTimer(CActive::EPriorityHigh)

    {

    }

CCamcTestClient_7::~CCamcTestClient_7 ()

    {

    Cancel();

    delete iWaitScheduler;

    delete iCamc;   

    iCamc = NULL;

    delete iCamera;

    iCamera= NULL;

    delete iCamera2;

    iCamera2= NULL;

    }

CCamcTestClient_7* CCamcTestClient_7::NewL()

    {

    CCamcTestClient_7* self = new(ELeave) CCamcTestClient_7;

    CleanupStack::PushL(self);

    self->ConstructL( );

    CleanupStack::Pop(self);

    return self;

    }

void CCamcTestClient_7::ConstructL( )

    {

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

    // It takes some time to free the camera.

    // Wait that it is free.

    TInt err;

    do

        {

        // Create a new Camera API implementation object, if supported

        TRAP( err, iCamera = CCamera::New2L( static_cast<MCameraObserver2&>(*this), 0 /*index*/, 0 /*Priority*/ ) );

        if ( err == KErrNotSupported )

            {

            PRINT( ( _L( "CCamcTestClient_7::ConstructL() CCamera::New2L return code=%d" ), err ) ); 

            // Create old Camera API implementation object.

            TRAP( err, iCamera = CCamera::NewL( static_cast<MCameraObserver&>(*this), 0 /*Index*/ ) );

            }

        else if ( !err )

            {

            PRINT( ( _L( "CCamcTestClient_7::ConstructL() using new MCameraObserver2" )) ); 

            }

        }

        while (err != KErrNone);

    iOpenReady = EFalse;

    iPrepareReady = EFalse;

    iRecordingReady = EFalse;

    iPaused = EFalse;

    CTimer::ConstructL();

    iTimeout = 0;

    iClosed = 0;

    CActiveScheduler::Add(this);

    }

void CCamcTestClient_7::Start_Active_ObjectL ( TestClient_7_Actions aAction )

    {

    // This reserve the camera, starts the active object.

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

    //	iTimeout = aTimeout;

    iTimeout = (TInt) 1E6; /* 1 Second */

    iWaitScheduler = new (ELeave) CActiveSchedulerWait;	

    // Reserve the Camera.

    iCamera->Reserve();

	iWaitScheduler->Start();

    RDebug::Print(_L("CamcTest_7::Start_Active_ObjectL PowerOn Completed starting CActiveScheduler") );

    CActiveScheduler::Start();

    // The Active Scheduler has finished.

    // Any Errors?

    if (iError)

        {

        RDebug::Print(_L("CamcTest_7::Start_Active_ObjectL leaves with %d"), iError);

        User::Leave(iError);

        }

    }

void CCamcTestClient_7::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 )

        {

        RDebug::Print(_L("CamcTest_7::RunTrappedL leaves with %d"), err);

        SomethingInActiveObjectIsLeaving(err);

        }

    }

void CCamcTestClient_7::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(ETrue); 

        RDebug::Print(_L("iCamc->Prepare1"));

        iCamc->Prepare();

        }

    else if ( iPrepareReady ) 

        {

        RDebug::Print(_L("iCamc->Record1"));

        iPrepareReady = EFalse;

        iCamc->Record();

        CTimer::After( iTimeout );

        }

    else if ( iRecordingReady )

        {

        RDebug::Print(_L("CamcTest_7::RunTrapped iRecordingReady") );

        iRecordingReady = EFalse;

        iClosed=1;

        }

    else if ( iPaused ) //resume

        {

        RDebug::Print(_L("iCamc->Record1"));

        iPaused = EFalse;

        iCamc->Record();

        }

    else //timer

        {

        switch(iAction)

            {

            case K_Tc7_ReleaseCameraWhileRecording:

                {

                // We are now recording

                iCamera->Release();

                iAction = K_Tc7_none;

                CTimer::After( (TInt) 10E6 );

                break;

                }

            case K_Tc7_PowerOffCameraWhileRecording:

                {

                // We are now recording

                RDebug::Print(_L("Powering off the camera"));

                iCamera->PowerOff();

                iAction = K_Tc7_none;  

                CTimer::After( (TInt) 20E6 );

                break;

                }

            case K_Tc7_ReleaseCameraCloseRecorderUseCamera:

                {

                // We are now recording

                switch(iCameraReleasedState)

                    {       

                    case ENothingReleased:

                        {

                        iCamera->Release();

                        CTimer::After( (TInt) 1E6 );

                        iCameraReleasedState = ECameraReleased;

                        break;    

                        }

                    case ECameraReleased:

                        {

                        iCamc->Close();   

                        CTimer::After( (TInt) 1E6 );

                        iCameraReleasedState = ECamcStopped;

                        break;                   

                        }

                    case ECamcStopped:

                        {

                        // Try to use the camera   

                        // Create a new Camera API implementation object, if supported

                        TRAPD( err, iCamera2 = CCamera::New2L( static_cast<MCameraObserver2&>(*this), 0 /*index*/, 0 /*Priority*/ ) );

                        if ( err )

                            {

                            PRINT( ( _L( "CCamcTestClient_7::RunLTrappedL() CCamera::New2L return code=%d" ), err ) ); 

                            // Create old Camera API implementation object.

                            iCamera2 = CCamera::NewL( static_cast<MCameraObserver&>(*this), 0 /*Index*/ );

                            }

                        else 

                            {

                            PRINT( ( _L( "CCamcTestClient_7::RunLTrappedL() using new MCameraObserver2" )) ); 

                            }

                        iCamera2->Reserve();

                        iAction = K_Tc7_none;

                        break;

                        }

                    default:

                        break;

                    }

                break;

                }

            default:

                {

                RDebug::Print(_L("CamcTest_7::RunTrappedL default"));

                iCamc->Close();

                // Simulates that iRecording has been completed through the 

                // MvruoRecordComplete callback

                iRecordingReady=ETrue;	

                iCamera->Release();

                CTimer::After( (TInt) 1E6 );

                }

            }

        }

    if ( iClosed )

        {

        RDebug::Print(_L("CamcTest_7::RunTrappedL iClosed"));

        iCamc->Close();

        CActiveScheduler::Stop();

        }

    }

void CCamcTestClient_7::DoCancel()

    {

    RDebug::Print(_L("CamcTest_7::DoCancel") );

    iCamc->Stop();

    iCamc->Close();

    //delete iCamc;

    //iCamc = NULL;

    }

////////////////////////////////////////////////////////

// MVideoRecorderUtilityObserver Callback functions

void CCamcTestClient_7::MvruoOpenComplete( TInt aError )

    {

    if (aError)

        {

        RDebug::Print(_L("CamcTest_7::MvruoOpenComplete leaves with %d"), aError );        

        SomethingInActiveObjectIsLeaving(aError);

        }

    else

        {

        iOpenReady = ETrue;

        RunL(); // RunL is trapped, cannot actually leave.

        }

    }

void CCamcTestClient_7::MvruoPrepareComplete( TInt aError )

    {    

    if (aError)

        {

         RDebug::Print(_L("CamcTest_7::MvruoPrepareComplete leaves with %d"), aError );

         SomethingInActiveObjectIsLeaving(aError);

        }

    else

        {

        iPrepareReady = ETrue;

        RunL(); // RunL is trapped, cannot actually leave.

        }

    }

void CCamcTestClient_7::MvruoRecordComplete( TInt aError )

    {

    if (aError)

        {

         RDebug::Print(_L("CamcTest_7::MvruoRecordComplete leaves with %d"), aError );

         SomethingInActiveObjectIsLeaving(aError);

        }

    else

        {

        iRecordingReady = ETrue;

        RunL(); // RunL is trapped, cannot actually leave.

        }

    }

void CCamcTestClient_7::MvruoEvent(const TMMFEvent& /*aEvent*/) 

    {

    /* Should be never called ... */  

    SomethingInActiveObjectIsLeaving(99);

    }

////////////////////////////////////////////////////////

// MCameraObserver Callback functions

void CCamcTestClient_7::ReserveComplete(TInt aError)

    {

    // The Camera is now reserved for us.

    if (aError)

        {

            SomethingInActiveObjectIsLeaving(aError);  

        }

    if (iCamera2 && iWaitScheduler->IsStarted())

        {

        iCamera2->PowerOn();

        }

    else if (iCamera && iWaitScheduler->IsStarted())

        {

        iCamera->PowerOn();

        }

    }

void CCamcTestClient_7::PowerOnComplete(TInt aError)

    {

    if (aError)

        {

        SomethingInActiveObjectIsLeaving(aError);

        }

    if (iWaitScheduler->IsStarted())

	    {

    	 iWaitScheduler->AsyncStop();

    	}  

    // If no errors, continue tests.

    switch(iAction)

        {

        case K_Tc7_ReleaseCameraWhileRecording:

        case K_Tc7_PowerOffCameraWhileRecording: 

        case K_Tc7_ReleaseCameraCloseRecorderUseCamera:

            {

            RDebug::Print(_L("CamcTest_7::case1 OpenFileL in"));

            // Start the Camcorder.

            TUid controllerUid = {TC7_CONTROLLER_UID};	

            TUid formatUid = {TC7_VIDEO_FORMAT_UID};

            TFileName file;

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

            TRAPD(err, iCamc->OpenFileL(

                file,	                     	// File

                iCamera->Handle(),				//CameraHandle

                controllerUid,					//Controller UID

                formatUid						//Format UID

                ));

            if (err)

                {

                RDebug::Print(_L("CamcTest_7::case1 OpenFileL leaves with %d"), err); //FIXME

                SomethingInActiveObjectIsLeaving(err);

                }

            RDebug::Print(_L("CamcTest_7::case1 OpenFileL out"));

            break;

            }

        case K_Tc7_OpenFileWhenCameraIsNotAvailable:

            {  

            // Start the Camcorder.

            TUid controllerUid = {TC7_CONTROLLER_UID};	

            TUid formatUid = {TC7_VIDEO_FORMAT_UID};

            RDebug::Print(_L("CamcTest_7::case2 OpenFileL in"));

            TFileName file;

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

            TRAPD(err, iCamc->OpenFileL(

                file,	

                0,			    // CameraHandle = 0 ==> Get a valid camera

                                // There shouldn't be any left.

                controllerUid,					

                formatUid						

                ));

            if (err)

                {

                RDebug::Print(_L("CamcTest_7::case2 OpenFileL leaves with %d"), err); //FIXME

                SomethingInActiveObjectIsLeaving(err);

                }

            RDebug::Print(_L("CamcTest_7::case2 OpenFileL out"));

            break;

            }

        case K_Tc7_OpenFileWithVideoFormatNULL :

            {

            // Start the Camcorder.

            TUid controllerUid = {TC7_CONTROLLER_UID};	

            TFileName file;

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

            TRAPD(err, iCamc->OpenFileL(

                file,	

                 iCamera->Handle(),			 

                controllerUid,					

                KNullUid	  // VideoFormat NULL					

                ));

            if (err)

                {

                    SomethingInActiveObjectIsLeaving(err);

                }

            break;

            }

        default:

            CTimer::After( (TInt) 1E6 );   

        }

    }

void CCamcTestClient_7::ViewFinderFrameReady(CFbsBitmap& /*aFrame*/)

    {    

    // do nothing Here

    }

void CCamcTestClient_7::ImageReady(CFbsBitmap* /*aBitmap */,HBufC8* /*aData*/,TInt aError)

    {

    if (aError)

        {

        SomethingInActiveObjectIsLeaving(aError);

        }

    // If no errors, do nothing

    }

void CCamcTestClient_7::FrameBufferReady(MFrameBuffer* /*aFrameBuffer*/,TInt aError )

    {

    if (aError)

        {

        SomethingInActiveObjectIsLeaving(aError);

        }

    // If no errors, do nothing

    }

void CCamcTestClient_7::SomethingInActiveObjectIsLeaving (TInt aError)

    {

    // Something in the active object is leaving

    // or a fatal error has been found.

    // Stop the active object scheduler.

        iError=aError;

        iCamc->Stop();

        CActiveScheduler::Stop();

    }

// -----------------------------------------------------------------------------

// CCamcTestClient_7::HandleEvent

// MCameraObserver2 call-back handler

// -----------------------------------------------------------------------------

//

void CCamcTestClient_7::HandleEvent( const TECAMEvent& aEvent)

    {

    PRINT(( _L( "CCamcTestClient_7::HandleEvent() entering, type=%x, err=%d" ), aEvent.iEventType.iUid, aEvent.iErrorCode ));

    if ( aEvent.iEventType == KUidECamEventCameraNoLongerReserved )

        {

        PRINT(( _L( "CCamcTestClient_7::HandleEvent() KUidECamEventCameraNoLongerReserved" ) ));

        }

    else if ( aEvent.iEventType == KUidECamEventPowerOnComplete )

        {

        PRINT(( _L( "CCamcTestClient_7::HandleEvent() KUidECamEventPowerOnComplete" ) ));

        PowerOnComplete( aEvent.iErrorCode );

        }

    else if ( aEvent.iEventType == KUidECamEventReserveComplete )

       {

       PRINT(( _L( "CCamcTestClient_7::HandleEvent() KUidECamEventReserveComplete" ) ));