/*

* 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 "engine.h"

#include "enginewrapper.h"

#include "settingsview.h"

#include "loadgen_utils.h"

#include "loadgen_cpuload.h"

#include "loadgen_memoryeat.h"

#include "loadgen_phonecall.h"

#include "loadgen_netconn.h"

#include "loadgen_keypress.h"

#include "loadgen_pointerevent.h"

#include "loadgen_messages.h"

#include "loadgen_applications.h"

#include "loadgen_photocapture.h"

#include "loadgen_bluetooth.h"

#include "loadgen_traces.h"

#include "loadgen_loadattributes.h"

#include "loadgen.hrh"

//#include "loadgen_editors.h"

//#include "loadgen_app.h"

//#include "loadgen_settingsviewdlg.h"

//#include "loadgen_maincontainer.h"

//#include <loadgen.rsg>

#include <coeutils.h>

#include <bautils.h>

#include <eikenv.h>

//#include <AknQueryDialog.h>

#include <e32math.h> 

#include <u32hal.h>

#include <hal.h> 

#include <hal_data.h>

#include <ecam.h>

//#include <aknnotewrappers.h>

#include <featdiscovery.h>

const TInt KZeroIndex = 0;

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

CEngine* CEngine::NewL(EngineWrapper *aEngineWrapper)

    {

    CEngine* self = new(ELeave) CEngine;

    CleanupStack::PushL(self);

    self->ConstructL(aEngineWrapper);

    CleanupStack::Pop();

    return self;

    }

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

CEngine::CEngine() : CActive( EPriorityStandard ),

		iAsyncRunLoadOperation( CActive::EPriorityStandard )

    {

	TCallBack asyncRunSuspRes( AsyncRunLoadOperation, this );

	iAsyncRunLoadOperation.Set(asyncRunSuspRes);

    }

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

void CEngine::ConstructL(EngineWrapper *aEngineWrapper)

    {

	iEngineWrapper = aEngineWrapper;

    iReferenceNumber = 0;

	iCurrentItemIndex = 0;

	iEditExistingLoad = EFalse;

    iEnv = CEikonEnv::Static();

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

    iLoadItemList = new(ELeave) CLoadItemList(64);

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

    CActiveScheduler::Add(this);

  }

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

TInt CEngine::AsyncRunLoadOperation( TAny* aObject )

	{

	TRAPD( err, static_cast<CEngine*>( aObject )->AsyncRunLoadOperationL() );

	return err;

	}

void CEngine::AsyncRunLoadOperationL()

	{

	switch(iLoadOperation)

		{

		case EEditLoad:

			break;

		case ESuspResLoad:

			SuspendOrResumeSelectedOrHighlightedItemsL();

			break;

		case EStopLoad:

			if(iSelectionIndexes)

				{

				StopSelectedOrHighlightedItemsL(iSelectionIndexes);

				}

			break;

		}

	}

void CEngine::AsyncSuspRes()

	{

	iLoadOperation = ESuspResLoad;

	iAsyncRunLoadOperation.CallBack();

	}

void CEngine::AsyncStopLoad( const CArrayFix<TInt>* aSelectionIndexes )

	{

	iSelectionIndexes = aSelectionIndexes;

	iLoadOperation = EStopLoad;

	iAsyncRunLoadOperation.CallBack();

	}

void CEngine::AsyncEditLoad()

	{

	iLoadOperation = EEditLoad;

	iAsyncRunLoadOperation.CallBack();

	}

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

void CEngine::ActivateEngineL()

    {

    // load settings

    //TRAP_IGNORE(LoadSettingsL());

	// RAM

	TMemoryInfoV1Buf ramMemory;

	UserHal::MemoryInfo(ramMemory);

	TInt freeRam = ramMemory().iFreeRamInBytes;

    // set defaults to attributes

    iCpuLoadAttributes.iId = 0;

    iCpuLoadAttributes.iPriority = EThreadPriorityTypeNormal;

    iCpuLoadAttributes.iMode = ECpuLoadModeYielding;

    iCpuLoadAttributes.iType = ECpuLoadTypePeriodic;

    iCpuLoadAttributes.iLength = 4000;

    iCpuLoadAttributes.iIdle = 2000;

    iCpuLoadAttributes.iRandomVariance = 0;

    iCpuLoadAttributes.iCpu = KCPUSelection_FreeScheduling; // set CPU as "undefined" (can be >= 0 only in SMP environments)

    iCpuLoadAttributes.iCpuCount = UserSvr::HalFunction(EHalGroupKernel, KHalFunction_EKernelHalNumLogicalCpus, 0, 0);

    if( iCpuLoadAttributes.iCpuCount < 1 || iCpuLoadAttributes.iCpuCount > KMaxCPUs )

        {

        // HAL may not support this function, so let's use CPU count 1:

        iCpuLoadAttributes.iCpuCount = 1;

        }

    iMemoryEatAttributes.iId = 0;

    iMemoryEatAttributes.iPriority = EThreadPriorityTypeNormal;

    iMemoryEatAttributes.iSource = 0;

    iMemoryEatAttributes.iType = EMemoryEatTypeMemoryToBeLeft;

    iMemoryEatAttributes.iBuffer = 16*1024;

    iMemoryEatAttributes.iIdle = 0;

    iMemoryEatAttributes.iAmount = freeRam;//0;

    iMemoryEatAttributes.iRandomMin = 1000000;

    iMemoryEatAttributes.iRandomMax = 1500000;

    iMemoryEatAttributes.iAmountDes.Copy(KNullDesC);

    iMemoryEatAttributes.iRandomMinDes.Copy(KNullDesC);

    iMemoryEatAttributes.iRandomMaxDes.Copy(KNullDesC);

    iMemoryEatAttributes.iRandomVariance = 0;

    iPhoneCallAttributes.iId = 0;

    iPhoneCallAttributes.iPriority = EThreadPriorityTypeNormal;

    iPhoneCallAttributes.iDestination.Copy(_L("+358"));

    iPhoneCallAttributes.iLength = 60000;

    iPhoneCallAttributes.iIdle = 10000;

    iPhoneCallAttributes.iRandomVariance = 0;

    iNetConnAttributes.iId = 0;

    iNetConnAttributes.iPriority = EThreadPriorityTypeNormal;

    iNetConnAttributes.iDestination.Copy(_L("http://www.nokia.com"));

    iNetConnAttributes.iIdle = 10000;

    iNetConnAttributes.iRandomVariance = 0;

    iKeyPressAttributes.iId = 0;

    iKeyPressAttributes.iPriority = EThreadPriorityTypeNormal;

    iKeyPressAttributes.iHeartBeat = 100;

    iKeyPressAttributes.iRandomVariance = 0;

    iPointerEventAttributes.iId = 0;

    iPointerEventAttributes.iPriority = EThreadPriorityTypeNormal;

    iPointerEventAttributes.iHeartBeat = 1000;

    iPointerEventAttributes.iRandomVariance = 0;

    iMessageAttributes.iId = 0;

    iMessageAttributes.iPriority = EThreadPriorityTypeNormal;

    iMessageAttributes.iMessageType = EMessageTypeSMS;

    iMessageAttributes.iDestination.Copy(_L("+358"));

    iMessageAttributes.iAmount = 5;

    iMessageAttributes.iLength = 160;

    iMessageAttributes.iIdle = 15000;

    iMessageAttributes.iRandomVariance = 0;

    iApplicationsAttributes.iId = 0;

    iApplicationsAttributes.iLaunchingInterval = 2000;

    iApplicationsAttributes.iPriority = EThreadPriorityTypeNormal;

    iApplicationsAttributes.iKeyPressType = EApplicationsKeyPressTypeNone;

    iApplicationsAttributes.iMaxOpen = 20;

    iApplicationsAttributes.iHeartBeat = 50;

    iApplicationsAttributes.iRandomVariance = 0;

    iPhotoCaptureAttributes.iId = 0;

    iPhotoCaptureAttributes.iPriority = EThreadPriorityTypeNormal;

    iPhotoCaptureAttributes.iIdle = 10000;

    iPhotoCaptureAttributes.iRandomVariance = 0;        

    iPhotoCaptureAttributes.iCameraCount = CCamera::CamerasAvailable();

    if(iPhotoCaptureAttributes.iCameraCount > 0)

        {

        iPhotoCaptureAttributes.iCamera = 0; // Main camera

        }

    else

        {

        iPhotoCaptureAttributes.iCamera = -1;

        }

    iBluetoothAttributes.iId = 0;

    iBluetoothAttributes.iPriority = EThreadPriorityTypeNormal;

    iBluetoothAttributes.iIdle = 10000;

    iBluetoothAttributes.iRandomVariance = 0;

    iBluetoothAttributes.iBluetoothSupported = CFeatureDiscovery::IsFeatureSupportedL(KFeatureIdBt);

    }

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

void CEngine::DeActivateEngineL()

    {

    Cancel();

    // for a faster exit, send the application to background

    TApaTask selfTask(iEnv->WsSession());

    selfTask.SetWgId(iEnv->RootWin().Identifier());

    selfTask.SendToBackground();

    }

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

CEngine::~CEngine()

    {

    if (iLoadItemList)

        {

        DeleteAllLoadItems();

        delete iLoadItemList;

        }

    if ( iApplicationsAttributes.iAppsArray )

        {

        delete iApplicationsAttributes.iAppsArray;

        }

    iTimer.Close();

    iLs.Close();

    }

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

void CEngine::DoCancel()

    {

    iTimer.Cancel();

    }

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

void CEngine::RunL()

    {

    // continue    

    //iTimer.After(iStatus, 400000);

    //SetActive();

    }

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

void CEngine::StartNewLoadL(TInt aCommand)

    {

    // show new load query

	//CLoadGenLoadTypeEditorBase* dlg = NULL;

	if(aCommand == ELoadGenCmdNewLoadPhotoCaptures && 

	   iPhotoCaptureAttributes.iCameraCount == 0)

		{

		_LIT(message, "Cameras not available");

		iEngineWrapper->ShowNote(message);

		return;

		}

	if(aCommand == ELoadGenCmdNewLoadBluetooth &&

	   iBluetoothAttributes.iBluetoothSupported == EFalse)

		{

		_LIT(message, "Bluetooth device not available");

		iEngineWrapper->ShowNote(message); 

		return;

		}

	/*

    switch ( aCommand )

        {

        case ELoadGenCmdNewLoadCPULoad:

            {

            //dlg = CLoadGenCPULoadEditor::NewL(iCpuLoadAttributes);

            break;

            }

        case ELoadGenCmdNewLoadEatMemory:

            {

            //dlg = CLoadGenMemoryEatEditor::NewL(iMemoryEatAttributes);

            break;

            }

        case ELoadGenCmdNewLoadPhoneCall:

            {

            //dlg = CLoadGenPhoneCallEditor::NewL(iPhoneCallAttributes);

            break;

            }

        case ELoadGenCmdNewLoadNetConn:

            {

            //dlg = CLoadGenNetConnEditor::NewL(iNetConnAttributes);

            break;

            }

        case ELoadGenCmdNewLoadKeyPress:

            {

            //dlg = CLoadGenKeyPressEditor::NewL(iKeyPressAttributes);

            break;

            }               

        case ELoadGenCmdNewLoadMessages:

            {

            //dlg = CLoadGenMessagesEditor::NewL( iMessageAttributes );

            break;

            }

        case ELoadGenCmdNewLoadApplications:

            {

            //dlg = CLoadGenApplicationsEditor::NewL( iApplicationsAttributes );

            break;

            }

        case ELoadGenCmdNewLoadPhotoCaptures:

            {

            if( iPhotoCaptureAttributes.iCameraCount > 0 )

                {

                //dlg = CLoadGenPhotoCaptureEditor::NewL( iPhotoCaptureAttributes );

                }

            else

                {

                _LIT(message, "Cameras not available");

				iEngineWrapper->ShowNote(message); 

                //CAknErrorNote* errorNote = new(ELeave) CAknErrorNote;

                //errorNote->ExecuteLD(message);

				return;

                }

            break;

            }

        case ELoadGenCmdNewLoadBluetooth:

            {

            if( iBluetoothAttributes.iBluetoothSupported )

                {

                //dlg = CLoadGenBluetoothEditor::NewL(iBluetoothAttributes);                

                }

            else

                {

                _LIT(message, "Bluetooth device not available");

				iEngineWrapper->ShowNote(message); 

                //CAknErrorNote* errorNote = new(ELeave) CAknErrorNote;

                //errorNote->ExecuteLD(message);

                return;

                }

            break;

            }

        case ELoadGenCmdNewLoadPointerEvent:

            {

            //dlg = CLoadGenPointerEventEditor::NewL(iPointerEventAttributes);

            break;

            } 

        default:

            {

            User::Panic(_L("Wrong new load"), 111);

            break;

            }

        }

	*/

	iEditExistingLoad = EFalse;

    iEngineWrapper->OpenLoadSettings(aCommand, EFalse); // = dlg->RunQueryLD();

    // set back title

	//if (iMainContainer) 

    //    iMainContainer->SetDefaultTitlePaneTextL();

    // start creating new load if dialog accepted

    //if (dlgResult)

    //    {

    //    DoStartNewLoadL(aCommand);

    //    }

	// DoStartNewLoadL() called from engine wrapper slot function newLoadAdded() after

	// load settings closed by user select: ok.

    }

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

