/*

* Copyright (c) 2004 - 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:  Class for initializing the engine gradually.

*                Active object initializes one "subsystem" on each

*                round. In case of failure timer is started and

*                retrial is done after time-out. Uninitialization

*                is done is one shot.

*

*/

#ifndef CVTENGINITIALIZER_H

#define CVTENGINITIALIZER_H

//  INCLUDES

#include    "MVtEngSettingObserver.h"

#include    <e32base.h>

#include    <mvtprotocolhandler.h>

// FORWARD DECLARATIONS

class CVtEngHandlerContainer;

class CVtEngOperation;

/**

*  Engine initializer.

*

*  @lib videoteleng

*  @since 2.6

*/

NONSHARABLE_CLASS( CVtEngInitializer ) :

    public CActive,

	public MVtEngSettingObserver

    {

    public: // Constructors and destructor

        static CVtEngInitializer* NewL( CVtEngHandlerContainer& aHandlers );

        /**

        * Destructor.

        */

        virtual ~CVtEngInitializer();

    public: // new functions

        /**

        * Starts initialization process.

        */

        void InitializeL( CVtEngOperation& aCallback );

        /**

        * Cancels initialiation

        * @return ETrue if CActive::Cancel was called

        */

        TBool CancelInit();

        /**

        * Uninitializes engine.

        */

        void Uninitialize( CVtEngOperation& aCallback );

        /**

        * Gets GetSessionCommand ownership after initialization.

        * @return CSessionCommand interface.

        */

        MVtSessionCommand* GetSessionCommand();

        /**

        * Returns if engine is initialized.

        * @return ETrue if initialized

        */

        TBool Initialized() const;

		/**

        * Creates handler for DTMF sending.

		* @param aH324Config H324 configure interface

        */

        void CreateDtmfHandlerL( MVtH324ConfigCommand* aH324Config );

		/**

		* Gets pointer to comms. Still owns the comms.

		* @return Pointer to comms.

		*/		

        MCommServer* GetVtComms();

    private: // from CActive

        /**

        * performs one initialization step.

        */

        void RunL();

        /**

        * Cancels initialization process.

        */

        void DoCancel();

        /**

        * Handles error in the process.

        * @return always returns KErrNone

        */

        TInt RunError( TInt aError );

    public: // from MVtEngSettingObserver

        virtual void HandleSettingChangedL( 

            CVtEngSettings::TSettingId aId, 

            const TDesC& aValue );

    private: // Constructors

        /**

        * c++ constructor

        */

        CVtEngInitializer( CVtEngHandlerContainer& aHandlers );

        /**

        *

        */

        void ConstructL();

    private:

        enum TProcess

            {

            // Go to next step

            EContinue,

            // Reset engine

            EReset,

            // Retry current step when failed.

            ERetry

            };

    private: // new functions

        /**

        * Reads bit reversal information from locally variated flags.

        * @return ETrue if reversed.

        */

        TBool BitReversalUsed();

        /**

        * Proceeds to next step or starts retrial of

        * previously failed step.

        */

        void ContinueOrRetry( const TProcess aOperation );

        /**

        * Notifies observer on initialization completion.

        */

        void Notify( const TInt aResult );

        /**

        * Callback for retrial timer.

        */

        static TInt HandleTimer( TAny* aAny );

        /**

        * Handles retrial timer expiration.

        */

        void DoHandleTimer();

        TBool ActivateAndSignal( TInt aSignalValue );

    private:

        /**

        * Initialization steps

        */

        enum TVtEngInitializationSteps

            {

            EInitNone,

            EInitSession,

            EInitMedia,

            EInitProto,

			EInitDataportCompleted,

            EInitComplete,

            EResetMedia,

            EResetMediaPhase2

            };

        /**

        * Dataport information handling flags.

        */

        enum TVtEngDataportInformationFlags

            {

            EDataportListened = 0x01,

            EDataportReceived = 0x02

            };

    private:

        // handler container

        CVtEngHandlerContainer& iHandlers;

        // Current (un)initialization step

        TInt                    iStep;

        // Operation to be notified on completion

        CVtEngOperation*        iCallback;

        // Retrial count

        TInt                    iRetrials;

        // Retrial timer

        CPeriodic*              iTimer;

        // Protocol Session Engine

		MVtSessionCommand* iSessionCommand;

        // Protocol Comms Server

        MCommServer*      iComms;

        // Has subscription been made for dataport name.

        TInt iDataportHandled;

		// If MediaHandler has taken ownership of 2-way, this is true,

		// otherwise false.

		TBool iOwnershipInMH;

    };

#endif      // CVTENGINITIALIZER_H

// End of File