/*

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

// System includes

#include <AknQueryDialog.h>

#include <charconv.h>

// Engine includes

#include <memspy/engine/memspyengine.h>

#include <memspy/engine/memspyengineobjectprocess.h>

#include <memspy/engine/memspyengineobjectthread.h>

#include <memspy/engine/memspyengineobjectcontainer.h>

#include <memspy/engine/memspyengineobjectthreadinfoobjects.h>

#include <memspy/engine/memspyengineobjectthreadinfocontainer.h>

#include <memspy/engine/memspyengineprocessmemorytracker.h>

#include <memspy/engine/memspyenginehelperprocess.h>

// User includes

#include "MemSpyUiUtils.h"

#include "MemSpyViewMainMenu.h"

#include "MemSpyContainerObserver.h"

// Literal constants

_LIT8( KMemSpyProcessMemoryTrackerXmlFileMimeType, "text/xml" );

_LIT8( KMemSpyXmlSpec_MasterSection, "memspy_process_memory_tracking" );

_LIT8( KMemSpyXmlSpec_EntryProcess, "process" );

_LIT8( KMemSpyXmlSpec_EntryProcess_SID, "sid" );

_LIT8( KMemSpyXmlSpec_HexPrefix, "0x" );

CMemSpyViewMemoryTrackingAutoStartConfig::CMemSpyViewMemoryTrackingAutoStartConfig( CMemSpyEngine& aEngine, MMemSpyViewObserver& aObserver )

:   CMemSpyViewBase( aEngine, aObserver )

    {

    }

CMemSpyViewMemoryTrackingAutoStartConfig::~CMemSpyViewMemoryTrackingAutoStartConfig()

    {

    iProcessUids.Close();

    //

    delete iParser;

    delete iConverter;

    //

    delete iXMLFileNameInstallTime;

    delete iXMLFileNameUserSupplied;

    }

void CMemSpyViewMemoryTrackingAutoStartConfig::ConstructL( const TRect& aRect, CCoeControl& aContainer, TAny* aSelectionRune )

    {

    CMemSpyViewBase::ConstructL( aRect, aContainer, aSelectionRune );

    // We only convert from UTF-8 to UTF-16

	iParser = CParser::NewL( KMemSpyProcessMemoryTrackerXmlFileMimeType, *this );

    iConverter = CCnvCharacterSetConverter::NewL();

    if  ( iConverter->PrepareToConvertToOrFromL( KCharacterSetIdentifierUtf8, iEngine.FsSession() ) == CCnvCharacterSetConverter::ENotAvailable )

	    {

		User::Leave(KErrNotFound);

		}

    // Search for standard files

    FindXmlInstallTimeL();

    FindXmlUserSuppliedL();

    // Copy items to our own temporary list...

    const RArray<TUid>& list = iEngine.HelperProcess().MemoryTrackingAutoStartProcessList();

    for( TInt i=0; i<list.Count(); i++ )

        {

        User::LeaveIfError( iProcessUids.Append( list[ i ] ) );

        }

    // Reset the title

    _LIT( KCustomTitle, "Process-Specific Memory Tracking" );

    SetTitleL( KCustomTitle );

    }

TMemSpyViewType CMemSpyViewMemoryTrackingAutoStartConfig::ViewType() const

    {

    return EMemSpyViewTypeThreadInfoItemMemoryTrackingAutoStartConfig;

    }

CMemSpyViewBase* CMemSpyViewMemoryTrackingAutoStartConfig::PrepareParentViewL()

    {

    CMemSpyViewMainMenu* parent = new(ELeave) CMemSpyViewMainMenu( iEngine, iObserver );

    CleanupStack::PushL( parent );

    parent->ConstructL( Rect(), *Parent(), (TAny*) ViewType() );

    CleanupStack::Pop( parent );

    return parent;

    }

TBool CMemSpyViewMemoryTrackingAutoStartConfig::HandleCommandL( TInt aCommand )

    {

    TBool handled = ETrue;

    //

    switch ( aCommand )

        {

    case EMemSpyCmdMemoryTrackingAutoStartItemAdd:

        OnCmdItemAddL();

        break;

    case EMemSpyCmdMemoryTrackingAutoStartItemEdit:

        OnCmdItemEditL();

        break;

    case EMemSpyCmdMemoryTrackingAutoStartItemDelete:

        OnCmdItemDeleteL();

        break;

    case EMemSpyCmdMemoryTrackingAutoStartItemDeleteAll:

        OnCmdItemDeleteAllL();

        break;

    case EMemSpyCmdMemoryTrackingAutoStartItemImport:

        OnCmdItemImportL();

        break;

    default:

        handled = CMemSpyViewBase::HandleCommandL( aCommand );

        break;

        }

    //

    return handled;

    }

void CMemSpyViewMemoryTrackingAutoStartConfig::HandleListBoxItemActionedL( TInt /*aIndex*/ )

    {

    OnCmdItemEditL();

    }

