/*

* Copyright (c) 2006 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:  Videoteleng  Camera Preferences extension

*

*/

// INCLUDE FILES

#include    "CVtEngCameraPreferences.h"

#include    "VtEngPanic.h"

#include    "CVtEngSettings.h"

#include    "VtEngUtils.h"

#include    "mvtengcamerapreferencesobserver.h"

#include    <capivideosource.h>

#include    <cvtlogger.h>

// LOCAL CONSTANTS AND MACROS

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

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

// CVtEngCameraPreferences::CVtEngCameraPreferences

// C++ constructor can NOT contain any code, that

// might leave.

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

//

CVtEngCameraPreferences::CVtEngCameraPreferences():

                        CVtEngExtensionBase(

                        KVtEngExtensionCameraPreferences )

    {

    }

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

// CVtEngCameraPreferences::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CVtEngCameraPreferences::ConstructL()

    {

    __VTPRINTENTER( "CVtEngCameraPreferences.ConstructL" )

    __VTPRINTEXIT( "CVtEngCameraPreferences.ConstructL" )

    }

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

// CVtEngCameraPreferences::NewL

// Two-phased constructor.

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

//

CVtEngCameraPreferences* CVtEngCameraPreferences::NewL()

    {

    CVtEngCameraPreferences* self = new( ELeave ) CVtEngCameraPreferences;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

// CVtEngCameraPreferences::~CVtEngCameraPreferences

// Destructor. Cannot leave.

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

//

CVtEngCameraPreferences::~CVtEngCameraPreferences()

    {

    __VTPRINTENTER( "CameraPreferences.~" )

    if ( iObserver )

        {

        iObserver->Detach( *this );

        }

    __VTPRINTEXIT( "CameraPreferences.~" )

    }

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

// CVtEngCameraPreferences::GetInterface

//

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

//

TAny* CVtEngCameraPreferences::GetInterface()

    {

    __VTPRINTENTER( "CameraPreferences.GetInterface")

    // Cast first as API MVtEngCameraPreferences* class

    // and after that to TAny*

    __VTPRINTEXIT( "CameraPreferences.GetInterface" )

    return reinterpret_cast< TAny* >( ( MVtEngCameraPreferences* ) this );

    }

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

// CVtEngCameraPreferences::HandleL

//

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

//

TBool CVtEngCameraPreferences::HandleL( CVtEngOperation* aOp )

    {

    __VTPRINTENTER( "CameraPreferences.HandleL" )

    const TVtEngCommandId id( aOp->Command() );

    __VTPRINT2( DEBUG_GEN, "CVtEngCameraPreferences.HandleL CMD ID[%d] ", id )

    // Check provider

    if ( iProvider == NULL )

        {

        __VTPRINTEXITR( "CVtEngCameraPreferences.HandleL iProvider [%d]",

                	( TInt )iProvider )

        User::Leave( KErrNotReady );

        }

    // Check which command and call

    // active provider with operation params

    switch ( id )

        {

        case KVtEngSetContrast:

        	{

        	TInt contrast = 0;

        	TVtEngOpParamUtil< TInt >::Set( contrast, *aOp );

            iProvider->SetContrastL( contrast );

            if ( iObserver )

                {

                iObserver->ContrastUpdated( contrast );

                }

            break;

        	}

        case KVtEngSetBrightness:

            {

     		TInt brightness = 0;

        	TVtEngOpParamUtil< TInt >::Set( brightness, *aOp );

            iProvider->SetBrightnessL( brightness );

            if ( iObserver )

                {

                iObserver->BrightnessUpdated( brightness );

                }

            break;

            }

        case KVtEngSetWhiteBalance:

            {

            CCamera::TWhiteBalance whitebalance = CCamera::EWBAuto;

        	TVtEngOpParamUtil< CCamera::TWhiteBalance >::Set( whitebalance,

        		*aOp );

            iProvider->SetWhiteBalanceL( whitebalance );

            if ( iObserver )

                {

                iObserver->WhiteBalanceUpdated( TWhiteBalance( whitebalance ) );

                }

            break;

            }

        case KVtEngSetColorTone:

            {

            CCamera::CCameraImageProcessing::TEffect colortone =

            	CCamera::CCameraImageProcessing::EEffectNone;

        	TVtEngOpParamUtil< CCamera::CCameraImageProcessing::TEffect >::Set(

        		colortone, *aOp );

            iProvider->SetColorToneL( colortone );

            if ( iObserver )

                {

                iObserver->ColorToneUpdated( TColorTone( colortone ) );

                }

            break;

            }

        //Not supported command

        default:

            __VTPRINTEXITR(

            "CVtEngCameraPreferences.HandleL NOT SUPPORTED CMD[%d]", id )

            return EFalse;

        }

    __VTPRINTEXIT( "CameraPreferences.HandleL" )

    return ETrue;

    }

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

// CVtEngCameraPreferences::ValidateCommand

//

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

TBool CVtEngCameraPreferences::ValidateCommand(

	const TVtEngCommandId aCommandId )

    {

    __VTPRINTENTER( "CameraPreferences.ValidateCommand" )

    // Check provider

    if ( iProvider == NULL )

        {

        __VTPRINTEXITR(

        	"CVtEngCameraPreferences.ValidateCommand iProvider [%d]",

        	( TInt ) iProvider)

        return EFalse;

        }

    // Take provider info is needed down below

    TVSDataProviderInfo info;

    iProvider->ProviderInfo( info );

    // local or hw support

    // set as False

    TBool hworlocalsupport = EFalse;

    // Check which command and check if

    // if provider and local variation supports

     __VTPRINT2( DEBUG_GEN,

     	"CVtEngCameraPreferences.ValidateCommand CMD ID[%d] ", aCommandId )

    switch ( aCommandId )

        {

        case KVtEngSetContrast:

	        {

            if ( info.iOptionsSupported & TCameraInfo::EContrastSupported  )

                {

                hworlocalsupport = ETrue;

                }

            break;

	        }

        case KVtEngSetBrightness:

            {

            if ( info.iOptionsSupported & TCameraInfo::EBrightnessSupported )

                {

                hworlocalsupport = ETrue;

                }

            break;

            }

        case KVtEngSetWhiteBalance:

            {

            if ( info.iWhiteBalanceModesSupported != CCamera::EWBAuto )

                {

                hworlocalsupport = ETrue;

                }

            break;

            }

        case KVtEngSetColorTone:

            {

            if ( info.iSupportedColorTones !=

            	CCamera::CCameraImageProcessing::EEffectNone )

                {

                hworlocalsupport = ETrue;

                }

            break;

            }

        // Not supported command

        default:

        	{

            __VTPRINT2( DEBUG_GEN,

            	"CVtEngCameraPreferences.ValidateCommand NOT SUPPORTED CMD[%d]",

            	 aCommandId)

            hworlocalsupport = EFalse;

        	}

        }

    __VTPRINTEXITR( "CVtEngCameraPreferences.ValidateCommand return value[%d]",

    	hworlocalsupport)

    return hworlocalsupport;

    }

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

// CVtEngCameraPreferences::GetColorTone

//

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

//

TInt CVtEngCameraPreferences::GetColorTone(

	MVtEngCameraPreferences::TColorTone& aColortone ) const

    {

    __VTPRINTENTER( "CameraPreferences.GetColorTone" )

    if ( iProvider == NULL )

        {

        __VTPRINTEXITR( "CVtEngCameraPreferences.GetColorTone iProvider[%d]",

        	 ( TInt )iProvider)

        return KErrNotReady;

        }

    TInt error;

    CCamera::CCameraImageProcessing::TEffect colortone;

    error = iProvider->GetColorTone( colortone );

    aColortone = ( MVtEngCameraPreferences::TColorTone ) colortone;

    __VTPRINTEXITR( "CameraPreferences.GetColorTone error [%d]",error )

    return error;

    }

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

// CVtEngCameraPreferences::GetSupportedColorTones

//

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

//

TInt CVtEngCameraPreferences::GetSupportedColorTones(

	TUint32& aSupportedColorTones ) const

    {

    __VTPRINTENTER( "CameraPreferences.GetSupportedColorTones" )

    if ( iProvider == NULL )

        {

        __VTPRINTEXITR(

        	"CVtEngCameraPreferences.GetSupportedColorTones iProvider[%d]",

        	( TInt )iProvider)

        return KErrNotReady;

        }

    TVSDataProviderInfo info;

    iProvider->ProviderInfo( info );

    aSupportedColorTones = info.iSupportedColorTones;

    __VTPRINTEXITR( "CameraPreferences.GetSupportedColorTones [%b]",

    	info.iSupportedColorTones)

    return KErrNone;

    }

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

// CVtEngCameraPreferences::GetWhiteBalance

//

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

//

TInt CVtEngCameraPreferences::GetWhiteBalance(

	MVtEngCameraPreferences::TWhiteBalance& aWhiteBalance ) const

    {

    __VTPRINTENTER( "CameraPreferences.GetWhiteBalance" )

    if ( iProvider == NULL )

        {

        __VTPRINTEXITR(

        	"CVtEngCameraPreferences.GetWhiteBalance iProvider [%d]",

        	( TInt )iProvider )

        return KErrNotReady;

        }

    TInt error;

    CCamera::TWhiteBalance whitebalance;

    error = iProvider->GetWhiteBalance( whitebalance );

    aWhiteBalance = (MVtEngCameraPreferences::TWhiteBalance) whitebalance;

	__VTPRINTEXITR( "CameraPreferences.GetWhiteBalance error [%d]",error )

    return error;

    }

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

// CVtEngCameraPreferences::GetSupportedWhiteBalanceModes

//

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

//

TInt CVtEngCameraPreferences::GetSupportedWhiteBalanceModes(

	TUint32& aWhiteBalance  ) const

    {

    __VTPRINTENTER( "CameraPreferences.GetSupportedWhiteBalanceModes" )

    if ( iProvider == NULL )

        {

        __VTPRINTEXITR(

        	"CVtEngCameraPreferences.GetSupportedWhiteBalanceModes iProvider [%d]",

        	( TInt )iProvider)

        return KErrNotReady;

        }

    TVSDataProviderInfo info;

    iProvider->ProviderInfo( info );

    aWhiteBalance = info.iWhiteBalanceModesSupported;

    __VTPRINTEXITR( "CameraPreferences.GetSupportedWhiteBalanceModes [%b]",

    	info.iWhiteBalanceModesSupported)

    return KErrNone;

    }

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

// CVtEngCameraPreferences::GetBrightness

//

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

//

TInt CVtEngCameraPreferences::GetBrightness( TInt& aBrightness  ) const

    {

    __VTPRINTENTER( "CameraPreferences.GetBrightness" )

    if ( iProvider == NULL )

        {

        __VTPRINTEXITR( "CVtEngCameraPreferences.GetBrightness iProvider [%d]",

        	( TInt )iProvider)

        return KErrNotReady;

        }

    TInt error;

    error = iProvider->GetBrightness( aBrightness );

	__VTPRINTEXITR( "CameraPreferences.GetBrightness error [%d]",error )

    return error;

    }

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

// CVtEngCameraPreferences::GetContrast

//

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

//

TInt CVtEngCameraPreferences::GetContrast( TInt& aContrast  ) const

    {

    __VTPRINTENTER( "CameraPreferences.GetContrast" )

    if ( iProvider == NULL )

        {

        __VTPRINTEXITR( "CVtEngCameraPreferences.GetContrast iProvider [%d]",

        	( TInt )iProvider)

       	return KErrNotReady;

        }

    TInt error;

    error = iProvider->GetContrast( aContrast );

	__VTPRINTEXITR( "CameraPreferences.GetContrast error [%d]",error )

    return error;

    }

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

// CVtEngCameraPreferences::SetProvider

//

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

//

void CVtEngCameraPreferences::SetProvider( CVSDataProvider* aProvider,

    MVtEngCameraPreferencesObserver& aObserver )

    {

    __VTPRINTENTER( "CameraPreferences.SetProvider" )

    if ( iObserver )

        {

        iObserver->Detach( *this );

        iObserver = NULL;

        }

    iProvider = aProvider;

    iObserver = &aObserver;

    if ( iObserver )

        {

        iObserver->Attach( *this );

        }

    __VTPRINTEXIT( "CameraPreferences.SetProvider" )

    }

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

// CVtEngCameraPreferences::Detach

//

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

//

void CVtEngCameraPreferences::Detach( MVtEngCameraPreferencesObserver&

    aObserver )

    {

    __VTPRINTENTER( "CameraPreferences.Detach" )

    if ( iObserver == &aObserver )

        {

        iObserver = NULL;

        }

    __VTPRINTEXITR( "CameraPreferences.Detach $%x", TInt( iObserver ) )

    }

//  End of File