/*

* 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 <e32base.h>

#include <e32cons.h>

#include <e32svr.h>

#include <f32file.h>

#include "atconsoleui.h"

#include "atconsoleviews.h"

// CONSTANTS

_LIT( KNameTxt, "AT CONSOLE UI" );

// FORWARD DECLARATIONS

LOCAL_C void MainL();

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

// CConsoleMain::NewL()

// Construct the console main class.

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

//

CConsoleMain* CConsoleMain::NewL( )

    {

    CConsoleMain* self = new ( ELeave ) CConsoleMain();

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CConsoleMain::ConstructL()

// Second level constructor.

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

//

void CConsoleMain::ConstructL( )

    {

    // Construct the console

    iConsole = Console::NewL( KNameTxt,

                             TSize( KConsFullScreen, KConsFullScreen ) );

    iStorageServerOpen = EFalse;

    iConsole->Printf(_L("\nAnalyzeTool console starting\n"));

    }

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

// CConsoleMain::CConsoleMain()

// C++ default constructor.

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

//

CConsoleMain::CConsoleMain()

    {

    }

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

// CConsoleMain::~CConsoleMain()

// Destructor.

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

//

CConsoleMain::~CConsoleMain()

    {

    // Close storage server

    iStorageServer.Close();

    delete iReader;

    iReader = NULL;

    delete iScroller;

    iScroller = NULL;

    delete iConsole;

    iConsole = NULL;

    delete iMainView;

    iMainView = NULL;

    iSubTestProcesses.Close();

    iProcesses.Close();

    }

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

// CConsoleMain::StartL()

// Construct menu objects and start the menu handling.

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

//

TInt CConsoleMain::StartL()

    {

    // Construct keystroke reader

    iReader = CConsoleReader::NewL( this, iConsole );

    // Construct the main menu

    iMainView = CMainView::NewL( this, NULL, _L( "Processes view" ) );

    // Connect to the storage server

    TInt error = iStorageServer.Connect();

    if( error != KErrNone )

        {

        // Notify if error occurs

        }

    else

        {

        iStorageServerOpen = ETrue;

        iStorageServer.GetProcessesL( iProcesses );

        }

    // TEST

    /*TATProcessInfo pr1;

    pr1.iProcessId = 1;

    TBuf8<KMaxProcessName> pr1Name;

    pr1Name.Copy( _L("MemoryLeaker.exe") );

    pr1.iProcessName.Copy( pr1Name );

    pr1.iStartTime = 1234556789;

    iProcesses.Append( pr1 );

    TATProcessInfo pr2;

    pr2.iProcessId = 2;

    TBuf8<KMaxProcessName> pr2Name;

    pr2Name.Copy( _L("ConsoleApplication.exe") );

    pr2.iProcessName.Copy( pr2Name );

    pr2.iStartTime = 12345567559;

    iProcesses.Append( pr2 );

    TATProcessInfo pr3;

    pr3.iProcessId = 3;

    TBuf8<KMaxProcessName> pr3Name;

    pr3Name.Copy( _L("Player.exe") );

    pr3.iProcessName.Copy( pr3Name );

    pr3.iStartTime = 1234577789;

    iProcesses.Append( pr3 );*/

    // TEST END

    if ( iProcesses.Count() > KErrNone )

        {

        CView* processMenu  = NULL;

        for ( TInt count = 0 ; count < iProcesses.Count() ; count++ )

            {

            TBuf<KMaxProcessName> processName;

            processName.Copy( iProcesses[ count ].iProcessName );

            TInt64 processId = iProcesses[ count ].iProcessId;

            // Create and add menu

            processMenu   = CProcessInfoView::NewL( this, iMainView, processName, processId );

            iMainView->AddItemL( processMenu );  

            }           

        }

    iScroller = CScrollerTimer::NewL ( this );

    iScroller->StartL();

    // Print the main menu

    iCurrentView = iMainView;

    iCurrentView->PrintViewL( CView::EViewPrint );

    // Start to process keyboard events

    iReader->StartL();

    return KErrNone;

    }

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

// CConsoleMain::Processes()

// Returns processes.

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

//

RArray<TATProcessInfo> CConsoleMain::Processes()

    {

    return iProcesses;

    }

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

// CConsoleMain::KeyPressedL()

// Process keyboard events. Print new menu.

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

//

