/*

* Copyright (c) 2008 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:  CAlfPerfAppTestCaseExecutionView implementation.

 *

*/

#include <aknutils.h>

#include <aknviewappui.h>

#include <alfperfapp.rsg>

#include <alf/alfenv.h>

#include <hal.h>

#include "alfperfapptestcaseexecutionview.h"

#include "alfperfappconstants.h"

#include "alfperfapptestcasefactory.h"

#include "alfperfapptestcase.h"

#include "alfperfappmodel.h"

#include "../../alfdebugextension/inc/alfdebug.h"

/**

 * Client-server interface for daemon.

 */

class RAlfPerfAppDaemon : public RApaAppServiceBase

    {

public:

    /**

     * Constructor.

     */

    RAlfPerfAppDaemon();

    /**

     * Connects to daemon.

     * @return error code, KErrNone upon success.

     */

    TInt Connect();

    /**

     * Gets measurements.

     * @param aMeasurements this will contain measurements.

     * @return error code.

     */

    TInt GetMeasurements( TAlfDebugServerMeasurements& aMeasurements );

    /**

     * Enables activity polling. 

     * @param aEnable ETrue if enabled, EFalse if disabled.

     * @return error code.

     */

    TInt EnableActivityPoll( TBool aEnable );

private:

    /**

     * From RApaAppServiceBase, returns service UID.

     * @return service UID.

     */

    virtual TUid ServiceUid() const;

    };

/**

 * CAlfPerfAppTestCaseExecutionView::CContainer container class.

 */

class CAlfPerfAppTestCaseExecutionView::CContainer : public CCoeControl

    {

    public:

        CContainer( CAlfPerfAppTestCaseExecutionView& aView );

        void ConstructL();

        ~CContainer();

        // From base class CCoeControl    

        virtual TKeyResponse OfferKeyEventL( 

                const TKeyEvent& aKeyEvent, TEventCode aType );

        virtual void HandleResourceChange( TInt aType );

        virtual void Draw(const TRect& aRect) const;

    private:

        /**

         * Reference to execution view.

         * Now owned.

         */

        CAlfPerfAppTestCaseExecutionView& iView;

    };

/**

 * Active object to execute test cases.

 */

class CAlfPerfAppTestCaseExecutionView::CActiveExecuter 

: public CActive, private MAlfPerfAppTestCaseInterface

    {

    public:

        CActiveExecuter( 

                CAlfPerfAppTestCaseExecutionView& aView,

                CAlfPerfAppTestCaseFactory& aFactory,

                CAlfPerfAppModel& aModel,

                RAlfPerfAppDaemon& aDaemon,

                TBool aUseContinuousRun = EFalse);

        ~CActiveExecuter();

        /**

         * Starts executing test cases.

         */

        void StartNextCase();

        /**

         * Sets visible area.

         * @param aRect new visible area.

         */ 

        void SetVisibleArea( const TRect& aRect );

        /**

         * Ends the continuous run if it was on, otherwise does nothing.

         */

        void EndContinuousRun();

    private:

        // From base class CActive

        virtual void RunL();

        virtual void DoCancel();

        virtual TInt RunError( TInt aError );

        // From base class MAlfPerfAppTestCaseInterface

        virtual void MeasureNow();

    private:

        /**

         * Gets next test case.

         * @return ETrue if test case received ok.

         */

        TBool GetNextTestCaseL();

        /**

         * Reports error. Calls DoReportErrorL in TRAP harness.

         * @param aErrorCode error code.

         */

        void ReportError( TInt aErrorCode );

        /**

         * Reports error to model.

         * @param aErrorCode error code.

         */

        void DoReportErrorL( TInt aErrorCode );

        /**

         * Reports error and continues to next case.

         * @param aErrorCode error code.

         */

        void ReportErrorAndContinue( TInt aErrorCode );

        /**

         * Resets current state.

         */

        void Reset( TBool aOkToCallObserver );

        /**

         * Completes request status with specified error code.

         * @param aErrorCode error code.

         */

        void CompleteNow( TInt aErrorCode );

        /**

         * Determine next state based on current state.

         * It's expected that current state has been completed

         * successfully.

         */

        void DetermineNextState();

        /**

         * Creates alf environment and initializes

         * debug extension plugin.

         */

        void CreateEnvL();

        /**

         * Deletes alf environment.

         */

        void DeleteEnv();

        /**

         * Performs measurements.

         */

        void PerformMeasurementsL();

    private:

        /**

         * Reference to execution view.

         * Not owned.

         */

        CAlfPerfAppTestCaseExecutionView& iView;

        /**

         * Reference to test case factory.

         * Not owned.

         */

        CAlfPerfAppTestCaseFactory& iFactory;

        /**

         * Reference to model.

         * Not owned.

         */

        CAlfPerfAppModel& iModel;

        /**

         * Reference to daemon.

         * Not owned.

         */

        RAlfPerfAppDaemon& iDaemon;

        /**

         * Visible area rect.

         */

        TRect iVisibleArea;

        /**

         * Current test case id.

         */

        TInt iCaseId;

        /*

         *  Current cases place in the sequence

         */

        TInt iSequenceIndex;

        /**

         * Enumerates different possibilities for current state.

         */

        enum TCurrentState

            {

            EStateIdle,

            EStateCreateTestCase,

            EStateSetupTestCase,

            EStateExecuteTestCase,

            EStateTearDownTestCase

            };

        /**

         * Current state.

         */

        TCurrentState iCurrentState;

        /**

         * Alf environment.

         * Owned.

         */

        CAlfEnv* iEnv;

        /**

         * Current test case under execution.

         * Owned.

         */      

        CAlfPerfAppTestCase* iCurrentTestCase;

        /**

         * NTickCount tick period.

         */

        TInt iTickPeriod;  

        /**

         * Tells if the continuous run is enabled.

         */

        TBool iContinuousRunOngoing;

        /**

         * Tells if this is the last case. Used only to end continuous run correctly.

         */

        TBool iFinalCase;

    };

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

