--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/perfsrv/memspy/Engine/Source/Helpers/MemSpyEngineHelperServer.cpp Mon Sep 06 15:00:47 2010 +0300
@@ -0,0 +1,455 @@
+/*
+* 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 <memspy/engine/memspyenginehelperserver.h>
+
+// Driver includes
+#include <memspy/driver/memspydriverclient.h>
+#include <memspy/driver/memspydriverconstants.h>
+
+// User includes
+#include <memspy/engine/memspyengine.h>
+#include <memspy/engine/memspyengineoutputsink.h>
+#include <memspy/engine/memspyengineobjectthread.h>
+#include <memspy/engine/memspyengineobjectprocess.h>
+#include <memspy/engine/memspyengineobjectcontainer.h>
+#include <memspy/engine/memspyenginehelperchunk.h>
+
+// Literal constants
+_LIT( KMemSpyEngineServListOutputComma, ", " );
+
+
+
+CMemSpyEngineHelperServer::CMemSpyEngineHelperServer( CMemSpyEngine& aEngine )
+: iEngine( aEngine )
+ {
+ }
+
+
+CMemSpyEngineHelperServer::~CMemSpyEngineHelperServer()
+ {
+ }
+
+
+void CMemSpyEngineHelperServer::ConstructL()
+ {
+ }
+
+
+CMemSpyEngineHelperServer* CMemSpyEngineHelperServer::NewL( CMemSpyEngine& aEngine )
+ {
+ CMemSpyEngineHelperServer* self = new(ELeave) CMemSpyEngineHelperServer( aEngine );
+ CleanupStack::PushL( self );
+ self->ConstructL();
+ CleanupStack::Pop( self );
+ return self;
+ }
+
+
+EXPORT_C void CMemSpyEngineHelperServer::GetServerSessionsL( TAny* aServerHandle, RArray<TMemSpyDriverServerSessionInfo>& aSessions )
+ {
+ const TInt KMaxCount = 256;
+ TAny* handles[KMaxCount];
+ TInt c = KMaxCount;
+
+ TInt r = iEngine.Driver().GetServerSessionHandles( aServerHandle, handles, c );
+ if ( r == KErrNone )
+ {
+ if ( c > 0 )
+ {
+ if (c > KMaxCount)
+ {
+ c = KMaxCount;
+ }
+
+ TMemSpyDriverServerSessionInfo info;
+ for (TInt i=0; i<c; i++)
+ {
+ r = iEngine.Driver().GetServerSessionInfo( handles[i], info );
+ if (r == KErrNone)
+ {
+ aSessions.AppendL( info );
+ }
+ }
+ }
+ }
+ }
+
+
+EXPORT_C void CMemSpyEngineHelperServer::GetServerSessionsL( const TMemSpyDriverHandleInfoGeneric& aServerDetails, RArray<TMemSpyDriverServerSessionInfo>& aSessions )
+ {
+ GetServerSessionsL( aServerDetails.iHandle, aSessions );
+ }
+
+
+EXPORT_C void CMemSpyEngineHelperServer::GetServerListL( RArray<TMemSpyDriverHandleInfoGeneric>& aServers )
+ {
+ const TInt KMaxCount = 256;
+ TAny* handles[KMaxCount];
+ TInt c = KMaxCount;
+
+ TInt r = iEngine.Driver().GetContainerHandles( EMemSpyDriverContainerTypeServer, handles, c );
+ if ( r == KErrNone )
+ {
+ if ( c > 0 )
+ {
+ if (c > KMaxCount)
+ {
+ c = KMaxCount;
+ }
+
+ TMemSpyDriverHandleInfoGeneric info;
+ for (TInt i=0; i<c; i++)
+ {
+ r = iEngine.Driver().GetGenericHandleInfo( KMemSpyDriverEnumerateContainerHandles, EMemSpyDriverContainerTypeServer, handles[i], info );
+ if (r == KErrNone)
+ {
+ aServers.AppendL( info );
+ }
+ }
+ }
+ }
+ }
+
+
+EXPORT_C CMemSpyEngineServerList* CMemSpyEngineHelperServer::ServerListL()
+ {
+ CMemSpyEngineServerList* list = CMemSpyEngineServerList::NewLC();
+ //
+ RArray<TMemSpyDriverHandleInfoGeneric> servers;
+ CleanupClosePushL( servers );
+ //
+ GetServerListL( servers );
+ //
+ const TInt count = servers.Count();
+ for( TInt i=0; i<count; i++ )
+ {
+ const TMemSpyDriverHandleInfoGeneric& details = servers[ i ];
+ //
+ CMemSpyEngineServerEntry* serverEntry = CMemSpyEngineServerEntry::NewLC( details );
+ list->AddItemL( serverEntry );
+ CleanupStack::Pop( serverEntry );
+ }
+ //
+ CleanupStack::PopAndDestroy( &servers );
+
+ // Sort the list by session count
+ list->SortBySessionCountL();
+
+ // Done
+ CleanupStack::Pop( list );
+ return list;
+ }
+
+
+CMemSpyEngine& CMemSpyEngineHelperServer::Engine() const
+ {
+ return iEngine;
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+CMemSpyEngineServerList::CMemSpyEngineServerList()
+ {
+ }
+
+
+EXPORT_C CMemSpyEngineServerList::~CMemSpyEngineServerList()
+ {
+ iItems.ResetAndDestroy();
+ iItems.Close();
+ }
+
+
+void CMemSpyEngineServerList::ConstructL()
+ {
+ }
+
+
+CMemSpyEngineServerList* CMemSpyEngineServerList::NewLC()
+ {
+ CMemSpyEngineServerList* self = new(ELeave) CMemSpyEngineServerList();
+ CleanupStack::PushL( self );
+ self->ConstructL();
+ return self;
+ }
+
+
+EXPORT_C TInt CMemSpyEngineServerList::Count() const
+ {
+ return iItems.Count();
+ }
+
+
+EXPORT_C const CMemSpyEngineServerEntry& CMemSpyEngineServerList::At( TInt aIndex ) const
+ {
+ return *iItems[ aIndex ];
+ }
+
+
+EXPORT_C void CMemSpyEngineServerList::SortByNameL()
+ {
+ TLinearOrder< CMemSpyEngineServerEntry > comparer( CompareByName );
+ iItems.Sort( comparer );
+ }
+
+
+EXPORT_C void CMemSpyEngineServerList::SortBySessionCountL()
+ {
+ TLinearOrder< CMemSpyEngineServerEntry > comparer( CompareBySessionCount );
+ iItems.Sort( comparer );
+ }
+
+
+EXPORT_C TInt CMemSpyEngineServerList::ItemIndex( const CMemSpyEngineServerEntry& aEntry ) const
+ {
+ TInt ret = KErrNotFound;
+ //
+ const TInt count = Count();
+ for( TInt i=0; i<count; i++ )
+ {
+ const CMemSpyEngineServerEntry* item = iItems[ i ];
+ //
+ if ( item == &aEntry )
+ {
+ ret = i;
+ break;
+ }
+ }
+ //
+ return ret;
+ }
+
+
+EXPORT_C void CMemSpyEngineServerList::OutputDataColumnsL( CMemSpyEngine& aEngine, TBool aClientThreadColumns )
+ {
+ HBufC* columns = HBufC::NewLC( 1024 );
+ TPtr pColumns( columns->Des() );
+ //
+ _LIT(KCol1, "Thread/Process Id");
+ pColumns.Append( KCol1 );
+ pColumns.Append( KMemSpyEngineServListOutputComma );
+ //
+ _LIT(KCol2, "Name");
+ pColumns.Append( KCol2 );
+ pColumns.Append( KMemSpyEngineServListOutputComma );
+ //
+ _LIT(KCol3, "Connected Session Count");
+ pColumns.Append( KCol3 );
+ //
+ if ( aClientThreadColumns )
+ {
+ _LIT(KCol4, "Connected Client");
+ pColumns.Append( KMemSpyEngineServListOutputComma );
+ pColumns.Append( KCol4 );
+ }
+ //
+ aEngine.Sink().OutputLineL( pColumns );
+ CleanupStack::PopAndDestroy( columns );
+ }
+
+
+void CMemSpyEngineServerList::AddItemL( CMemSpyEngineServerEntry* aItem )
+ {
+ iItems.AppendL( aItem );
+ }
+
+
+EXPORT_C TInt CMemSpyEngineServerList::MdcaCount() const
+ {
+ return Count();
+ }
+
+
+EXPORT_C TPtrC CMemSpyEngineServerList::MdcaPoint( TInt aIndex ) const
+ {
+ const CMemSpyEngineServerEntry& item = At( aIndex );
+ return TPtrC( item.Caption() );
+ }
+
+
+TInt CMemSpyEngineServerList::CompareByName( const CMemSpyEngineServerEntry& aLeft, const CMemSpyEngineServerEntry& aRight )
+ {
+ const TInt ret = aLeft.Name().CompareF( aRight.Name() );
+ return ret;
+ }
+
+
+TInt CMemSpyEngineServerList::CompareBySessionCount( const CMemSpyEngineServerEntry& aLeft, const CMemSpyEngineServerEntry& aRight )
+ {
+ TInt ret = -1;
+ //
+ if ( aLeft.SessionCount() < aRight.SessionCount() )
+ {
+ ret = 1;
+ }
+ else if ( aLeft.SessionCount() == aRight.SessionCount() )
+ {
+ ret = 0;
+ }
+ //
+ return ret;
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+CMemSpyEngineServerEntry::CMemSpyEngineServerEntry()
+ {
+ }
+
+
+EXPORT_C CMemSpyEngineServerEntry::~CMemSpyEngineServerEntry()
+ {
+ delete iCaption;
+ delete iName;
+ }
+
+
+void CMemSpyEngineServerEntry::ConstructL( const TMemSpyDriverHandleInfoGeneric& aInfo )
+ {
+ iName = HBufC::NewL( aInfo.iName.Length() );
+ iName->Des().Copy( aInfo.iName );
+ iSessionCount = aInfo.iCount;
+ iId = aInfo.iId;
+ iHandle = aInfo.iHandle;
+
+ // Make caption
+ _LIT(KServerListFormat, "\t%S\t\t%d session");
+ TBuf<KMaxFullName + 128> item;
+ //
+ item.Format( KServerListFormat, iName, iSessionCount );
+ //
+ if ( iSessionCount != 1 )
+ {
+ // Add missing 's'
+ item.Append( TChar('s') );
+ }
+ //
+ iCaption = item.AllocL();
+ }
+
+
+CMemSpyEngineServerEntry* CMemSpyEngineServerEntry::NewLC( const TMemSpyDriverHandleInfoGeneric& aInfo )
+ {
+ CMemSpyEngineServerEntry* self = new(ELeave) CMemSpyEngineServerEntry();
+ CleanupStack::PushL( self );
+ self->ConstructL( aInfo );
+ return self;
+ }
+
+
+EXPORT_C void CMemSpyEngineServerEntry::OutputDataL( CMemSpyEngineHelperServer& aHelper, TBool aClientThreadColumns ) const
+ {
+ _LIT(KMemSpyEngineServListOutputDecimal, "%d");
+ _LIT(KMemSpyEngineServListOutputString, "%S");
+ //
+ HBufC* columns = HBufC::NewLC( 1024 );
+ TPtr pColumns( columns->Des() );
+ //
+ pColumns.AppendFormat( KMemSpyEngineServListOutputDecimal, Id() );
+ pColumns.Append( KMemSpyEngineServListOutputComma );
+ //
+ pColumns.AppendFormat( KMemSpyEngineServListOutputString, &Name() );
+ pColumns.Append( KMemSpyEngineServListOutputComma );
+ //
+ pColumns.AppendFormat( KMemSpyEngineServListOutputDecimal, SessionCount() );
+ //
+ aHelper.Engine().Sink().OutputLineL( pColumns );
+
+ if ( aClientThreadColumns )
+ {
+ RArray<TMemSpyDriverServerSessionInfo> sessions;
+ CleanupClosePushL( sessions );
+
+ // Get the sessions
+ GetSessionsL( aHelper, sessions );
+
+ // Output an additional line per entry
+ const TInt count = sessions.Count();
+ for( TInt i=0; i<count; i++ )
+ {
+ const TMemSpyDriverServerSessionInfo& session = sessions[ i ];
+ //
+ pColumns.Copy( session.iName );
+ pColumns.Insert( 0, KMemSpyEngineServListOutputComma );
+ pColumns.Insert( 0, KMemSpyEngineServListOutputComma );
+ pColumns.Insert( 0, KMemSpyEngineServListOutputComma );
+ //
+ aHelper.Engine().Sink().OutputLineL( pColumns );
+ }
+ //
+ CleanupStack::PopAndDestroy( &sessions );
+ }
+
+ CleanupStack::PopAndDestroy( columns );
+ }
+
+
+EXPORT_C void CMemSpyEngineServerEntry::GetSessionsL( CMemSpyEngineHelperServer& aHelper, RArray<TMemSpyDriverServerSessionInfo>& aSessions ) const
+ {
+ aHelper.GetServerSessionsL( Handle(), aSessions );
+ }
+
+