/*

* Copyright (c) 2002-2007 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:  Camera Application Engine implementation still capturing, 

*                settings, and view finder methods

*

*/

// INCLUDE FILES

#include <fbs.h>                            // For CFbsBitmap

#include "CaeEngineImp.h"                   // Engine implementation header.

#include "CaeStillQualityLevels.h"          // For still capturing quality levels.

#include "CaeVideoQualityLevels.h"          // Needed just in destructor.

#include "CaeVideoTimes.h"                  // Needed just in destructor.

#include "CaeStillStatesActive.h"                

#ifdef CAE_TEST_VERSION

#include "CaeEngineImpTestErrors.h"         // For TEST_VERSION compilation only

#endif

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "CaeEngineImpStillAndVfTraces.h"

#endif

// ============================ MEMBER FUNCTIONS ===============================

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

// CCaeEngine::NewL

// Two-phased constructor. Calls CCaeEngineImp's NewL().

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

//

EXPORT_C CCaeEngine* CCaeEngine::NewL()

    {

    return CCaeEngineImp::NewL();

    }

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

// CCaeEngineImp::CCaeEngineImp

// Default constructor.

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

//

CCaeEngineImp::CCaeEngineImp(): 

    iZoomMode( EZoomModeDigital ), 

    iExposureMode( CCamera::EExposureAuto ),

    iWhiteBalanceMode( CCamera::EWBAuto ), 

    iFlashMode( CCamera::EFlashNone ),

    iVideoTimesInterval( KVideoTimesIntervalDefault ), 

    iMaxClipSizeInBytes( KMMFNoMaxClipSize ), 

    iMaxClipSizeInBytesPrep( KMMFNoMaxClipSize )

    {

    }

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

// CCaeEngineImp::~CCaeEngineImp

// Destructor.

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

//

CCaeEngineImp::~CCaeEngineImp()

    {

    LOGTEXT( _L( "Cae: CCaeEngineImp::~CCaeEngineImp() entering" ) );

    // Cancels/closes/stops still capturing, video recording, and view finding.

    CancelAllActivities();

    // Delete extension implementations

	iExtension.ResetAndDestroy();

    // Delete the state machine

    // Note: This must be done after destroying extensions because there is some

    // validity checking in the iStillStatesActive destructor.

    delete( iStillStatesActive );

    // Delete interface implementation lists. 

	// Close for each iImplementations before closing 

	// iExtInterfaceImplementationLists.

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

		{

		iExtInterfaceImplementationLists[i].iImplementations->Close();

		delete( iExtInterfaceImplementationLists[i].iImplementations );

		}

	iExtInterfaceImplementationLists.Close();

    // Delete custom interface list items

	iExtCustomInterfaceImplementations.Close();

    delete iVideoType;

    delete iVideoClipFileName;

    // Turn camera power off first, then release camera.

    if ( iCamera ) 

        {

        if ( iReserved ) 

            {

            if ( iPowerOn ) 

                {

                iCamera->PowerOff();

                }

            iCamera->Release();

            }

        }

    delete iVideoFrameSizePrep;

    delete iVideoFrameSize;

    delete iVideoTimes;

    delete iVideoTimesCallback;

    delete iVideoRecorder;

    delete iVideoQualityLevelsCont;

    delete iStillQualityLevelsCont;

    delete iCallbackActive;

    delete iInfo;

    delete iCamera;

	REComSession::FinalClose();

    LOGTEXT( _L( "Cae: CCaeEngineImp::~CCaeEngineImp() returning" ) );

    // For RTRT code coverage analysis.

    // #pragma attol insert _ATCPQ_DUMP(0);

    }

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

// CCaeEngineImp::ConstructL

// Symbian 2nd phase constructor that can leave.

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

//