void CMemSpyViewMemoryTrackingAutoStartConfig::SetListBoxModelL()

    {

    CDesCArrayFlat* model = new(ELeave) CDesCArrayFlat(5);

    CleanupStack::PushL( model );

    TBuf<128> buf;

    _LIT( KProcUidFormatSpec, "\t0x%08x" );

    const TInt count = iProcessUids.Count();

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

        {

        const TUid procUid = iProcessUids[ i ];

        //

        buf.Format( KProcUidFormatSpec, procUid.iUid );

        model->AppendL( buf );

        }

    // Set up list box

    CAknSettingStyleListBox* listbox = static_cast< CAknSettingStyleListBox* >( iListBox );

    listbox->Model()->SetItemTextArray( model );

    listbox->Model()->SetOwnershipType( ELbmOwnsItemArray );

    CleanupStack::Pop( model );

    }

void CMemSpyViewMemoryTrackingAutoStartConfig::RefreshL()

    {

    SetListBoxModelL();

    CMemSpyViewBase::RefreshL();

    iListBox->HandleItemAdditionL();

    iListBox->DrawDeferred();

    }

void CMemSpyViewMemoryTrackingAutoStartConfig::DynInitMenuPaneL( TInt aResourceId, CEikMenuPane* aMenuPane )

    {

    if  ( aResourceId == MenuCascadeResourceId() )

        {

        const TInt count = iProcessUids.Count();

        const TInt index = iListBox->CurrentItemIndex();

        // We cannot edit an item if none exists

        aMenuPane->SetItemDimmed( EMemSpyCmdMemoryTrackingAutoStartItemEdit, ( count == 0 || index < 0 || index > count - 1 ) );

        aMenuPane->SetItemDimmed( EMemSpyCmdMemoryTrackingAutoStartItemDelete, ( count == 0 || index < 0 || index > count - 1 ) );

        aMenuPane->SetItemDimmed( EMemSpyCmdMemoryTrackingAutoStartItemDeleteAll, ( count <= 1 || index > count - 1 ) );

        // We can only import items if an XML file is available

        const TBool xmlAvailable = ( iXMLFileNameInstallTime->Length() || iXMLFileNameUserSupplied->Length() );

        aMenuPane->SetItemDimmed( EMemSpyCmdMemoryTrackingAutoStartItemImport, !xmlAvailable );

        }

    }

TUint CMemSpyViewMemoryTrackingAutoStartConfig::MenuCascadeResourceId() const

    {

    return R_MEMSPY_MENUPANE_MEMORY_TRACKING_AUTOSTART;

    }

TInt CMemSpyViewMemoryTrackingAutoStartConfig::MenuCascadeCommandId() const

    {

    return EMemSpyCmdMemoryTrackingAutoStart;

    }

void CMemSpyViewMemoryTrackingAutoStartConfig::OnCmdItemAddL()

    {

    const TUid uid = ShowDialogL( KNullUid );

    if ( uid != KNullUid )

        {

        User::LeaveIfError( iProcessUids.Append( uid ) );

        SaveChangesL();

        RefreshL();

        iListBox->HandleItemAdditionL();

        iListBox->DrawDeferred();

        }

    }

void CMemSpyViewMemoryTrackingAutoStartConfig::OnCmdItemEditL()

    {

    const TInt index = iListBox->CurrentItemIndex();

    if ( index >= 0 && index < iProcessUids.Count() )

        {

        TUid processUid = iProcessUids[ index ];

        processUid = ShowDialogL( processUid );

        //

        if ( processUid != KNullUid )

            {

            iProcessUids[ index ] = processUid;

            SaveChangesL();

            RefreshL();

            iListBox->HandleItemAdditionL();

            iListBox->DrawDeferred();

            }

        }

    }

