// 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:
//

/**
 @file
 @test
 @internalComponent - Internal Symbian test code 
*/


#include "te_conestepbase.h"


_LIT(KTestStepThread, "TestStepConeThread");


TVerdict CTe_ConeStepBase::doTestStepPreambleL()
	{
	CTe_graphicsperformanceSuiteStepBase::doTestStepPreambleL();
	
	TESTNOERRORL(iConeThread.Create(KTestStepThread, CTe_ConeStepBase::ConeThreadFunction,
	        KDefaultStackSize, NULL, this));
	
	iInitUISemaphore.CreateLocal(0);
	iConeThread.Resume(); // start the cone thread
	
	// wait for InitUIL() method to finish, that means test can start now
	iInitUISemaphore.Wait();
	
	return TestStepResult();
	}

TVerdict CTe_ConeStepBase::doTestStepPostambleL()
	{
	iProfiler->FreeResultsMemory(); // cleanup memory in the baseclass (otherwise heaptest panics)
	
	iConeThread.RequestComplete(iTestCompletionStatus, KErrNone); // informs conestopper
    
	TRequestStatus status;
	iConeThread.Rendezvous(status); // asynchronous, completes amongst others when thread terminates
	User::WaitForRequest(status); // waits for Rendevous() to finish
	iConeThread.Close();
	iInitUISemaphore.Close();
	
	return CTe_graphicsperformanceSuiteStepBase::doTestStepPostambleL();
	}


/**
 * Starts the CONE thread.
 */
TInt CTe_ConeStepBase::ConeThreadFunction(TAny* aParams)
     {
     CTe_ConeStepBase* testStep = static_cast<CTe_ConeStepBase*>(aParams);
     return testStep->StartControlEnvironment();     
     }

CCoeEnv* CTe_ConeStepBase::ConstructControlEnvironment()
    {
    CEikonEnv* eikonEnv = new CEikonEnv();
    if (eikonEnv)
        {
        TRAPD(err, eikonEnv->ConstructL());
        if (err != KErrNone)
            {
            delete eikonEnv;
            return NULL;
            }
        }    
    return eikonEnv;
    }

TInt CTe_ConeStepBase::StartControlEnvironment()
    {
    TInt err = KErrNoMemory;
    CConeThreadStopper* stopper = new CConeThreadStopper(*this);
    if (stopper)
        {
        CCoeEnv* coeEnv = ConstructControlEnvironment();
        if (coeEnv)
            {
            TRAP(err, InitUIL(coeEnv));
            if (err == KErrNone)
                {
                stopper->Start(iTestCompletionStatus);
                iInitUISemaphore.Signal();
                coeEnv->ExecuteD(); // runs until its terminated by the CConeThreadStopper
                coeEnv = NULL;
                }       
            delete coeEnv;
            }            
        delete stopper;
        }
    if (err != KErrNone)
        {
        SetTestStepResult(EAbort);
        iInitUISemaphore.Signal(); // also signal if an error occurs, otherwise test would be blocked
        }
    return err;
    }


void CTe_ConeStepBase::StopControlEnvironment()
   {
   CActiveScheduler::Stop();
   }



CConeThreadStopper::CConeThreadStopper(CTe_ConeStepBase& aTestStep) :
       CActive(EPriorityStandard), iTestStep(aTestStep)
   {
   // empty
   }

CConeThreadStopper::~CConeThreadStopper()
    {
    Cancel();
    }

void CConeThreadStopper::Start(TRequestStatus *&aStopStatus)
   {
   CActiveScheduler::Add(this);
   aStopStatus = &iStatus;
   iStatus = KRequestPending;
   SetActive();
   }

void CConeThreadStopper::DoCancel()
    {
    // empty
    }

void CConeThreadStopper::RunL()
   {
   iTestStep.StopControlEnvironment(); // stops the active scheduler of the CONE thread
   }