void CCaeEngineImp::ConstructL( TInt aCameraIndex, TInt aDisplayIndex )

    {

    LOGTEXT2( _L( "Cae: CCaeEngineImp::ConstructL() entering with camera index %d" ), 

    	aCameraIndex );

    OstTrace0( CAMERASRV_PERFORMANCE, CCAEENGINEIMP_CONSTRUCTL, "e_CAM_ENG_INIT 1" );   //CAE_ENGINE_INIT_START

    if ( ( aCameraIndex < 0 ) || 

         ( aCameraIndex >= CCamera::CamerasAvailable() ) )

        {

        LOGTEXT2( _L( "Cae: CCaeEngineImp::ConstructL leaving KErrHardwareNotAvailable, aCameraIndex=%d" ), aCameraIndex );

        User::Leave( KErrHardwareNotAvailable );

        }

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

    TRAPD( err, iCamera = CCamera::New2L( static_cast<MCameraObserver2&>(*this), aCameraIndex, KCameraPriority ) );

    if ( err )

        {

        LOGTEXT2( _L( "Cae: CCaeEngineImp::ConstructL() CCamera::New2L return code=%d" ), err ); 

        // Create old Camera API implementation object.

        iCamera = CCamera::NewL( static_cast<MCameraObserver&>(*this), aCameraIndex );

        LOGTEXT( _L( "Cae: CCaeEngineImp::ConstructL() using MCameraObserver" )); 

        }

    else

        {

        LOGTEXT( _L( "Cae: CCaeEngineImp::ConstructL() using MCameraObserver2" )); 

        }

    // Get camera handle.

    iCameraHandle = iCamera->Handle();

    // Set display index

    iDisplayIndex = aDisplayIndex;

    // Create and initialize info object.

    iInfo = new( ELeave ) TCamAppEngineInfo;

    InitializeInfo( *iCamera );

    // Create active object for calling methods from callbacks.

    iCallbackActive = CCaeCallbackActive::NewL( *this );

    // Create still quality levels container object.

    iStillQualityLevelsCont = CCaeStillQualityLevelsCont::NewL();

    // Set default value for video recording stopping 

    iAsyncVideoStopEnabled = EFalse;

	// Create interface lists. 

	// The order of interface lists in iExtInterfaceImplementationLists

	// should not be changed later as the order must always match to 

	// TCaeExtensionInterfaceIndexes enum.

	for ( TInt i = 0; KCaeSupportedExtensionInterfaceUids[i].iUid != NULL; i++ )

		{

		TCaeExtensionInterfaceImplListItem listItem;

		RArray<TCaeExtensionInterfaceImplItem>* emptyImplementationArray = 

			new(ELeave) RArray<TCaeExtensionInterfaceImplItem>(

			TCaeExtensionInterfaceImplItemGranularity );

		listItem.iInterfaceUid = KCaeSupportedExtensionInterfaceUids[i];

		listItem.iImplementations = emptyImplementationArray; 

		// Copy the list item to the end of the list.Give ownership of 

        // emptyImplementationArray.

        CleanupStack::PushL( emptyImplementationArray );

		iExtInterfaceImplementationLists.AppendL( listItem ); 

        CleanupStack::Pop( emptyImplementationArray );

		}

    // Create the state machine for still capturing

    iStillStatesActive = CCaeStillStatesActive::NewL( *iCamera, *iInfo,

        *( iExtInterfaceImplementationLists[KCaeExtProcessImageInterfaceIndex].iImplementations  ) );

	// Create extensions and populate the extension array 

	PopulateExtensionArrayL();

    OstTrace0( CAMERASRV_PERFORMANCE, DUP1_CCAEENGINEIMP_CONSTRUCTL, "e_CAM_ENG_INIT 0" );  //CAE_ENGINE_INIT_END

    LOGTEXT( _L( "Cae: CCaeEngineImp::ConstructL() returning" ) );

    }

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

// CCaeEngineImp::NewL

// Two-phased constructor.

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

//

CCaeEngineImp* CCaeEngineImp::NewL()

    {

    LOGTEXT( _L( "Cae: CCaeEngineImp::NewL() entering" ) );

    CCaeEngineImp* self = new( ELeave ) CCaeEngineImp();

    CleanupStack::PushL( self );

    self->ConstructL( 0, 0 ); // Construct with default camera index 0 and display index 0

    CleanupStack::Pop( self );

    LOGTEXT( _L( "Cae: CCaeEngineImp::NewL() returning" ) );

    return self;

    }

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

// CCaeEngineImp::PopulateExtensionArrayL

