/*

* 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 API extension configuration

*

*/

// INCLUDE FILES

#include    "CVtEngExtensions.h"

#include    "VtEngPanic.h"

#include    "VtEngUtils.h"

#include    "CVtEngOperation.h"

#include 	"CVtEngMediaHandler.h"

#include    "CVtEngCameraPreferences.h"

#include 	"cvtengrecord2file.h"

#include    <cvtlogger.h>

// LOCAL CONSTANTS AND MACROS

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

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

// CVtEngExtensions::CVtEngExtensions

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

// might leave.

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

//

CVtEngExtensions::CVtEngExtensions(): 

                  iExtensionArray( KExtensionGranularity )

    {

    }

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

// CVtEngExtensions::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CVtEngExtensions::ConstructL()

    {

    __VTPRINTENTER( "Extensions.ConstructL" )

    __VTPRINTEXIT( "Extensions.ConstructL" )

    }

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

// CVtEngExtensions::NewL

// Two-phased constructor.

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

//

CVtEngExtensions* CVtEngExtensions::NewL()

    {

    CVtEngExtensions* self = new( ELeave ) CVtEngExtensions;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

// CVtEngExtensions::~CVtEngExtensions

// Destructor. Cannot leave.

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

//

CVtEngExtensions::~CVtEngExtensions()

    {

    __VTPRINTENTER( "Extensions.~" )

    // Clean and destroy pointer array 

    iExtensionArray.ResetAndDestroy();

    __VTPRINTEXIT( "Extensions.~" )

    }

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

// CVtEngExtensions::CreateExtensions

// 

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

//

CVtEngExtensionBase* CVtEngExtensions::CreateExtensionsL( const TUid& aUid,

	CVtEngMediaHandler& aHandler)

    {

    __VTPRINTENTER( "Extensions.CreateExtensions" )

    // init local variables

    TInt error = KErrNotSupported;

    CVtEngExtensionBase* extension = NULL;

    // Check if supported UID

    if ( aUid == KVtEngExtensionCameraPreferences  || 

    	aUid == KVtEngExtensionRecord2File )

   		{  		

   		// Create extension	

        extension = aHandler.CreateExtensionsL( aUid );        

        // Push it to clean up stack because 

        // it needs to be append in to

        // array and it can be failed

        CleanupStack::PushL( extension );

        // append extension in to array             

        error = iExtensionArray.Append(extension);

        if ( error != KErrNone )

            {

            // if append fails

            // clear clean up stack and leave 

            __VTPRINTEXITR( 

            	"Extensions.CreateExtensions iExtension.Append failed %d",

            	 error )

            CleanupStack::PopAndDestroy();

            User::Leave( error );

            }

        // append succesful

        // pop extension from clena up stack and return     

        __VTPRINTEXITR( 

        	"Extensions.CreateExtensions iExtension UID[%d] succesfully Appended",

        	 aUid.iUid)     

        CleanupStack::Pop();

        return extension;    

   		}

   	// not supported UID	

   	// leave with error

   	else

   		{

   		__VTPRINTEXITR( 

   			"Extensions.CreateExtensions Extension NOTSUPPORTED UID%d",

   			 aUid.iUid )

        User::Leave( error );

        return extension;

   		}

    }

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

// CVtEngExtensions::GetClientInterface

// 

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

//

TInt CVtEngExtensions::GetClientInterface( TAny** aInterfacePtr, 

	const TUid& aUid , CVtEngMediaHandler& aHandler)

    {

    __VTPRINTENTER( "Extensions.GetClientInterface" )

   	// if aInterfacePtr pointer is NULL -> panic

   	__ASSERT_ALWAYS( aInterfacePtr,Panic( EVtEngPanicInvalidPointer ) );

	// init local variables

    CVtEngExtensionBase* extension = NULL;

    TInt error = KErrGeneral;

    // initialize IF pointer to be NULL

    // if correct extension API IF is found

    // then changed to valid pointer

    *aInterfacePtr = NULL;

    // Check if extension is allready in pointer array

    TInt index = LookupExtensions( aUid );

    if ( index != KErrNotFound )

        {

        *aInterfacePtr = iExtensionArray[index]->GetInterface();

        __VTPRINTEXITR( "Extensions.GetClientInterface error [%d]", KErrNone ) 

        return KErrNone;

        }

    // Create extension   

    else

        {

        TRAP( error, extension = CreateExtensionsL( aUid, aHandler ) );

        if ( extension && error == KErrNone )

            {

            *aInterfacePtr = extension->GetInterface();

            error = KErrNone;   

            }  

        __VTPRINTEXITR( "Extensions.GetClientInterface error [%d]", error )

        return error;       

        }

    }

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

// CVtEngExtensions::LookupExtensions

// 

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

//

TInt CVtEngExtensions::LookupExtensions( const TUid& aUid) const

    {

    __VTPRINTENTER( "Extensions.LookupExtensions" )

    TInt index( iExtensionArray.Count() );

    // Loop whole extension array

    while( index-- )

        {

        // If matches in one of arrays UIDs        

        if( aUid == iExtensionArray[index]->Uid() )

            {

            __VTPRINTEXITR( "Extensions.LookupExtensions index [%d]", index) 

            return index;

            }

        }   

    __VTPRINTEXITR("Extensions.LookupExtensions Not Found index [%d]",

    	KErrNotFound)   

    return KErrNotFound; 

    }

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

// CVtEngExtensions::OfferOperationL

// 

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

//

TBool CVtEngExtensions::OfferOperationL( CVtEngOperation* aOp )

    {   

    __VTPRINTENTER( "Extensions.OfferOperationL" )

    TInt index( iExtensionArray.Count() );

    // Format cmdComleted as false

    TBool cmdCompleted = EFalse;

    // Offer operation to all extension in array

    while( index-- )

        {

        // If valid extension found

        if ( iExtensionArray[index]->HandleL( aOp ) )

            {

            cmdCompleted = ETrue;

            break;

            }

        }

    __VTPRINTEXITR( "Extensions.OfferOperationL cmdCompleted [%d]",

    	cmdCompleted)  

    return cmdCompleted;

    }    

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

// CVtEngExtensions::ValidateCommand

// 

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

//        

TBool CVtEngExtensions::ValidateCommand( const TVtEngCommandId aCommandId )

    {

    __VTPRINTENTER( "Extensions.ValidateCommand" )

     TInt index( iExtensionArray.Count() );

    // Format oKToPerform as false

    TBool oKToPerform = EFalse;

    // Try validate command in all extensions in array

    while( index-- )

        {

        // If valid extension found

        if ( iExtensionArray[index]->ValidateCommand( aCommandId ) )

            {

            oKToPerform = ETrue;

            break;

            }

        }

    __VTPRINTEXITR( "Extensions.ValidateCommand oKToPerform [%d]",

    	oKToPerform)

    return oKToPerform;

    }    

//  End of File