diff -r 000000000000 -r d6fe6244b863 memspyui/source/MemSpyViewHeapTracking.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/memspyui/source/MemSpyViewHeapTracking.cpp Tue Feb 02 00:17:27 2010 +0200 @@ -0,0 +1,435 @@ +/* +* 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 "MemSpyViewHeapTracking.h" + +// System includes +#include + +// Engine includes +#include +#include +#include +#include +#include +#include +#include + +// User includes +#include "MemSpyUiUtils.h" +#include "MemSpyViewMainMenu.h" +#include "MemSpyContainerObserver.h" +#include "MemSpyViewHeapTrackingSettings.h" +#include "MemSpyViewHeapTrackingResults.h" + + +CMemSpyViewHeapTracking::CMemSpyViewHeapTracking( CMemSpyEngine& aEngine, MMemSpyViewObserver& aObserver ) +: CMemSpyViewBase( aEngine, aObserver ), + iState( EMemSpyViewHeapTrackingStateIdle ) + { + if ( iEngine.HelperSysMemTracker().IsActive() ) + { + iState = EMemSpyViewHeapTrackingStateTimerOn; + } + } + + +CMemSpyViewHeapTracking::~CMemSpyViewHeapTracking() + { + delete iStopTimerCallBack; + iEngine.HelperSysMemTracker().RemoveObserver( this ); + } + + +void CMemSpyViewHeapTracking::ConstructL( const TRect& aRect, CCoeControl& aContainer, TAny* aSelectionRune ) + { + _LIT( KTitle, "System-Wide Memory Tracking" ); + SetTitleL( KTitle ); + // + CMemSpyViewBase::ConstructL( aRect, aContainer, aSelectionRune ); + + // Backup current config because it may be overwritten with Basic/Full mode settings. + CMemSpyEngineHelperSysMemTracker& swmt = iEngine.HelperSysMemTracker(); + TMemSpyEngineHelperSysMemTrackerConfig config; + swmt.GetConfig( config ); + iOriginalConfig = config; + + if ( config.iMode != TMemSpyEngineHelperSysMemTrackerConfig::MemSpyEngineSysMemTrackerModeCustom ) + { + // Set config. Needed for updating config for Basic or Full mode. + SetConfigByModeL( config.iMode, config ); + } + + // Make sure the correct item is selected + TInt index = 0; + if ( aSelectionRune != NULL ) + { + const TMemSpyViewType viewType = (TMemSpyViewType) ((TInt) aSelectionRune); + index = IndexByViewType( viewType ); + } + iListBox->SetCurrentItemIndex( index ); + HandleListBoxItemSelectedL( index ); + } + + +void CMemSpyViewHeapTracking::RefreshL() + { + SetListBoxModelL(); + CMemSpyViewBase::RefreshL(); + } + + +TMemSpyViewType CMemSpyViewHeapTracking::ViewType() const + { + return EMemSpyViewTypeHeapTracking; + } + + +CMemSpyViewBase* CMemSpyViewHeapTracking::PrepareParentViewL() + { + + // Save custom settings even if mode is Basic or Full + TRAP_IGNORE( + CMemSpyEngineHelperSysMemTracker& swmt = iEngine.HelperSysMemTracker(); + TMemSpyEngineHelperSysMemTrackerConfig config; + swmt.GetConfig( config ); + config.iEnabledCategories = iOriginalConfig.iEnabledCategories; + config.iThreadNameFilter = iOriginalConfig.iThreadNameFilter; + config.iDumpData = iOriginalConfig.iDumpData; + swmt.SetConfigL( config ); + Settings().StoreSettingsL(); + ); + + CMemSpyViewMainMenu* parent = new(ELeave) CMemSpyViewMainMenu( iEngine, iObserver ); + CleanupStack::PushL( parent ); + parent->ConstructL( Rect(), *Parent(), (TAny*) ViewType() ); + CleanupStack::Pop( parent ); + return parent; + } + + +CMemSpyViewBase* CMemSpyViewHeapTracking::PrepareChildViewL() + { + CMemSpyViewBase* child = NULL; + const TInt index = iListBox->CurrentItemIndex(); + + // Get current config + CMemSpyEngineHelperSysMemTracker& swmt = iEngine.HelperSysMemTracker(); + TMemSpyEngineHelperSysMemTrackerConfig config; + swmt.GetConfig( config ); + + // + if ( index == 0 ) + { + // This is the start/stop toggle so we don't make a child view + child = NULL; + + // ... instead we either start or stop the tracker + if ( !iEngine.HelperSysMemTracker().IsActive() ) + { + iState = EMemSpyViewHeapTrackingStateSingleOn; + // Setting observer to be able to stop SWMT after first cycle is completed + iEngine.HelperSysMemTracker().SetObserver( this ); + iEngine.HelperSysMemTracker().StartL(); + } + + // Redraw listbox + RefreshL(); + } + else if ( index == 1 ) + { + // This is the start/stop toggle so we don't make a child view + child = NULL; + + // ... instead we either start or stop the tracker + if ( iEngine.HelperSysMemTracker().IsActive() && iState == EMemSpyViewHeapTrackingStateTimerOn ) + { + iState = EMemSpyViewHeapTrackingStateIdle; + iEngine.HelperSysMemTracker().StopL(); + } + else if ( iState == EMemSpyViewHeapTrackingStateIdle ) + { + iState = EMemSpyViewHeapTrackingStateTimerOn; + iEngine.HelperSysMemTracker().StartL(); + } + + // Redraw listbox + RefreshL(); + } + else if ( index == 2 ) + { + switch ( config.iMode ) + { + case TMemSpyEngineHelperSysMemTrackerConfig::MemSpyEngineSysMemTrackerModeBasic: + { + // Set Full mode + SetConfigByModeL( TMemSpyEngineHelperSysMemTrackerConfig::MemSpyEngineSysMemTrackerModeFull, config ); + break; + } + case TMemSpyEngineHelperSysMemTrackerConfig::MemSpyEngineSysMemTrackerModeFull: + { + // Set Custom mode + SetConfigByModeL( TMemSpyEngineHelperSysMemTrackerConfig::MemSpyEngineSysMemTrackerModeCustom, config ); + break; + } + case TMemSpyEngineHelperSysMemTrackerConfig::MemSpyEngineSysMemTrackerModeCustom: + { + // Set Basic mode + SetConfigByModeL( TMemSpyEngineHelperSysMemTrackerConfig::MemSpyEngineSysMemTrackerModeBasic, config ); + break; + } + default: break; + } + + // Redraw listbox + RefreshL(); + } + else if ( index == 3 ) + { + if ( config.iMode == TMemSpyEngineHelperSysMemTrackerConfig::MemSpyEngineSysMemTrackerModeCustom ) + { + child = new(ELeave) CMemSpyViewHeapTrackingSettings( iEngine, iObserver ); + } + else + { + child = new(ELeave) CMemSpyViewHeapTrackingResults( iEngine, iObserver ); + } + } + else if ( index == 4 ) + { + child = new(ELeave) CMemSpyViewHeapTrackingResults( iEngine, iObserver ); + } + if ( child ) + { + CleanupStack::PushL( child ); + child->ConstructL( Rect(), *Parent() ); + CleanupStack::Pop( child ); + } + + // + return child; + } + + +void CMemSpyViewHeapTracking::SetListBoxModelL() + { + CDesCArrayFlat* model = new(ELeave) CDesCArrayFlat(5); + CleanupStack::PushL( model ); + + TBuf item; + + // Get current config + CMemSpyEngineHelperSysMemTracker& swmt = iEngine.HelperSysMemTracker(); + TMemSpyEngineHelperSysMemTrackerConfig config; + swmt.GetConfig( config ); + + // 1st item + _LIT( KItem1FormatEnable, "\tGet dump now" ); + model->AppendL( KItem1FormatEnable ); + + + // 1st item + if ( iEngine.HelperSysMemTracker().IsActive() && iState == EMemSpyViewHeapTrackingStateTimerOn ) + { + _LIT( KItem1FormatEnable, "\tStop timer\t\t%d (sec)" ); + TName item; + item.Format( KItem1FormatEnable, config.iTimerPeriod.Int() / 1000000 ); + model->AppendL( item ); + } + else + { + _LIT( KItem1FormatEnable, "\tStart timer\t\t%d (sec)" ); + TName item; + item.Format( KItem1FormatEnable, config.iTimerPeriod.Int() / 1000000 ); + model->AppendL( item ); + } + + // 2nd item + switch ( config.iMode ) + { + case TMemSpyEngineHelperSysMemTrackerConfig::MemSpyEngineSysMemTrackerModeBasic: + { + _LIT( KItem2Format, "\tTracking mode\t\tBasic" ); + model->AppendL( KItem2Format ); + break; + } + case TMemSpyEngineHelperSysMemTrackerConfig::MemSpyEngineSysMemTrackerModeFull: + { + _LIT( KItem2Format, "\tTracking mode\t\tFull" ); + model->AppendL( KItem2Format ); + break; + } + case TMemSpyEngineHelperSysMemTrackerConfig::MemSpyEngineSysMemTrackerModeCustom: + { + _LIT( KItem2Format, "\tTracking mode\t\tCustom" ); + model->AppendL( KItem2Format ); + + // 3rd item + TFullName item; + if ( config.DumpData() && + config.iEnabledCategories & TMemSpyEngineHelperSysMemTrackerConfig::EMemSpyEngineSysMemTrackerCategoryUserHeap ) + { + _LIT( KItem3Format, "\tSettings\t\t%d categ., dump" ); + item.Format( KItem3Format, config.EnabledCategoryCount() ); + } + else + { + _LIT( KItem3Format, "\tSettings\t\t%d categories" ); + item.Format( KItem3Format, config.EnabledCategoryCount() ); + } + model->AppendL( item ); + break; + } + default: break; + } + + // 4th item + const TInt cycleCount = iEngine.HelperSysMemTracker().MdcaCount(); + if ( cycleCount ) + { + _LIT( KItem2Format, "\tResults\t\t%d cycles" ); + TFullName item; + item.Format( KItem2Format, cycleCount ); + model->AppendL( item ); + } + else + { + _LIT( KItem2Format, "\tResults\t\tNo results" ); + model->AppendL( KItem2Format ); + } + + // Set up list box + CAknSettingStyleListBox* listbox = static_cast< CAknSettingStyleListBox* >( iListBox ); + listbox->Model()->SetItemTextArray( model ); + listbox->Model()->SetOwnershipType( ELbmOwnsItemArray ); + CleanupStack::Pop( model ); + } + + +void CMemSpyViewHeapTracking::HandleCyclesResetL() + { + } + + +void CMemSpyViewHeapTracking::HandleCycleStartedL( const CMemSpyEngineHelperSysMemTrackerCycle& /*aCycle*/ ) + { + } + + +void CMemSpyViewHeapTracking::HandleCycleFinishedL( const CMemSpyEngineHelperSysMemTrackerCycle& /*aCycle*/ ) + { + // Stopping SWMT does not work directly from this function. + // It has to be made asynchronously. + iStopTimerCallBack = new (ELeave) CAsyncCallBack( TCallBack( CMemSpyViewHeapTracking::AsyncStopTimerCallback, this ), CActive::EPriorityStandard ); + iStopTimerCallBack->CallBack(); + } + + +TInt CMemSpyViewHeapTracking::IndexByViewType( TMemSpyViewType aType ) + { + // Get current config + CMemSpyEngineHelperSysMemTracker& swmt = iEngine.HelperSysMemTracker(); + TMemSpyEngineHelperSysMemTrackerConfig config; + swmt.GetConfig( config ); + + TInt index = 0; + // + switch( aType ) + { + default: + case EMemSpyViewTypeHeapTrackingResults: + { + if ( config.iMode == TMemSpyEngineHelperSysMemTrackerConfig::MemSpyEngineSysMemTrackerModeCustom ) + { + index = 4; + } + else + { + index = 3; + } + break; + } + case EMemSpyViewTypeHeapTrackingSettings: + index = 3; + break; + } + // + return index; + } + + +void CMemSpyViewHeapTracking::SetConfigByModeL( TMemSpyEngineHelperSysMemTrackerConfig::TMemSpyEngineSysMemTrackerMode aMode, TMemSpyEngineHelperSysMemTrackerConfig& aConfig ) + { + switch ( aMode ) + { + case TMemSpyEngineHelperSysMemTrackerConfig::MemSpyEngineSysMemTrackerModeBasic: + { + aConfig.iMode = aMode; + aConfig.iEnabledCategories = TMemSpyEngineHelperSysMemTrackerConfig::EMemSpyEngineSysMemTrackerCategoryUserHeap | + TMemSpyEngineHelperSysMemTrackerConfig::EMemSpyEngineSysMemTrackerCategoryUserStacks | + TMemSpyEngineHelperSysMemTrackerConfig::EMemSpyEngineSysMemTrackerCategoryGlobalData | + TMemSpyEngineHelperSysMemTrackerConfig::EMemSpyEngineSysMemTrackerCategorySystemMemory; + aConfig.iDumpData = EFalse; + break; + } + case TMemSpyEngineHelperSysMemTrackerConfig::MemSpyEngineSysMemTrackerModeFull: + { + aConfig.iMode = aMode; + aConfig.iEnabledCategories = TMemSpyEngineHelperSysMemTrackerConfig::EMemSpyEngineSysMemTrackerCategoryAll; + aConfig.iDumpData = ETrue; + aConfig.iThreadNameFilter = KNullDesC; + break; + } + case TMemSpyEngineHelperSysMemTrackerConfig::MemSpyEngineSysMemTrackerModeCustom: + { + aConfig.iMode = aMode; + aConfig.iEnabledCategories = iOriginalConfig.iEnabledCategories; + aConfig.iDumpData = iOriginalConfig.iDumpData; + aConfig.iThreadNameFilter = iOriginalConfig.iThreadNameFilter; + break; + } + default: User::Leave( KErrArgument ); + } + // Push changes to SWMT + CMemSpyEngineHelperSysMemTracker& swmt = iEngine.HelperSysMemTracker(); + swmt.SetConfigL( aConfig ); + Settings().StoreSettingsL(); + } + + +TInt CMemSpyViewHeapTracking::AsyncStopTimerCallback( TAny* aParam ) + { + CMemSpyViewHeapTracking* view = static_cast( aParam ); + return view->AsyncStopTimerCallback(); + } + + +TInt CMemSpyViewHeapTracking::AsyncStopTimerCallback() + { + iState = EMemSpyViewHeapTrackingStateIdle; + iEngine.HelperSysMemTracker().RemoveObserver( this ); + TRAP_IGNORE( + iEngine.HelperSysMemTracker().StopL(); + RefreshL(); + ); + delete iStopTimerCallBack; + iStopTimerCallBack = NULL; + return KErrNone; + } + + +