// Get a list of extension implementations via ECom, construct the extensions and 

// add those the the array.

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

//

void CCaeEngineImp::PopulateExtensionArrayL()

	{

	LOGTEXT( _L( "Cae: CCaeEngineImp::PopulateExtensionArrayL() entering" ) );

	// Get a list of all extensions from ECom

	TEComResolverParams resolverParams;

	resolverParams.SetDataType ( KExtensionTypeStringDesc );

	resolverParams.SetWildcardMatch ( EFalse );

	RImplInfoPtrArray implInfoArray;

	REComSession::ListImplementationsL( KExtensionInterfaceUid, resolverParams, 

		implInfoArray );

	// This should be called only after ListImplementationsL

	CleanupResetAndDestroyPushL( implInfoArray ); 

	LOGTEXT2( _L( "Cae: CCaeEngineImp::PopulateExtensionArrayL: extension count: %d" ),

		implInfoArray.Count());

	// Create each extension via ECom and add it to the list 

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

		{		

		MExtension* extension = NULL;

		// Trap the construction as if one extension fails to construct it 

		// should not stop others from constructing

    	LOGTEXT2( _L( "Cae: CCaeEngineImp::PopulateExtensionArrayL: load extension uid=%x" ),

	    	implInfoArray[i]->ImplementationUid().iUid);

		TRAPD( error, extension = MExtension::NewExtensionL( 

			implInfoArray[i]->ImplementationUid(), 

			(MExtensionCallbackInterface*) this ));

		if ( error || !extension)

			{

			// If one extension is failing we skip that.

			#ifdef _DEBUG

			TBuf<256> text;

			text.Format(_L( "Cae: CCaeEngineImp::PopulateExtensionArrayL: NewExtensionL leaved, uid=%x, error=%d, extension=%x" ),

				implInfoArray[i]->ImplementationUid().iUid, error, extension );

			LOGTEXT( text );

			#endif

			delete( extension );

			}

		else

			{

			iExtension.AppendL( extension );

			}

		}

	CleanupStack::PopAndDestroy( &implInfoArray );

	LOGTEXT( _L( "Cae: CCaeEngineImp::PopulateExtensionArrayL() returning" ) );

	}

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

// CCaeEngineImp::SetCamAppEngineObserver

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

//

void CCaeEngineImp::SetCamAppEngineObserver( MCamAppEngineObserver& aObserver )

    {

    LOGTEXT( _L( "Cae: CCaeEngineImp::SetCamAppEngineObserver()" ) );

    iCaeObserver = &aObserver;

    iStillStatesActive->SetCamAppEngineObserver( aObserver );

    }

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

// CCaeEngineImp::GetInfo

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

//

void CCaeEngineImp::GetInfo( TCamAppEngineInfo& aInfo ) const

    {

    LOGTEXT( _L( "Cae: CCaeEngineImp::GetInfo()" ) );

    aInfo = *iInfo;

    }

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

// CCaeEngineImp::InitL

// Initialise the engine for still image capturing using default parameters.

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

//

void CCaeEngineImp::InitL( TBool aCreateSnapImage )

    {

    LOGTEXT( _L( "Cae: CCaeEngineImp::InitL() entering" ) );

    iStillStatesActive->SetSnapImageCreation( aCreateSnapImage );

    // To allow re-initialization, release the camera (first cancels possible 

    // activities and turns camera power off).

    Release();

    // Init to default quality levels.

    iInfo->iNumStillQualityLevelsSupported = 

        iStillQualityLevelsCont->InitDefaultsL();

    // Reserve camera (and after succesfull reserve, camera power will be 

    // turned on).

    iResetToPreviousSettings = ETrue; // This requests here to set the camera

                                      // to default settings after power is on.

    iCamera->Reserve();

    LOGTEXT( _L( "Cae: CCaeEngineImp::InitL() returning" ) );

    }

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

// CCaeEngineImp::InitL

// Initialise the engine for still image capturing either using default 

// parameters or parameters from ini-file.

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

//

