/*

* Copyright (c) 2010 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: 

*

*/

// INCLUDE FILES

#include "loadgen_applications.h"

#include "loadgen_utils.h"

#include "loadgen.hrh"

#include <loadgen.rsg>

#include <e32math.h>

#include "loadgen_traces.h"

_LIT(KThreadName, "Applications %d");

const TInt KDefaultStartDelay = 500;

const TInt KThreadNameLength = 64;

const TInt KDescriptorBufSize = 256;

const TInt KPriorityBufSize = 16;

const TInt KScanCodeStart = 32;

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

CAppLauncher* CAppLauncher::NewL( TApplicationsAttributes& aAttributes, TInt aReferenceNumber )

    {

    CAppLauncher* self = new(ELeave) CAppLauncher( aAttributes, aReferenceNumber );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;    

    }

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

CAppLauncher::~CAppLauncher()

    {

    Close();

    }

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

CAppLauncher::CAppLauncher(  

           TApplicationsAttributes& aAttributes, TInt aReferenceNumber ) : 

           iAttributes( aAttributes )

    {

    iAttributes.iId = aReferenceNumber;

    }

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

void CAppLauncher::ConstructL()

    {

    CLoadBase::ConstructL();

    iType = ELoadGenCmdNewLoadApplications;

    TBuf<KThreadNameLength> threadName;

    threadName.Format( KThreadName, iAttributes.iId );

    // create a thread

    User::LeaveIfError( iThread.Create( threadName, ThreadFunction, 

                                        KDefaultStackSize*2, KMinHeapSize, 

                                        KKilo * KMinHeapSize, (TAny*) &iAttributes ) );

    // set priority of the thread

    SetPriority();

    }

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

TInt CAppLauncher::ThreadFunction( TAny* aThreadArg )

    {

    CTrapCleanup* pC = CTrapCleanup::New();

    CActiveScheduler* pS = new CActiveScheduler;

    CActiveScheduler::Install( pS );

    // start generating load, pass pointer to arguments

    GenerateLoad( *( ( TApplicationsAttributes* ) aThreadArg ) );

    delete pS;

    delete pC;

    return KErrNone;

    }

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

void CAppLauncher::GenerateLoad( TApplicationsAttributes& aAttributes )

    {

    CAppLauncherManager* appLauncherManager = NULL;

    TRAPD( err, appLauncherManager = CAppLauncherManager::NewL( aAttributes ) );

    if ( err == KErrNone ) 

        {

        CActiveScheduler::Start();

        }

    delete appLauncherManager;

    }

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

void CAppLauncher::Resume()

    {

    CLoadBase::Resume();

    iThread.Resume();

    }

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

void CAppLauncher::Suspend()

    {

    CLoadBase::Suspend();

    iThread.Suspend();

    }

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

void CAppLauncher::SetPriority()

    {

    CLoadBase::SetPriority();

    iThread.SetPriority( CLoadGenUtils::SettingItemToThreadPriority( iAttributes.iPriority ) );

    }

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

void CAppLauncher::Close()

    {

    CLoadBase::Close();

    if ( iThread.ExitReason() == 0 ) // check if the thread is still alive

        {

        // signal the thread that it needs to close

        iThread.RequestComplete( iAttributes.iDeathStatus, KErrCancel );

        // wait the thread to die

        TRequestStatus waiter;

        iThread.Logon( waiter );

        User::WaitForRequest( waiter );

        iThread.Close();

        }

    }

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

TPtrC CAppLauncher::Description()

    {

    TBuf<KDescriptorBufSize> buf;

    TBuf<KPriorityBufSize> prioBuf;

    CLoadGenUtils::SettingItemToThreadDescription( iAttributes.iPriority, prioBuf );

    _LIT(KAppLauncherEntry, "[%d] Appls prio=%S max apps=%d heartbeat=%dms random=%d%%");

    buf.Format( KAppLauncherEntry, iAttributes.iId, &prioBuf, iAttributes.iMaxOpen, 

                iAttributes.iHeartBeat, iAttributes.iRandomVariance );

    return TPtrC( buf );

    }               

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

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

