/*

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

*

*/

// INCLUDE FILES

#include "profiler_gui_samplersettingsviewdlg.h"

#include "profiler_gui_model.h"

#include "profiler_gui_app.h"

#include "profiler_gui_settingsviewdlg.h"

#include "profiler_gui_maincontainer.h"

#include "profiler_gui.hrh"

#include <piprofilerui.rsg>

#include <coeutils.h>

#include <bautils.h>

#include <eikenv.h>

#include <AknQueryDialog.h>

#include <AknGlobalNote.h>

#include <aknmessagequerydialog.h> 

#include <e32math.h> 

#include <akntitle.h> 

#include <s32file.h>

#include <aknnotewrappers.h>

#include <sysutil.h>

// UIDs

#include <piprofiler/EngineUIDs.h>

#include <piprofiler/ProfilerTraces.h>

#include <piprofiler/ProfilerSession.h>

// LITERALS

_LIT(KAppName, "PI Profiler");

_LIT(KWarningNote, "NOTE: output changed!\n");

_LIT(KProfilerEngineExe, "PIProfilerEngine.exe");

// literals for default general setting values

_LIT8(KTraceOutput, "file_system");

_LIT8(KTraceDebugOutput, "debug_output");

_LIT8(KProfilerDefaultDrive, "E:\\data");

_LIT8(KProfilerDefaultPrefix, "Profiler_#");

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