void CMemSpyViewMemoryTrackingAutoStartConfig::OnCmdItemDeleteL()

    {

    const TInt index = iListBox->CurrentItemIndex();

    if ( index >= 0 && index < iProcessUids.Count() )

        {

        iProcessUids.Remove( index );

        SaveChangesL();

        RefreshL();

        iListBox->HandleItemRemovalL();

        iListBox->DrawDeferred();

        const TInt newIndex = index - 1;

        const TInt count = iProcessUids.Count();

        if ( newIndex >=0 && newIndex < count )

            {

            iListBox->SetCurrentItemIndex( index );

            }

        }

    }

void CMemSpyViewMemoryTrackingAutoStartConfig::OnCmdItemDeleteAllL()

    {

    iProcessUids.Reset();

    SaveChangesL();

    RefreshL();

    iListBox->HandleItemRemovalL();

    iListBox->DrawDeferred();

    }

void CMemSpyViewMemoryTrackingAutoStartConfig::OnCmdItemImportL()

    {

    if  ( iXMLFileNameInstallTime->Length() )

        {

        CAknQueryDialog* importDialog = CAknQueryDialog::NewL();

        if  ( importDialog->ExecuteLD( R_MEMSPY_MEMORY_TRACKING_IMPORT_FROM_INSTALLED_XML_DIALOG ) )

            {

            TRAP_IGNORE( ParseL( *iXMLFileNameInstallTime ) );

            }

        }

    if  ( iXMLFileNameUserSupplied->Length() )

        {

        CAknQueryDialog* importDialog = CAknQueryDialog::NewL();

        if  ( importDialog->ExecuteLD( R_MEMSPY_MEMORY_TRACKING_IMPORT_FROM_USERDEFINED_XML_DIALOG ) )

            {

            TRAP_IGNORE( ParseL( *iXMLFileNameUserSupplied ) );

            }

        }

    SaveChangesL();

    RefreshL();

    iListBox->HandleItemRemovalL();

    iListBox->DrawDeferred();

    }

TUid CMemSpyViewMemoryTrackingAutoStartConfig::ShowDialogL( TUid aUid )

    {

    TUid uid = KNullUid;

    //

    _LIT( KProcessUidFormat, "%x" );

    TBuf<128> buf;

    buf.Format( KProcessUidFormat, aUid );

    //

    CAknTextQueryDialog* dialog = new(ELeave) CAknTextQueryDialog( buf );

    const TBool dialogActioned = ( dialog->ExecuteLD( R_MEMSPY_MEMORY_TRACKING_PROCESS_UID_DIALOG ) );

    //

    if ( dialogActioned )

        {

        // Validate the text

        uid = ValidateProcessUid( buf );

        }

    //

    return uid;

    }

void CMemSpyViewMemoryTrackingAutoStartConfig::SaveChangesL()

    {

    iEngine.HelperProcess().SetMemoryTrackingAutoStartProcessListL( iProcessUids );

    Settings().StoreSettingsL();

    }

TUid CMemSpyViewMemoryTrackingAutoStartConfig::ValidateProcessUid( const TDesC& aUid )

    {

    TUid ret = KNullUid;

    TBool isValid = ETrue;

    //

    const TInt length = aUid.Length();

    for( TInt i=0; i<length && isValid; i++ )

        {

        const TChar charValue = aUid[ i ];

        //

        switch( charValue )

            {

        case '0':

        case '1':

        case '2':

        case '3':

        case '4':

        case '5':

        case '6':

        case '7':

        case '8':

        case '9':

        case 'a':

        case 'A':

        case 'b':

        case 'B':

        case 'c':

        case 'C':

        case 'd':

        case 'D':

        case 'e':

        case 'E':

        case 'f':

        case 'F':

            break;

        default:

            isValid = EFalse;

            break;

            }

        }

    //

    if ( isValid )

        {

        TUint32 val = 0;

        TLex lexer( aUid );

        if ( lexer.Val( val, EHex ) == KErrNone )

            {

            ret.iUid = val;

            }

        }

    //

    return ret;

    }

void CMemSpyViewMemoryTrackingAutoStartConfig::FindXmlInstallTimeL()

    {

    RFs& fsSession = iEngine.FsSession();

    //

    TFileName* fileName = new(ELeave) TFileName();

    CleanupStack::PushL( fileName );

    //

    fsSession.PrivatePath( *fileName );

    //

    TFindFile findFile( fsSession );

    if  ( findFile.FindByPath( KMemSpyProcessMemoryTrackingAutoStartConfigFileName, fileName ) == KErrNone )

        {

        iXMLFileNameInstallTime = findFile.File().AllocL();

        }

    else

        {

        iXMLFileNameInstallTime = KNullDesC().AllocL();

        RDebug::Print( _L("CMemSpyViewMemoryTrackingAutoStartConfig::FindXmlInstallTimeL() - NO FILE FOUND") );

        }

    //

    CleanupStack::PopAndDestroy( fileName );

    }