CAppLauncherManager* CAppLauncherManager::NewL( TApplicationsAttributes& aAttributes )

    {

    CAppLauncherManager* self = new(ELeave) CAppLauncherManager(aAttributes);

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

CAppLauncherManager::CAppLauncherManager( TApplicationsAttributes& aAttributes ) :

            CActive( EPriorityStandard ), iAttributes( aAttributes )

    {

    iAppEventType = EApplicationsLaunchApplication;

    }

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

CAppLauncherManager::~CAppLauncherManager()

    {

    if ( iPeriodicTimer )

        {

        iPeriodicTimer->Cancel();

        delete iPeriodicTimer;

        }

    delete iLauncherEngine;

    Cancel();

    iWsSession.Close();

    }

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

void CAppLauncherManager::ConstructL()

    {

    CActiveScheduler::Add( this );

    // create instance to application launcher

    iLauncherEngine = CLauncherEngine::NewL( iAttributes );

    // set the status as pending

    iStatus = KRequestPending;

    SetActive();

    // set the death status pointer point to the request status of this ao

    iAttributes.iDeathStatus = &iStatus;

    // init

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

    // start timer    

    iPeriodicTimer = CPeriodic::NewL( CActive::EPriorityStandard );

    iPeriodicTimer->Start( KDefaultStartDelay, 

                           CLoadGenUtils::MilliSecondsToMicroSeconds( 

                               iAttributes.iLaunchingInterval, iAttributes.iRandomVariance ),

                           TCallBack( PeriodicTimerCallBack, this ) );

    }

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

void CAppLauncherManager::RunL()

    {

    // request status has completed by the main thread meaning that we need to stop now

    CActiveScheduler::Stop();

    }

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

void CAppLauncherManager::DoCancel()

    {

    }

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

TInt CAppLauncherManager::PeriodicTimerCallBack( TAny* aAny )

    {

    CAppLauncherManager* self = static_cast<CAppLauncherManager*>( aAny );

    TRAPD( err, self->SimulateEventL() );

    if ( KErrNone != err )

        {

        return err;

        }

    return KErrNone;

    }

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

void CAppLauncherManager::SimulateEventL()

    {    

    // Randomly start new applications.

    // After maximum applications launched stop one application.

    // And after that start launching again.

    if ( iAppEventType == EApplicationsLaunchApplication && 

         iAttributes.iMaxOpen == iLauncherEngine->AppLaunchCounter() )

        {

        iAppEventType = EApplicationsCloseApplication;

        }

    if ( iAppEventType == EApplicationsCloseApplication && 

         iAttributes.iMaxOpen -1 == iLauncherEngine->AppLaunchCounter() )

        {

        iAppEventType = EApplicationsLaunchApplication;

        }

    // Launch or stop

    if ( iAppEventType == EApplicationsLaunchApplication )

        {

        iLauncherEngine->StartAppLaunchingL();

        }  

    else

        {

        iLauncherEngine->StopApplication( ETrue );

        }

    }

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

#include <avkon.hrh>

#include <e32std.h>

#include <w32std.h>

#include <apgtask.h>

#include <bautils.h>

#include <s32file.h>

#include <apgwgnam.h> 

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

CLauncherEngine* CLauncherEngine::NewL( TApplicationsAttributes& aAttributes )

    {

    CLauncherEngine* self = new(ELeave) CLauncherEngine( aAttributes );

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

CLauncherEngine::CLauncherEngine( TApplicationsAttributes& aAttributes ) : 

                        iAttributes( aAttributes )

    {

    }

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

void CLauncherEngine::ConstructL()

    {

    LOGSTRING("LoadGen: CLauncherEngine::ConstructL");

    iAppKeyPressManager = CAppKeyPressManager::NewL( iAttributes );

    iAppLaunchCounter = 0;

    User::LeaveIfError( iTimer.CreateLocal() );

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

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

    }

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

CLauncherEngine::~CLauncherEngine()

    {

    LOGSTRING("LoadGen: CLauncherEngine::~CLauncherEngine");

    StopApplication( EFalse );

    iWs.Close();

    iLs.Close();

    iTimer.Close();

    delete iAppKeyPressManager;

    }

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

void CLauncherEngine::StartAppLaunchingL()

    {

    LOGSTRING("LoadGen: CLauncherEngine::StartAppLaunchingL");

    if ( iAppLaunchCounter == iAttributes.iMaxOpen )

        {

        return;

        }

    // start launching

    TBool launched( EFalse );

    while ( !launched )

        {

        launched = LaunchApplicationL();

        }

    }

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

TBool CLauncherEngine::LaunchApplicationL()

    {

    LOGSTRING("LoadGen: CLauncherEngine::LaunchApplicationL");

    TBool result( EFalse );

    // get the uid of the current app

    iCurrentAppUid = KNullUid;

    TApaAppInfo appInfo;

    // get application list size

    TInt appsListSize = iAttributes.iAppsArray->MdcaCount();

    // get random application number in the list

    TInt appTolaunch = CLoadGenUtils::RandomNumber( 0,  appsListSize - 1 );

    // get file name of the application to be launched

    TFileName launchFileName = iAttributes.iAppsArray->MdcaPoint( appTolaunch );

    iLs.GetAllApps();

    while ( iLs.GetNextApp( appInfo ) == KErrNone )

        {

        // get file name in  current appInfo

        TFileName appFileName = appInfo.iFullName;

        // get AppUid

        if ( appFileName.CompareF( launchFileName ) == 0 )

            {

            iCurrentAppUid = appInfo.iUid;

            break;

            }

        }

    if ( iCurrentAppUid != KNullUid )

        {        

        // parse the filename

        TParse nameParser;

        nameParser.SetNoWild( iAttributes.iAppsArray->MdcaPoint( appTolaunch ), NULL, NULL );

        iCurrentAppNameAndExt.Copy( nameParser.Drive() );

        iCurrentAppNameAndExt.Append( nameParser.NameAndExt() );

        // do not try to launch these apps

        if ( iCurrentAppUid != KNullUid &&

              iAttributes.iAppsArray->MdcaPoint( appTolaunch).FindF(_L("\\loadgen.")) == KErrNotFound &&

              iAttributes.iAppsArray->MdcaPoint( appTolaunch ).FindF( _L("\\Phone." ) ) == KErrNotFound &&

              iAttributes.iAppsArray->MdcaPoint( appTolaunch).FindF( _L("\\Startup.") ) == KErrNotFound &&  

              iAttributes.iAppsArray->MdcaPoint( appTolaunch ).FindF( _L("\\SplashScreen.") ) == KErrNotFound &&  

              iAttributes.iAppsArray->MdcaPoint( appTolaunch ).FindF( _L("\\cameraapp.") ) == KErrNotFound &&

              iAttributes.iAppsArray->MdcaPoint( appTolaunch ).FindF( _L("\\eshell.") ) == KErrNotFound &&

              iAttributes.iAppsArray->MdcaPoint( appTolaunch ).FindF( _L("\\ConnTest.") ) == KErrNotFound &&

              iAttributes.iAppsArray->MdcaPoint( appTolaunch ).FindF( _L("\\Launcher.") ) == KErrNotFound &&

#ifdef __WINS__

              iAttributes.iAppsArray->MdcaPoint( appTolaunch ).FindF( _L("\\DebugAgent.") ) == KErrNotFound &&

              iAttributes.iAppsArray->MdcaPoint( appTolaunch ).FindF( _L("\\redirect.") ) == KErrNotFound &&              

#endif              

              iAttributes.iAppsArray->MdcaPoint( appTolaunch ).FindF( _L("\\VoiceRecorder.") ) == KErrNotFound )            

            {

            // check if the app is already running

            TApaTaskList taskList( iWs );

            TApaTask thisTask = taskList.FindApp( iCurrentAppUid );

            if ( !thisTask.Exists( ))

                {

                // check the program's capabilities

                TApaAppCapabilityBuf buf;

                iLs.GetAppCapability( buf, iCurrentAppUid );

                TApaAppCapability cap = buf();

                // if it's embeddable only, don't launch if setting is enabled

                // if it's hidden, don't launch if setting is enabled

                if ( cap.iEmbeddability != TApaAppCapability::EEmbeddableOnly &&

                     !cap.iAppIsHidden )

                    {

                    LOGSTRING2("launchFileName = %S", &launchFileName);

                    DoLaunchApplicationL();

                    result = ETrue;

                    }            

                } 

            }

        }

    return result;

    }

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

void CLauncherEngine::DoLaunchApplicationL()

    {

    LOGSTRING("LoadGen: CLauncherEngine::DoLaunchApplicationL");

    // Find the task with uid3

    TApaTaskList tasklist( iWs );

    TApaTask task=tasklist.FindApp( iCurrentAppUid );

    if ( !task.Exists() )

        // Task doesn't exist, launch a new instance of an application

        {

        TApaAppInfo appInfo;

        User::LeaveIfError( iLs.GetAppInfo( appInfo, iCurrentAppUid ) );

        CApaCommandLine* cmdLine=CApaCommandLine::NewLC();

        cmdLine->SetExecutableNameL( appInfo.iFullName );

        // app is launched in background

        cmdLine->SetCommandL( EApaCommandBackground );       

        // start the app

        User::LeaveIfError( iLs.StartApp( *cmdLine ) );

        iAppKeyPressManager->AddNewApplicationUidToKeyEventsL( iCurrentAppUid );

        iAppLaunchCounter++;

        CleanupStack::PopAndDestroy( cmdLine );

        }

    }

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

void CLauncherEngine::StopApplication( TBool aRandomApplication )

    {

    LOGSTRING("LoadGen: CLauncherEngine::StopApplication");

    // remove key pressing instance

    TUid appToDelete = iAppKeyPressManager->KillApplication( aRandomApplication );

    if ( appToDelete != KNullUid )

        {

        TApaTaskList taskList( iWs );

        TApaTask thisTask = taskList.FindApp( appToDelete );

        if ( thisTask.Exists() )

            {

            // since the application is still open, let's close it

            thisTask.EndTask();

            }

        iAppLaunchCounter--;

        }

    // return if only one application requested

    if ( aRandomApplication )

        {

        return;

        }

    // remove all launched applications because load is requested to be closed

    while ( appToDelete != KNullUid )

        {

        appToDelete = iAppKeyPressManager->KillApplication( aRandomApplication );

        if ( appToDelete != KNullUid )

            {

            TApaTaskList taskList( iWs );

            TApaTask thisTask = taskList.FindApp( appToDelete );

            if ( thisTask.Exists() )

                {

                // since the application is still open, let's close it

                thisTask.EndTask();

                }

            iAppLaunchCounter--;

            }

        }

    }

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

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

CAppKeyPressManager* CAppKeyPressManager::NewL( TApplicationsAttributes& aAttributes )