void CCaeEngineImp::InitL( 

    TUid aSdUidStillQltyLevels, 

    TBool aCreateSnapImage )

    {

    if( aSdUidStillQltyLevels == KNullUid )

        {

        InitL( aCreateSnapImage );

        }

    else

        {

        LOGTEXT( _L( "Cae: CCaeEngineImp::InitL(aSdUidStillQltyLevels): NOT SUPPORTED, leaving" ) );

        User::Leave( KErrNotSupported );

        }

    }

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

// CCaeEngineImp::Reserve

// Calls Camera API Reserve().

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

//

void CCaeEngineImp::Reserve()

    {

    LOGTEXT( _L( "Cae: CCaeEngineImp::Reserve() entering" ) );

    if ( !iReserved ) 

        {

        iResetToPreviousSettings = ETrue;

        iCamera->Reserve();

        }

    else if ( !iPowerOn ) // in case previous reserve ok, but poweron failed

        {

        PowerOn();

        }

    LOGTEXT( _L( "Cae: CCaeEngineImp::Reserve() returning" ) );

    }

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

// CCaeEngineImp::Release

// Calls Camera API Release().

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

//

void CCaeEngineImp::Release()

    {

    LOGTEXT( _L( "Cae: CCaeEngineImp::Release() entering" ) );

    if ( iReserved ) 

        {

        PowerOff();         // Cancel all activities (if any) and turn power off.

        iCamera->Release(); // Release Camera HW.

        iReserved = EFalse;

        iStillPrepared = EFalse;

        iVideoPrepared = EFalse;

        iVideoOpened = EFalse;

        }

    LOGTEXT( _L( "Cae: CCaeEngineImp::Release() returning" ) );

    }

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

// CCaeEngineImp::PowerOn

// Calls Camera API PowerOn().

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

//

void CCaeEngineImp::PowerOn()

    {

    LOGTEXT( _L( "Cae: CCaeEngineImp::PowerOn() entering" ) );

    if ( iReserved && !iPowerOn ) 

        {

        iCamera->PowerOn();

        }

    LOGTEXT( _L( "Cae: CCaeEngineImp::PowerOn() returning" ) );

    }

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

// CCaeEngineImp::PowerOff

// Calls Camera API PowerOff().

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

//

void CCaeEngineImp::PowerOff()

    {

    LOGTEXT( _L( "Cae: CCaeEngineImp::PowerOff() entering" ) );

    if ( iPowerOn ) 

        {

        CancelAllActivities();

        iCamera->PowerOff();

        iPowerOn = EFalse;

        }

    LOGTEXT( _L( "Cae: CCaeEngineImp::PowerOff() returning" ) );

    }

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

// CCaeEngineImp::SetZoomModeL

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

//

void CCaeEngineImp::SetZoomModeL( 

    TZoomMode aZoomMode )

    {

    LOGTEXT( _L( "Cae: CCaeEngineImp::SetZoomModeL() entering" ) );

    // Currently supporting digital and optical zooms, not EZoomModeOpticalDigital.

    if ( ( aZoomMode != EZoomModeDigital ) && ( aZoomMode != EZoomModeOptical ) )

        {

        LOGTEXT2( _L( "Cae: CCaeEngineImp::SetZoomModeL leaving KErrNotSupported, aZoomMode=%d" ), aZoomMode );

        User::Leave( KErrNotSupported );

        }

    iZoomMode = aZoomMode;

    LOGTEXT( _L( "Cae: CCaeEngineImp::SetZoomModeL() returning" ) );

    }

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

// CCaeEngineImp::ZoomMode

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

//

CCaeEngine::TZoomMode CCaeEngineImp::ZoomMode() const

    {

    LOGTEXT( _L( "Cae: CCaeEngineImp::ZoomMode()" ) );

    return iZoomMode;

    }

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

// CCaeEngineImp::SetZoomValueL

// Calls Camera API SetDigitalZoomFactorL() or SetZoomFactorL().

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

//

void CCaeEngineImp::SetZoomValueL( 

    TInt aZoomValue )

    {

    LOGTEXT( _L( "Cae: CCaeEngineImp::SetZoomValueL() entering" ) );

    CheckPowerL();

    switch ( iZoomMode )

        {

        case EZoomModeDigital:

            // Leave if zoom factor is out of range.