void CConsoleMain::KeyPressedL()

    {

    TBool cont = ETrue;

    // Read the key

    TKeyCode key = iConsole->KeyCode();

    CView* tmp = iCurrentView;

    // Update the screen

    TimerUpdate();

    // Let the menu handle the key press

    TRAPD( err, 

        iCurrentView = iCurrentView->SelectL( key, cont );

        );

    if( err != KErrNone )

        {

        User::InfoPrint( 

            _L( "Processing keystroke failed" ) );  

        }

    if ( iCurrentView == NULL )

        {

            iCurrentView = tmp;

        }

   // If "not-exit" key pressed, continue

    if ( cont )

        {

        // Either only update old menu or new menu.

        if ( tmp == iCurrentView )

            {

            TRAP( err, iCurrentView->PrintViewL( CView::EViewRefresh ); );

            }

        else

            {

            TRAP( err, iCurrentView->PrintViewL( CView::EViewPrint ); )

            }

        if( err != KErrNone )

            {

            User::InfoPrint( 

                _L( "Printing view failed" ) );  

            }

        // Enable keystrokes

        iReader->StartL();

        }

    else

        {

        // Stop all subtests before closing handles

        StopAllSubtestsL();

        // "Exit", stop scheduler and exit

        CActiveScheduler::Stop();

        }

    }

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

// CConsoleMain::StopAllSubtestsL()

// Stops all subtests which are running

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

//

void CConsoleMain::StopAllSubtestsL()

    {

    TInt index( KErrNone );

    RArray<TATProcessInfo> processes;

    iStorageServer.GetProcessesL( processes );

    while ( index < processes.Count() )

        {

        TUint processId = processes[ index ].iProcessId;

        _LIT8( KSubTestId, "ATConsoleUiSubTest" );

        TInt stopErr = iStorageServer.StopSubTest( processId, KSubTestId );

        TInt find = iSubTestProcesses.Find( processId );

        if ( find > KErrNotFound )

            {

            iSubTestProcesses.Remove( find );

            if ( iSubTestProcesses.Count() == KErrNone )

                {

                iSubTestProcesses.Reset();

                }  

            }

        index++;

        }

    processes.Close();

    }

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

// CConsoleMain::Close()

// Close instance.

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

//

void CConsoleMain::Close( TInt aHandle )

    {

    if( aHandle < 0 )

        {

        return;

        } 

    }

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

// CConsoleMain::GetConsole()

// Returns the console.

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

//

CConsoleBase* CConsoleMain::GetConsole()

    {

    return iConsole;

    }

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

// CConsoleMain::TimerUpdate()

// Updates current menu from timer.

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

//

void CConsoleMain::TimerUpdate()

    {

    // Update processes

    if ( iCurrentView->Name().Compare( _L( "Processes view" ) ) == KErrNone )

        {

        UpdateProcessesL();

        iCurrentView->ResetItems();

        if ( iProcesses.Count() > KErrNone )

            {

            CView* processMenu  = NULL;

            for ( TInt count = 0 ; count < iProcesses.Count() ; count++ )

                {

                TBuf<KMaxProcessName> processName;

                processName.Copy( iProcesses[ count ].iProcessName );

                TInt64 processId = iProcesses[ count ].iProcessId;

                // Create and add menu

                processMenu   = CProcessInfoView::NewL( this, iMainView, processName, processId );

                iMainView->AddItemL( processMenu );  

                }           

             }                      

        }

    iCurrentView->TimerUpdate();

    }

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

// CConsoleMain::UpdateProcessesL()

// Updates processes.

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

//

void CConsoleMain::UpdateProcessesL()

    {

    if ( iStorageServerOpen )

        {

        iStorageServer.GetProcessesL( iProcesses );

        }

    }

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

// CConsoleMain::SetProcessSubTestStart()

// Starts subtest for a process.

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

//