CAlfPerfAppTestCaseExecutionView* CAlfPerfAppTestCaseExecutionView::NewLC(

        CAlfPerfAppModel& aModel )

    {

    CAlfPerfAppTestCaseExecutionView* self = 

    new (ELeave) CAlfPerfAppTestCaseExecutionView( aModel );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

CAlfPerfAppTestCaseExecutionView::~CAlfPerfAppTestCaseExecutionView()

    {

    delete iExecuter;

    delete iFactory;

    if ( iDaemon )

        {

        iDaemon->Close();

        delete iDaemon;

        }

    }

void CAlfPerfAppTestCaseExecutionView::NotifyLayoutChange( 

        const TRect& aRect )

    {

    if ( iExecuter )

        {

        iExecuter->SetVisibleArea( aRect );

        }

    }

void CAlfPerfAppTestCaseExecutionView::NotifyExecutionCompletedL()

    {

    AppUi()->ActivateLocalViewL( KAlfPerfAppTestCaseResultsViewId );

    }

void CAlfPerfAppTestCaseExecutionView::NotifyTestCaseVisible( TBool aVisible )

    {

    if ( iContainer )

        {

        if ( iDaemon )

            {

            // Call User::ResetInactivityTime periodically if test case

            // is visible. This ensures that screensaver is not activated

            // and thus test case execution is not disturbed.

            (void)iDaemon->EnableActivityPoll( aVisible );

            }

        iContainer->MakeVisible( !aVisible );

        }

    }

CAlfPerfAppTestCaseExecutionView::CAlfPerfAppTestCaseExecutionView(

        CAlfPerfAppModel& aModel )

: iModel( aModel )

            {

            }

#include <apgcli.h>

#include <apacmdln.h>

#include "alfperfapp.hrh"

        static void StartDaemonL()

            {

            _LIT( KAlfPerfAppDaemonExe, "alfperfappdaemon.exe" );

            const TUid KAlfPerfAppDaemonUid = { KAlfPerfAppDaemonUidValue };

            RApaLsSession apa;

            User::LeaveIfError(apa.Connect());

            CleanupClosePushL(apa);

            CApaCommandLine* cmdLine = CApaCommandLine::NewLC();

            cmdLine->SetExecutableNameL( KAlfPerfAppDaemonExe );

            cmdLine->SetServerRequiredL( KAlfPerfAppDaemonUid.iUid );

            cmdLine->SetCommandL( EApaCommandBackground );

            TThreadId dummy;

            TRequestStatus requestStatusForRendezvous;

            User::LeaveIfError( apa.StartApp(*cmdLine, dummy, &requestStatusForRendezvous) );

            User::WaitForRequest( requestStatusForRendezvous );

            User::LeaveIfError( requestStatusForRendezvous.Int() );

            CleanupStack::PopAndDestroy(2, &apa);   

            }

        void CAlfPerfAppTestCaseExecutionView::ConstructL()

            {

            BaseConstructL( R_ALFPERFAPP_TEST_CASE_EXECUTION_VIEW );

            iFactory = CAlfPerfAppTestCaseFactory::NewL();

            iDaemon = new (ELeave) RAlfPerfAppDaemon;

            TInt err = iDaemon->Connect();

            if ( err == KErrNotFound )

                {

                TRAP( err, StartDaemonL() );

                if ( err == KErrNone ||

                        err == KErrAlreadyExists )

                    {

                    err = iDaemon->Connect();

                    }

                }

            if ( err != KErrNotFound )

                {

                User::LeaveIfError( err );

                }

            }

        TUid CAlfPerfAppTestCaseExecutionView::Id() const

        {

        return KAlfPerfAppTestCaseExecutionViewId;

        }

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

        // Handles view activation

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

        //

        void CAlfPerfAppTestCaseExecutionView::DoActivateL(

                const TVwsViewId& /*aPrevViewId*/,

                TUid /*aCustomMessageId*/,

                const TDesC8& aCustomMessage )

            {

            CContainer* container = new (ELeave) CContainer( *this );

            CleanupStack::PushL( container );

            container->ConstructL();

            AppUi()->AddToStackL( *this, container );

            CleanupStack::Pop( container );

            iContainer = container;

            if(aCustomMessage == _L8("UseContinuousRun"))

                {

                // If we should use the continuous run, use it (the ETrue in the end)

                iExecuter = new (ELeave) CActiveExecuter( *this, *iFactory, iModel, *iDaemon, ETrue );

                Cba()->SetCommandSetL(R_AVKON_SOFTKEYS_OK_EMPTY);

                Cba()->DrawDeferred();

                }

            else

                {

                // If not, then just use the default parameters

                iExecuter = new (ELeave) CActiveExecuter( *this, *iFactory, iModel, *iDaemon);

                Cba()->SetCommandSetL(R_AVKON_SOFTKEYS_EMPTY);

                Cba()->DrawDeferred();

                }

            iExecuter->SetVisibleArea( 

                    TRect( container->Position(), container->Size() ) );

            iExecuter->StartNextCase();

            }

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

        // Handles view deactivation

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

        //

        void CAlfPerfAppTestCaseExecutionView::DoDeactivate()

            {

            if ( iContainer )

                {

                AppUi()->RemoveFromStack( iContainer );

                delete iContainer;

                iContainer = NULL;

                }

            delete iExecuter;

            iExecuter = NULL;

            }

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

        // Handles test case selection view specific commands.

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

        //

        void CAlfPerfAppTestCaseExecutionView::HandleCommandL( TInt aCommand )

            {

            if(aCommand == EAknSoftkeyOk) // For some reason, switch didn't catch this

                {

                iExecuter->EndContinuousRun();

                return;

                }

            switch ( aCommand )

                {

                default:

                    AppUi()->HandleCommandL( aCommand );

                    break;

                }

            }

        //

        // Implementation of CAlfPerfAppTestCaseExecutionView::CContainer:

        //

        CAlfPerfAppTestCaseExecutionView::CContainer::CContainer(

                CAlfPerfAppTestCaseExecutionView& aView )

        : iView( aView )

            {

            }

                void CAlfPerfAppTestCaseExecutionView::CContainer::ConstructL()

                    {

                    CreateWindowL();

                    TRect rect;

                    AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EMainPane, rect );

                    SetRect( rect );

                    ActivateL();

                    }

                CAlfPerfAppTestCaseExecutionView::CContainer::~CContainer()

                    {

                    }

                TKeyResponse CAlfPerfAppTestCaseExecutionView::CContainer::OfferKeyEventL( 

                        const TKeyEvent& /*aKeyEvent*/, TEventCode /*aType*/ )

                    {

                    TKeyResponse resp = EKeyWasNotConsumed;

                    if ( IsVisible() )

                        {

                        resp = EKeyWasConsumed;

                        }

                    return resp;

                    }

                void CAlfPerfAppTestCaseExecutionView::CContainer::HandleResourceChange( TInt aType )

                    {

                    CCoeControl::HandleResourceChange( aType );

                    if ( aType == KEikDynamicLayoutVariantSwitch )

                        {

                        TRect rect;

                        AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EMainPane, rect );

                        SetRect( rect );

                        iView.NotifyLayoutChange( rect );

                        }

                    }

                void CAlfPerfAppTestCaseExecutionView::CContainer::Draw( 

                        const TRect& /*aRect*/ ) const

                        {

                        CWindowGc& gc = SystemGc();

                        gc.SetPenStyle( CGraphicsContext::ENullPen );

                        gc.SetBrushStyle( CGraphicsContext::ESolidBrush );

                        gc.SetBrushColor( TRgb( 128, 0, 0 ) ); // red color

                        gc.DrawRect( Rect() );

                        gc.SetBrushStyle( CGraphicsContext::ENullBrush );