void CEngine::EditLoadL(TInt aIndex)

    {

	CLoadBase* aItem = iLoadItemList->At(aIndex);

	iCurrentItemIndex = aIndex;

	iEditExistingLoad = ETrue;

    // suspend current

	if (aItem->State() == CLoadBase::ELoadStateRunning)

		{

		iLoadStatusBeforeEdit = CLoadBase::ELoadStateRunning;

		aItem->Suspend();

		}

    // show new load query

	/* CLoadGenLoadTypeEditorBase* dlg = NULL;

    switch ( aItem->Type() )

        {

        case ELoadGenCmdNewLoadCPULoad:

            {

            //dlg = CLoadGenCPULoadEditor::NewL(static_cast<CCPULoad*>(aItem)->Attributes(), ETrue);

            break;

            }

        case ELoadGenCmdNewLoadEatMemory:

            {

            //dlg = CLoadGenMemoryEatEditor::NewL(static_cast<CMemoryEat*>(aItem)->Attributes(), ETrue);

            break;

            }

        case ELoadGenCmdNewLoadPhoneCall:

            {

            //dlg = CLoadGenPhoneCallEditor::NewL(static_cast<CPhoneCall*>(aItem)->Attributes(), ETrue);

            break;

            }

        case ELoadGenCmdNewLoadNetConn:

            {

            //dlg = CLoadGenNetConnEditor::NewL(static_cast<CNetConn*>(aItem)->Attributes(), ETrue);

            break;

            }

        case ELoadGenCmdNewLoadKeyPress:

            {

            //dlg = CLoadGenKeyPressEditor::NewL(static_cast<CKeyPress*>(aItem)->Attributes(), ETrue);

            break;

            }       

        case ELoadGenCmdNewLoadMessages:

            {

            //dlg = CLoadGenMessagesEditor::NewL(static_cast<CMessages*>(aItem)->Attributes(), ETrue);

            break;

            }

        case ELoadGenCmdNewLoadApplications:

            {

            //dlg = CLoadGenApplicationsEditor::NewL( static_cast<CAppLauncher*>(aItem)->Attributes(), ETrue );

            break;

            }

        case ELoadGenCmdNewLoadPhotoCaptures:

            {

            //dlg = CLoadGenPhotoCaptureEditor::NewL( static_cast<CPhotoCapture*>(aItem)->Attributes(), ETrue );

            break;

            }

        case ELoadGenCmdNewLoadBluetooth:

            {

            //dlg = CLoadGenBluetoothEditor::NewL( static_cast<CBluetooth*>(aItem)->Attributes(), ETrue );

            break;

            }

        case ELoadGenCmdNewLoadPointerEvent:

            {

            //dlg = CLoadGenPointerEventEditor::NewL(static_cast<CPointerEvent*>(aItem)->Attributes(), ETrue);

            break;

            }

        default:

            {

            User::Panic(_L("Wrong edit load"), 114);

            break;

            }

        }

		*/

	iEngineWrapper->OpenLoadSettings(aItem->Type(), iEditExistingLoad);

    // ExistingLoadEditedL method called from engine wrapper when load settings view close signal received.

	//TBool dlgResult = ETrue; //dlg->RunQueryLD();

    // set back title

	// TODO: check this.

    //if (iMainContainer)

    //    iMainContainer->SetDefaultTitlePaneTextL();

    // change priority of the load item

    //aItem->SetPriority();

    // resume execution the item

    //aItem->Resume();

    //if (dlgResult)

    //    RefreshViewL(EFalse);

    }

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

void CEngine::ExistingLoadEditedL()

	{

	CLoadBase* aItem = iLoadItemList->At(iCurrentItemIndex);

	// change priority of the load item

    aItem->SetPriority();

	if (iLoadStatusBeforeEdit == CLoadBase::ELoadStateRunning)

		{

		// resume execution the item

		aItem->Resume();

		RefreshViewL(EFalse);

		}

	// cancel:

	}

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

void CEngine::ExistingLoadEditCancelled()

	{

	if (iLoadStatusBeforeEdit == CLoadBase::ELoadStateRunning)

		{