void CConsoleMain::SetProcessSubTestStart( TUint aProcessId )

    {

    // load the kernel side device driver

    TInt loadErr = User::LoadLogicalDevice( KAnalyzeToolLddName );

    TBool driverLoaded( EFalse );

    if ( loadErr == KErrNone || loadErr == KErrAlreadyExists )

        {

        driverLoaded = ETrue;

        }

    RAnalyzeTool analyzeTool;

    TInt driverOpen = analyzeTool.Open();

    TInt handleCount( KErrNone );

    if ( driverOpen == KErrNone )

        {       

        TATProcessHandlesBuf params;

        params().iProcessId = aProcessId;

        analyzeTool.GetCurrentHandleCount( params );

        handleCount = params().iCurrentHandleCount;

        }

    _LIT8( KSubTestId, "ATConsoleUiSubTest" );

    TInt startErr = iStorageServer.StartSubTest( aProcessId, KSubTestId, handleCount );

    if ( KErrNone == startErr )

        {

        iSubTestProcesses.Append( aProcessId );

        }

    // The count of device driver users

    TClientCountBuf count;

    // Check the flag

    if ( driverOpen == KErrNone )

        {

        analyzeTool.ClientCount( count );

        analyzeTool.Close();

        }  

    // Check the flag

    if ( driverLoaded )

        {

        // Check if there is another user for device driver

        if ( count().iClientCount <= 1 )

            {

            // There was no other users -> unload the device driver

            User::FreeLogicalDevice( KAnalyzeToolLddName );

            }

        }

    }

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

// CConsoleMain::SetProcessSubTestStop()

// Stops subtest for a process.

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

//

void CConsoleMain::SetProcessSubTestStop( TUint aProcessId )

    {

    // Load the kernel side device driver

    TInt loadErr = User::LoadLogicalDevice( KAnalyzeToolLddName );

    TBool driverLoaded( EFalse );

    if ( loadErr == KErrNone || loadErr == KErrAlreadyExists )

        {

        driverLoaded = ETrue;

        }

    RAnalyzeTool analyzeTool;

    TInt driverOpen = analyzeTool.Open();

    TInt handleCount( KErrNone );

    if ( driverOpen == KErrNone )

        {  

        TATProcessHandlesBuf params;

        params().iProcessId = aProcessId;

        analyzeTool.GetCurrentHandleCount( params );

        handleCount = params().iCurrentHandleCount;

        }

    _LIT8( KSubTestId, "ATConsoleUiSubTest" );

    TInt stopErr = iStorageServer.StopSubTest( aProcessId, KSubTestId, handleCount );

    if ( KErrNone == stopErr )

        {

        TInt index = iSubTestProcesses.Find( aProcessId );

        if ( index > KErrNotFound )

            {

            iSubTestProcesses.Remove( index );

            if ( iSubTestProcesses.Count() == KErrNone )

                iSubTestProcesses.Reset();

            }             

        }

    // The count of device driver users

    TClientCountBuf count;

    // Check the flag

    if ( driverOpen == KErrNone )

        {

        analyzeTool.ClientCount( count );

        analyzeTool.Close();

        }

    // Check the flag

    if ( driverLoaded )

        {

        // Check if there is another user for device driver

        if ( count().iClientCount <= 1 )

            {

            // There was no other users -> unload the device driver

            User::FreeLogicalDevice( KAnalyzeToolLddName );

            }

        }

    }

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

// CConsoleMain::IsSubTestRunning()

// Returns ETrue if subtest is running for a process.

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

//

TInt CConsoleMain::IsSubTestRunning( TUint aProcessId )

    {

    return iSubTestProcesses.Find( aProcessId );

    }

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

// CScrollerTimer::NewL()

// Construct a new CScrollerTimer object.

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

//

CScrollerTimer* CScrollerTimer::NewL( CConsoleMain* aMain )

    {

    CScrollerTimer* self = new ( ELeave ) CScrollerTimer();

    CleanupStack::PushL( self );

    self->ConstructL( aMain );

    CleanupStack::Pop( self );

    return self;

    }

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

// CScrollerTimer::ConstructL()

// Second level constructor.

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

//

void CScrollerTimer::ConstructL( CConsoleMain* aMain )

    {

    // Store module information

    iMain = aMain;

    iTimer.CreateLocal();

    CActiveScheduler::Add ( this );

    }

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

// CScrollerTimer::CScrollerTimer()

// Constructor.

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

//

CScrollerTimer::CScrollerTimer() : CActive (CActive::EPriorityStandard)

    {

    }

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

// CScrollerTimer::~CScrollerTimer()

// Destructor.

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

//

CScrollerTimer::~CScrollerTimer( )

    {

    Cancel();

    iTimer.Close();

    }

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

// CScrollerTimer::StartL()

// Start timer.

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

//

void CScrollerTimer::StartL( )

    {

    SetActive();