void CMemSpyViewMemoryTrackingAutoStartConfig::FindXmlUserSuppliedL()

    {

    TFindFile findFile( iEngine.FsSession() );

    if  ( findFile.FindByPath( KMemSpyProcessMemoryTrackingAutoStartConfigFileName, &KMemSpyProcessMemoryTrackingAutoStartConfigSearchPath ) == KErrNone )

        {

        iXMLFileNameUserSupplied = findFile.File().AllocL();

        }

    else

        {

        iXMLFileNameUserSupplied = KNullDesC().AllocL();

        RDebug::Print( _L("CMemSpyViewMemoryTrackingAutoStartConfig::FindXmlUserSuppliedL() - NO FILE FOUND") );

        }

    }

void CMemSpyViewMemoryTrackingAutoStartConfig::ParseL( const TDesC& aFileName )

    {

	Xml::ParseL( *iParser, iEngine.FsSession(), aFileName );

    //

    const TInt error = iParserErrorCode;

    iParserErrorCode = KErrNone;

    //

	User::LeaveIfError( error );

    }

void CMemSpyViewMemoryTrackingAutoStartConfig::OnSectionProcessL( const RAttributeArray& aAttributes )

    {

    TUid uid = KNullUid;

    TBool gotSID = EFalse;

    //

    const TInt count = aAttributes.Count();

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

		{

		const TPtrC8 attrib( aAttributes[ i ].Attribute().LocalName().DesC() );

		const TPtrC8 value( aAttributes[ i ].Value().DesC() );

        //

		if  ( attrib.CompareF( KMemSpyXmlSpec_EntryProcess_SID ) == 0 )

			{

            if  ( gotSID )

                {

                User::LeaveIfError( KErrCorrupt );

                }

            else

                {

                if  ( value.Length() >= 8 )

                    {

                    TRadix radix = EDecimal;

                    TPtrC8 pValue( value );

                    //

                    if  ( value.Length() == 10 && value.Left( 2 ) == KMemSpyXmlSpec_HexPrefix )

                        {

                        pValue.Set( value.Mid( 2 ) );

                        radix = EHex;

                        }

                    //

                    TUint32 uidVal = 0;

                    TLex8 lexer( pValue );

                    const TInt err = lexer.Val( uidVal, radix );

                    User::LeaveIfError( err );

                    uid.iUid = uidVal;

                    gotSID = ETrue;

                    }

                }

			}

        }

    //

    if  ( gotSID )

        {

        User::LeaveIfError( iProcessUids.Append( uid ) );

        }

    else

        {

        User::Leave( KErrCorrupt );

        }

    }

void CMemSpyViewMemoryTrackingAutoStartConfig::OnStartDocumentL( const RDocumentParameters& /*aDocParam*/, TInt aErrorCode )

    {

    User::LeaveIfError( aErrorCode );

    }

void CMemSpyViewMemoryTrackingAutoStartConfig::OnEndDocumentL( TInt aErrorCode )

    {

    User::LeaveIfError( aErrorCode );

    }

void CMemSpyViewMemoryTrackingAutoStartConfig::OnStartElementL( const RTagInfo& aElement, const RAttributeArray& aAttributes, TInt aErrorCode )

    {

    User::LeaveIfError( aErrorCode );

    //

	const TPtrC8 name( aElement.LocalName().DesC() );

    //

    if  ( name.CompareF( KMemSpyXmlSpec_MasterSection ) == 0 )

		{

		iSeenMasterSection = ETrue;

		}

    else if ( iSeenMasterSection && name.CompareF( KMemSpyXmlSpec_EntryProcess ) == 0 )

        {

        OnSectionProcessL( aAttributes );

        }

    }

void CMemSpyViewMemoryTrackingAutoStartConfig::OnEndElementL( const RTagInfo& /*aElement*/, TInt aErrorCode )

    {

    User::LeaveIfError( aErrorCode );

    }

void CMemSpyViewMemoryTrackingAutoStartConfig::OnContentL( const TDesC8& /*aBytes*/, TInt aErrorCode )

    {

    User::LeaveIfError( aErrorCode );

    }