/*

* Copyright (c) 2009 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:  Defines the class that controls STIF Test Framework through

*                the STIF TF interface.

*

*/

#ifndef HTISTIFTFIF_H

#define HTISTIFTFIF_H

//  INCLUDES

#include <StifTFwIf.h>

#include <HtiServicePluginInterface.h>

// CONSTANTS

// MACROS

// DATA TYPES

// FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

class CDesC8ArrayFlat;

class CHtiStifTfServicePlugin;

class CConsoleBase;

// CLASS DECLARATION

/**

*  Container class for test modules' test infos.

*  One instance of this class contains the test infos of one test module in

*  an RPointerArray and the name of the test module as HBufC.

*

*/

class CHtiTestModuleCaseInfos : public CBase

    {

    public: // Constuctors and destructor

        /**

        * Two-phased constructor.

        */

        static CHtiTestModuleCaseInfos* NewL( const TDesC& aModuleName );

        /**

        * Two-phased constructor.

        */

        static CHtiTestModuleCaseInfos* NewLC( const TDesC& aModuleName );

        /**

        * Destructor.

        */

        ~CHtiTestModuleCaseInfos();

    public:

        /**

        * Compares the order of two CHtiTestMoudleCaseInfos objects.

        * Order is based on the alphabetical order of the module name.

        * @param aFirst reference to the first instance to compare

        * @param aSecond reference to the second instance to compare

        * @return Positive if the first module's name is greater than the

        *         second module's name. Negative if the first module's name is

        *         less than the second module's name. Zero if names are equal.

        */

        static TInt Compare( const CHtiTestModuleCaseInfos& aFirst,

                             const CHtiTestModuleCaseInfos& aSecond );

        /**

        * Compares the equality of two CHtiTestMoudleCaseInfos objects.

        * Equality is based on the name of the module.

        * @param aFirst reference to the first instance to compare

        * @param aSecond reference to the second instance to compare

        * @return ETrue if the module names are equal. EFalse otherwise.

        */

        static TBool Match(  const CHtiTestModuleCaseInfos& aFirst,

                             const CHtiTestModuleCaseInfos& aSecond );

    private:

        CHtiTestModuleCaseInfos();

        void ConstructL( const TDesC& aModuleName );

    public: // Data

        // The name of the test module whose test infos this instance contains

        HBufC* iModuleName;

        // An array of CTestInfo objects (one per test case)

        RPointerArray<CTestInfo> iTestInfos;

    };

// CLASS DECLARATION

/**

*  Implements the STIF Test Framework interface functions.

*/

class CHtiStifTfIf : public CStifTFwIf

    {

    public:  // Constructors and destructor

        /**

        * Two-phased constructor.

        */

        static CHtiStifTfIf* NewL( CHtiStifTfServicePlugin* aPlugin );

        /**

        * Destructor.

        */

        virtual ~CHtiStifTfIf();

    public: // New functions

        /**

        * Called when there is a message to be processed by this service.

        * @param aMessage message body destinated to the servive

        * @param aPriority message priority

        */

        void ProcessMessageL( const TDesC8& aMessage,

            THtiMessagePriority aPriority );

        /**

        * Called by the plugin to tell the service how much memory is

        * available for messages in the message queue.

        * @param aAvailableMemory amount of currently available memory

        *        in the message queue

        */

        void NotifyMemoryChange( TInt aAvailableMemory );

        /**

        * Sets the dispatcher to send outgoing messages to.

        * @param aDispatcher pointer to dispatcher instance

        */

        void SetDispatcher( MHtiDispatcher* aDispatcher );

    public: // Functions from base classes

    protected:  // New functions

    protected:  // Functions from base classes

        // virtual functions from CStifTFwIf

        /**

        * Function that is called when test execution is finished.

        * @param aTestId id of the test case

        * @param aTestExecutionResult result of test execution

        * @param aTestResult actual result of the test case

        */

        void TestCompleted( TInt aTestId,

                            TInt aTestExecutionResult,

                            TTestResult& aTestResult );

        /**

        * Function for sending message to ATS.

        * @param aMessage message to be sent

        */

        void AtsSend( const TDesC& aMessage );

        /**

        * Get device identifier.

        * Should be overridden to make them unique among slaves.

        * Returns default value for every slave otherwise.

        * @return the device ID

        */

        TUint16 DevId(){ return iDevId; };

        /**

        * Function is called when test case prints.

        */

        void Print( TInt aTestId, TTestProgress& aProgress );

    private:

        /**

        * C++ default constructor.

        */

        CHtiStifTfIf();

        /**

        * By default Symbian 2nd phase constructor is private.

        */

        void ConstructL( CHtiStifTfServicePlugin* aPlugin );

        // Private helper methods.

        void HandleOpenCmdL();

        void HandleCloseCmdL();

        void HandleLoadModuleCmdL();

        void HandleUnloadModuleCmdL();

        void HandleListCasesCmdL();

        void HandleStartCaseCmdL();

        void HandleCancelCaseCmdL();

        void HandlePauseCaseCmdL();

        void HandleResumeCaseCmdL();

        void HandleAddCaseFileCmdL();

        void HandleRemoveCaseFileCmdL();

        void HandleCaseMsgCmdL();

        void HandleSetDevIdCmdL();

        void HandleSetAttributeCmdL();

        void LoadTestCaseInfosL();

        void LoadTestCaseInfosL( TDesC& aModuleName );

        void ParseParametersL( const TDesC8& aCommand );

        TInt SendResponseMsg( const TDesC8& aMsg,

                              const TUint8 aCommandId = 0 );

        TInt SendErrorResponseMsg( TInt aErrorCode,

                                   const TDesC8& aErrorDescription,

                                   const TUint8 aCommandId = 0 );

        TInt IndexByModuleName( const TDesC& aModuleName );

        CTestInfo* GetCaseInfoL( TInt aCaseIndex );

    public:     // Data

        // Flag telling if the service is busy processing a message

        TBool iIsBusy;

    protected:  // Data

    private:    // Data

        // ID of the last received command

        TUint8 iCommandId;

        // Array container for parameters of the last received message

        CDesC8ArrayFlat* iParameters;

        // The message dispatcher interface

        MHtiDispatcher* iDispatcher;

        // Container for the response message to be dispatched out

        HBufC8* iMessage;

        // Error code in the outgoing error message

        TInt iErrorCode;

        // Flag telling if STIF TF has been opened

        TBool iStifTfOpen;

        // The device ID

        TUint16 iDevId;

        // An array holding the test case infos of all loaded test modules

        RPointerArray<CHtiTestModuleCaseInfos> iLoadedInfos;

        // Pointer to the service plugin instance - this is not owned

        CHtiStifTfServicePlugin* iPlugin;

        // Pointer to the HTI console

        CConsoleBase* iConsole;

    };

#endif      // HTISTIFTFIF_H

// End of File