CProfilerGuiModel* CProfilerGuiModel::NewL() 

	{

	CProfilerGuiModel* self = new(ELeave) CProfilerGuiModel;

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

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

CProfilerGuiModel::CProfilerGuiModel() : CActive(EPriorityStandard)

	{

	}

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

void CProfilerGuiModel::ConstructL()

	{

	// initialize basic settings

	iDrawState = EDrawStateInvalid;

	iReferenceNumber = 0;

	iState = MProfilerStatusObserver::EIdle;

    iEnv = CEikonEnv::Static();

    // profiler engine specific initialization

    LaunchProfilerEngineL();

    // max sampler item list length is 64, i.e. max 64 sampler plugins loaded 

    iSamplerItemList = new(ELeave) CSamplerItemList(64);

    // initialize attribute arrays

    iSamplerAttributes = new(ELeave) CArrayFixFlat<TSamplerAttributes>(20); // max sampler count is 20

    // engine status checker

    iStatusChecker = CProfilerEngineStatusChecker::NewL();

    iStatusChecker->SetObserver(this);

	CActiveScheduler::Add(this);

	}

void CProfilerGuiModel::UpdateUIRunningStateL()

    {

    // prevent the control of sampler specific settings during the trace 

    iMainContainer->SetDimmed(ETrue);

    // update status pane

    iMainView->UpdateStatusPaneL(iState);

    // show an info popup showing the logging method

    iMainContainer->ShowWriterInfoPopupL(KNullDesC);

    // refresh view

    RefreshViewL();

    }

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

void CProfilerGuiModel::NotifyContainerReadyL()

	{

	// load initial plugins

    LoadPluginsL();

    // get the initial state

    if( iStatusChecker->GetInitialState() == MProfilerStatusObserver::ERunning )

        {

        // set model state to restarting and grabbing an existing profiler process

        iState = MProfilerStatusObserver::ERestarting;

        // update status pane to correspond the running mode

        UpdateUIRunningStateL();

        // set model state to running

        iState = MProfilerStatusObserver::ERunning;

        }

	}

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

void CProfilerGuiModel::ActivateModelL()

	{

	// load general settings

	if( LoadGeneralSettingsL() != KErrNone )

	    {

	    LOGTEXT(_L("ProfilerGuiAppUi::ActivateModelL - could not connect profiler engine"));

	    }

	}

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

void CProfilerGuiModel::DeActivateModelL()

	{

	Cancel();

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

    TApaTask selfTask(iEnv->WsSession());

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

    selfTask.SendToBackground();

	}

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

CProfilerGuiModel::~CProfilerGuiModel()

	{

    if (iSamplerItemList)

        {

        DeleteAllSamplerItems();

        delete iSamplerItemList;

        iSamplerItemList = NULL;

        }

    if(iStatusChecker)

        {

        iStatusChecker->Cancel();

        delete iStatusChecker;

        iStatusChecker = NULL;

        }

    if(iSamplerAttributes)

        {

        iSamplerAttributes->Reset();

        delete iSamplerAttributes;

        iSamplerAttributes = NULL;

        }

    }

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

void CProfilerGuiModel::DoCancel()

	{

	}

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

void CProfilerGuiModel::RunL()

	{

	}

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

void CProfilerGuiModel::SetMainContainer(CProfilerGuiMainContainer* aContainer)

    {

    iMainContainer = aContainer;

    iDrawState = EDrawStateMain;

    }

void CProfilerGuiModel::UpdateState(TInt aState)

	{

	iState = aState;

	}

TInt CProfilerGuiModel::FindProcessL(RProcess& aProc)

    {

    TProcessId engId;

    TFindProcess procName;

    procName.Find(_L("PIProfilerEngine.exe*"));

    TFullName aResult;

    TFullName aResult2;

    TInt err(KErrNone);

    // find the first appearance

    err = procName.Next(aResult);

    if(err != KErrNone)

        {

        // did not find any engine process

        return err;

        }

    else

        {

        err = aProc.Open(procName);

        if(err == KErrNone)

            {

            if(aProc.ExitCategory().Length() > 0)

                {

                aProc.Close();

                // process already exited => create a new one

                return KErrNotFound;

                }

            aProc.Close();

            }

        }

//    // check now if a second appearance exists in process list, 

//    // i.e. engine started from eshell => two engine processes appear in normal case

//    procName.Next(aResult2);

//

//    // check if aResult2 contained the second appearance of profiler engine

//    if(aResult2.CompareF(aResult) > 0)

//        {

//        // other process found, i.e. right process to communicate with, in case started from eshell

//        err = aProc.Open(procName);

//        if(err == KErrNone)

//            {

//            if(aProc.ExitCategory().Length() > 0)

//                {

//                // process already exited => create a new one

//                return KErrNotFound;

//                }

//            aProc.Close();

//            }

//        }

    return err;

    }

void CProfilerGuiModel::LaunchProfilerEngineL()

    {

    LOGTEXT(_L("CProfilerGuiModel::LaunchProfilerEngineL - start"));

    TRequestStatus stat = KRequestPending;

    RProcess proc;

    TInt err(KErrNone);

    // check if process exists

    err = FindProcessL(proc);

    // check if already exists and don't start a new eshell profiling

    if( err == KErrNotFound )

        {

        // try create new process

        err = proc.Create(KProfilerEngineExe, _L(""));

        // check if RProcess::Create() succeeded

        if( err == KErrNone )

            {

            // Trigger rendezvous on the supplied TRequestStatus object

            proc.Rendezvous(stat); 

            // kick off the engine process

            proc.Resume();

            // wait for the constructor to complete 

            User::WaitForRequest(stat); 

            // just lose the handle

            proc.Close();

            }

        }

    // Increase the client reference count in server:

    AttachClient();    

    }

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

// CProfilerGuiModel::TerminateProfilerL()

// Stops Profiler Engine if it has been launched by this launcher. 

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

void CProfilerGuiModel::TerminateProfilerL()

    {

    LOGTEXT(_L("CProfilerGuiModel::TerminateProfiler - entry"));

    // exit profiler engine 

    RProfiler::ExitProfiler();

    LOGTEXT(_L("CProfilerGuiModel::TerminateProfiler - exit"));

    }

void CProfilerGuiModel::AttachClient()

    {

    LOGTEXT(_L("CProfilerGuiModel::AttachClient - entry"));

    // 

    RProfiler::AttachClient();

    LOGTEXT(_L("CProfilerGuiModel::AttachClient - exit"));

    }

void CProfilerGuiModel::RemoveClient()

    {

    LOGTEXT(_L("CProfilerGuiModel::RemoveClient - entry"));

    // 

    RProfiler::RemoveClient();

    LOGTEXT(_L("CProfilerGuiModel::RemoveClient - exit"));

    }

void CProfilerGuiModel::AddNewSamplersL(CArrayFixFlat<TSamplerAttributes>& aAttributes)

	{

	TSamplerAttributes item;

	TInt count(aAttributes.Count());

	// loop the attribute array and insert them into view list

	for (TInt i(0);i<count;i++)

		{

    	// get a TSamplerAttributes from list at a time  

		item = aAttributes.At(i);

		iReferenceNumber++;

        // add item to the array

        AppendToSamplerItemListL(item);

        // update the listbox

        RefreshViewL(EFalse);

        // set item index to the begin	

        iMainContainer->ListBox()->SetCurrentItemIndexAndDraw(iMainContainer->ListBox()->Model()->NumberOfItems()-1);

		}

    // refresh again

    if(iReferenceNumber > 0)

        {

        RefreshViewL(ETrue);

        }

	}

TBool CProfilerGuiModel::CheckTraceLocationSanityL(TGeneralAttributes& aAttr, TBool aQuietCheck)

    {

    RFs fs;

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

    TBuf<32> drive;

    CnvUtfConverter::ConvertToUnicodeFromUtf8(drive, aAttr.iSaveFileDrive);

    TDriveUnit driveUnit = TDriveUnit(drive);

    TBool ret(EFalse);

    // check that the root folder is correct

    if (drive.Length() > 2 && BaflUtils::CheckFolder(fs, drive.Left(3)) == KErrNone )

        {

        // check then if drive has still some space

        if(!SysUtil::DiskSpaceBelowCriticalLevelL(&fs, 0, driveUnit))

            {

            ret = ETrue;

            }

        }

    // check if the sanity check failed

    if(!ret)

        {

        // show an error note

        if(aQuietCheck == EFalse)

            {

            CAknErrorNote* note = new(ELeave) CAknErrorNote();

            note->ExecuteLD(_L("Invalid path, check settings!"));

            }

        }

    fs.Close();

    return ret;

    }

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

TInt CProfilerGuiModel::LaunchSettingsDialogL()

    {

    // launch the settings dialog

    TGeneralAttributes newSettings = iGeneralAttributes;

    TBool quietCheck(EFalse);

    CProfilerGuiSettingsViewDlg* dlg = CProfilerGuiSettingsViewDlg::NewL(newSettings);

    TInt returnValue = dlg->ExecuteLD(R_PROFILER_GUI_SETTINGS_DIALOG);

    // check if exit command => no error note to user

    if(returnValue == EAknCmdExit)

        quietCheck = ETrue;

    // always save settings since the settings dialog does not provide a possibility to cancel

    iGeneralAttributes.iTraceOutput.Copy(newSettings.iTraceOutput);

    iGeneralAttributes.iTraceFilePrefix.Copy(newSettings.iTraceFilePrefix);

    iGeneralAttributes.iTimedSamplingPeriod = newSettings.iTimedSamplingPeriod;

    // check if debug output selected no check of

    if(newSettings.iTraceOutput.CompareF(KTraceDebugOutput) != 0)

        {

        // Check save file drive sanity

        if(CheckTraceLocationSanityL(newSettings, quietCheck))

            {

            // save the new location

            iGeneralAttributes.iSaveFileDrive.Copy(newSettings.iSaveFileDrive);

            }

        }

    // saves the general settings to profiler engine

    SaveGeneralSettingsL();   

    // make sure that the title of the application is correct

    CEikStatusPane* sp = iEnv->AppUiFactory()->StatusPane();

    CAknTitlePane* tp = static_cast<CAknTitlePane*>( sp->ControlL( TUid::Uid( EEikStatusPaneUidTitle ) ) );

    tp->SetTextL(KAppName);

    return returnValue;

    }

TPtrC CProfilerGuiModel::GetWriterInfoNoteL(const TDesC& aNote)

	{

    TBuf<256> buf;

    TBuf<128> descBuf;

    buf.Zero();

    // get active profiler since it 

    RProfiler::GetActiveWriter(buf);

	if(iGeneralAttributes.iTraceOutput.CompareF(KTraceOutput) == 0)

		{

		if(iState == MProfilerStatusObserver::EInitializing ||

                iState == MProfilerStatusObserver::ERestarting )

			{

			descBuf.Zero();

			// set the additional note if available

			buf.Copy(aNote); 

			RProfiler::GetFileName(descBuf);

			buf.Append(_L("Writing to "));

			buf.Append(descBuf);

			}

		else if(iState == MProfilerStatusObserver::EIdle ||

		        iState == MProfilerStatusObserver::EStopping ||

		        iState == MProfilerStatusObserver::ERunning )

			{

			descBuf.Zero();

            // set the additional note if available

            buf.Copy(aNote); 

            RProfiler::GetFileName(descBuf);

			buf.Append(_L("Wrote trace data to "));

			buf.Append(descBuf);

			}

		else

		    {

	          buf.Copy(KNullDesC);

		    }

		}

	else if(iGeneralAttributes.iTraceOutput.CompareF(KTraceDebugOutput) == 0)

		{

		if(iState == MProfilerStatusObserver::EInitializing ||

                iState == MProfilerStatusObserver::ERestarting )

			{

			buf.Copy(_L("Writing to debug output..."));

			}

		else if( iState == MProfilerStatusObserver::EIdle || 

	             iState == MProfilerStatusObserver::EStopping ||

		         iState == MProfilerStatusObserver::ERunning )

			{

			buf.Copy(_L("Wrote trace data to debug output"));

			}

		else

		    {

		    buf.Copy(KNullDesC);

		    }

		}

	else

	    {

	    // should not reach this point

        buf.Copy(KNullDesC);

	    }

    return TPtrC(buf);	

    }

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

TInt CProfilerGuiModel::EditSamplerL(TSamplerAttributes& aItem)

    {

    // edit sampler specific settings i.e. attributes

    TSamplerAttributes& newSettings = aItem;