memspyui/source/MemSpyViewThreadInfoItemServer.cpp
branchRCL_3
changeset 50 9b2cffad4b5e
parent 49 f8280f3bfeb7
child 60 6646c35e558c
equal deleted inserted replaced
49:f8280f3bfeb7 50:9b2cffad4b5e
     1 /*
       
     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). 
       
     3 * All rights reserved.
       
     4 * This component and the accompanying materials are made available
       
     5 * under the terms of "Eclipse Public License v1.0"
       
     6 * which accompanies this distribution, and is available
       
     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
       
     8 *
       
     9 * Initial Contributors:
       
    10 * Nokia Corporation - initial contribution.
       
    11 *
       
    12 * Contributors:
       
    13 *
       
    14 * Description:
       
    15 *
       
    16 */
       
    17 
       
    18 #include "MemSpyViewThreadInfoItemServer.h"
       
    19 
       
    20 // Engine includes
       
    21 #include <memspy/engine/memspyengine.h>
       
    22 #include <memspy/engine/memspyengineobjectprocess.h>
       
    23 #include <memspy/engine/memspyengineobjectthread.h>
       
    24 #include <memspy/engine/memspyengineobjectcontainer.h>
       
    25 #include <memspy/engine/memspyengineobjectthreadinfoobjects.h>
       
    26 #include <memspy/engine/memspyengineobjectthreadinfocontainer.h>
       
    27 #include <memspy/engine/memspyenginehelperprocess.h>
       
    28 #include <memspy/engine/memspyenginehelperheap.h>
       
    29 #include <memspy/engine/memspyenginehelperserver.h>
       
    30 
       
    31 // User includes
       
    32 #include "MemSpyContainerObserver.h"
       
    33 
       
    34 // Constants
       
    35 const TInt KMemSpyServerSessionsIndex = 2;
       
    36 
       
    37 
       
    38 
       
    39 CMemSpyViewThreadInfoItemServer::CMemSpyViewThreadInfoItemServer( CMemSpyEngine& aEngine, MMemSpyViewObserver& aObserver, CMemSpyThreadInfoContainer& aContainer )
       
    40 :   CMemSpyViewThreadInfoItemGeneric( aEngine, aObserver, aContainer, EMemSpyThreadInfoItemTypeServer )
       
    41     {
       
    42     }
       
    43 
       
    44 
       
    45 void CMemSpyViewThreadInfoItemServer::ConstructL( const TRect& aRect, CCoeControl& aContainer, TAny* aSelectionRune )
       
    46     {
       
    47     // Causes list of server's to be prepared
       
    48     CMemSpyViewThreadInfoItemGeneric::ConstructL( aRect, aContainer, aSelectionRune );
       
    49 
       
    50     _LIT( KTitle, "Server List" );
       
    51     SetTitleL( KTitle );
       
    52 
       
    53 #ifdef _DEBUG
       
    54     RDebug::Printf( "CMemSpyViewThreadInfoItemServer::ConstructL() - aSelectionRune: 0x%08x", aSelectionRune );
       
    55 #endif
       
    56 
       
    57     // Try to select the correct server
       
    58     CMemSpyThreadInfoHandleObjectBase* infoItem = static_cast< CMemSpyThreadInfoHandleObjectBase* >( iInfoItem );
       
    59     TInt selectedIndex = 0;
       
    60     if  ( aSelectionRune )
       
    61         {
       
    62         // Treat the rune as a handle, and try to look it up
       
    63         selectedIndex = infoItem->DetailsIndexByHandle( aSelectionRune );
       
    64         }
       
    65 
       
    66     // Select item
       
    67     if  ( infoItem->DetailsCount() > 0 )
       
    68         {
       
    69         iListBox->SetCurrentItemIndex( selectedIndex );
       
    70         HandleListBoxItemSelectedL( selectedIndex );
       
    71         }
       
    72     }
       
    73 
       
    74 
       
    75 TBool CMemSpyViewThreadInfoItemServer::HandleCommandL( TInt aCommand )
       
    76     {
       
    77     TBool handled = CMemSpyViewBase::HandleCommandL( aCommand );
       
    78     return handled;
       
    79     }
       
    80 
       
    81 
       
    82 CMemSpyViewBase* CMemSpyViewThreadInfoItemServer::PrepareChildViewL()
       
    83     {
       
    84     CMemSpyViewThreadInfoItemServerDetails* child = new(ELeave) CMemSpyViewThreadInfoItemServerDetails( iEngine, iObserver, iContainer, iCurrentInfoItemDetails );
       
    85     CleanupStack::PushL( child );
       
    86     child->ConstructL( Rect(), *Parent() );
       
    87     CleanupStack::Pop( child );
       
    88     return child;
       
    89     }
       
    90 
       
    91 
       
    92 void CMemSpyViewThreadInfoItemServer::HandleListBoxItemSelectedL( TInt aIndex )
       
    93     {
       
    94     // Identify the type of item to display...
       
    95     CMemSpyThreadInfoHandleObjectBase* infoItem = static_cast< CMemSpyThreadInfoHandleObjectBase* >( iInfoItem );
       
    96     iCurrentInfoItemDetails = infoItem->DetailsAt( aIndex );
       
    97 
       
    98 #ifdef _DEBUG
       
    99     RDebug::Printf( "CMemSpyViewThreadInfoItemServer::HandleListBoxItemSelectedL() - iCurrentInfoItemDetails.iHandle: 0x%08x", iCurrentInfoItemDetails.iHandle );
       
   100 #endif
       
   101 
       
   102     // Notify observer about item selection
       
   103     ReportEventL( MMemSpyViewObserver::EEventItemSelected );
       
   104     }
       
   105 
       
   106 
       
   107 
       
   108 
       
   109 
       
   110 
       
   111 
       
   112 
       
   113 
       
   114 
       
   115 
       
   116 
       
   117 
       
   118 
       
   119 
       
   120 
       
   121 
       
   122 
       
   123 
       
   124 
       
   125 
       
   126 
       
   127 
       
   128 
       
   129 
       
   130 
       
   131 CMemSpyViewThreadInfoItemServerDetails::CMemSpyViewThreadInfoItemServerDetails( CMemSpyEngine& aEngine, MMemSpyViewObserver& aObserver, CMemSpyThreadInfoContainer& aContainer, const TMemSpyDriverHandleInfoGeneric& aInfoItemDetails )
       
   132 :   CMemSpyViewThreadInfoItemGeneric( aEngine, aObserver, aContainer, EMemSpyThreadInfoItemTypeServer ), iInfoItemDetails( aInfoItemDetails )
       
   133     {
       
   134     }
       
   135 
       
   136 
       
   137 void CMemSpyViewThreadInfoItemServerDetails::ConstructL( const TRect& aRect, CCoeControl& aContainer, TAny* aSelectionRune )
       
   138     {
       
   139     // Causes list of server's to be prepared
       
   140     CMemSpyViewThreadInfoItemGeneric::ConstructL( aRect, aContainer, aSelectionRune );
       
   141 
       
   142     _LIT( KTitle, "Server Details" );
       
   143     SetTitleL( KTitle );
       
   144 
       
   145     // Try to select the correct server
       
   146     TInt selectedIndex = 0;
       
   147     if  ( aSelectionRune )
       
   148         {
       
   149         // Presence of non-null item means that we came from the "Server sessions" list
       
   150         selectedIndex = KMemSpyServerSessionsIndex;
       
   151         }
       
   152 
       
   153     // Select item
       
   154     iListBox->SetCurrentItemIndex( selectedIndex );
       
   155     HandleListBoxItemSelectedL( selectedIndex );
       
   156     }
       
   157 
       
   158 
       
   159 TBool CMemSpyViewThreadInfoItemServerDetails::HandleCommandL( TInt aCommand )
       
   160     {
       
   161     TBool handled = CMemSpyViewBase::HandleCommandL( aCommand );
       
   162     return handled;
       
   163     }
       
   164 
       
   165 
       
   166 TMemSpyViewType CMemSpyViewThreadInfoItemServerDetails::ViewType() const
       
   167     {
       
   168     return EMemSpyViewTypeThreadInfoItemServerDetails;
       
   169     }
       
   170 
       
   171 
       
   172 CMemSpyViewBase* CMemSpyViewThreadInfoItemServerDetails::PrepareChildViewL()
       
   173     {
       
   174     CMemSpyViewBase* child = NULL;
       
   175     const TInt currentIndex = iListBox->CurrentItemIndex();
       
   176     //
       
   177     if  ( currentIndex == KMemSpyServerSessionsIndex )
       
   178         {
       
   179         CMemSpyViewThreadInfoItemServerSessions* serverSessions = new(ELeave) CMemSpyViewThreadInfoItemServerSessions( iEngine, iObserver, iInfoItem->Container(), iInfoItemDetails );
       
   180         CleanupStack::PushL( serverSessions );
       
   181         serverSessions->ConstructL( Rect(), *Parent(), NULL );
       
   182         CleanupStack::Pop( serverSessions );
       
   183         child = serverSessions;
       
   184         }
       
   185     //
       
   186     return child;
       
   187     }
       
   188 
       
   189 
       
   190 CMemSpyViewBase* CMemSpyViewThreadInfoItemServerDetails::PrepareParentViewL()
       
   191     {
       
   192     CMemSpyViewThreadInfoItemServer* parent = new(ELeave) CMemSpyViewThreadInfoItemServer( iEngine, iObserver, iInfoItem->Container() );
       
   193     CleanupStack::PushL( parent );
       
   194     parent->ConstructL( Rect(), *Parent(), iInfoItemDetails.iHandle );
       
   195     CleanupStack::Pop( parent );
       
   196     return parent;
       
   197     }
       
   198 
       
   199 
       
   200 void CMemSpyViewThreadInfoItemServerDetails::SetListBoxModelL()
       
   201     {
       
   202     CDesCArrayFlat* model = new(ELeave) CDesCArrayFlat(4);
       
   203     CleanupStack::PushL( model );
       
   204 
       
   205     TBuf<KMaxFullName + 1> item;
       
   206 
       
   207     // 1st item = session type
       
   208     const TPtrC pServerSessionType = CMemSpyThreadInfoServer::SessionType( iInfoItemDetails.iSessionType );
       
   209     _LIT(KItem1Format, "\tServer Type\t\t%S");
       
   210     item.Format( KItem1Format, &pServerSessionType );
       
   211     model->AppendL( item );
       
   212 
       
   213     // 2nd item = session count
       
   214     _LIT(KItem2Format, "\tConnected Sessions\t\t%d");
       
   215     item.Format( KItem2Format, iInfoItemDetails.iCount );
       
   216     model->AppendL( item );
       
   217 
       
   218     // 3rd item = view sessions
       
   219     if  ( iInfoItem->Container().MdcaCount() > 0 )
       
   220         {
       
   221         _LIT(KItem3Format, "\tView Sessions");
       
   222         model->AppendL( KItem3Format );
       
   223         }
       
   224 
       
   225     // Set up list box
       
   226     CAknSettingStyleListBox* listbox = static_cast< CAknSettingStyleListBox* >( iListBox );
       
   227     listbox->Model()->SetItemTextArray( model );
       
   228     listbox->Model()->SetOwnershipType( ELbmOwnsItemArray );
       
   229     CleanupStack::Pop( model );
       
   230     }
       
   231 
       
   232 
       
   233 void CMemSpyViewThreadInfoItemServerDetails::HandleListBoxItemActionedL( TInt /*aIndex*/ )
       
   234     {
       
   235     // Notify observer about an item being 'fired'
       
   236     ReportEventL( MMemSpyViewObserver::EEventItemActioned );
       
   237     }
       
   238 
       
   239 
       
   240 void CMemSpyViewThreadInfoItemServerDetails::HandleListBoxItemSelectedL( TInt /*aIndex*/ )
       
   241     {
       
   242     // Notify observer about item selection
       
   243     ReportEventL( MMemSpyViewObserver::EEventItemSelected );
       
   244     }
       
   245 
       
   246 
       
   247 
       
   248 
       
   249 
       
   250 
       
   251 
       
   252 
       
   253 
       
   254 
       
   255 
       
   256 
       
   257 
       
   258 
       
   259 
       
   260 
       
   261 
       
   262 
       
   263 
       
   264 
       
   265 
       
   266 
       
   267 
       
   268 
       
   269 
       
   270 
       
   271 
       
   272 
       
   273 CMemSpyViewThreadInfoItemServerSessions::CMemSpyViewThreadInfoItemServerSessions( CMemSpyEngine& aEngine, MMemSpyViewObserver& aObserver, CMemSpyThreadInfoContainer& aContainer, const TMemSpyDriverHandleInfoGeneric& aInfoItemDetails )
       
   274 :   CMemSpyViewThreadInfoItemGeneric( aEngine, aObserver, aContainer, EMemSpyThreadInfoItemTypeServer ), iInfoItemDetails( aInfoItemDetails )
       
   275     {
       
   276     }
       
   277 
       
   278 
       
   279 void CMemSpyViewThreadInfoItemServerSessions::ConstructL( const TRect& aRect, CCoeControl& aContainer, TAny* aSelectionRune )
       
   280     {
       
   281     CMemSpyViewThreadInfoItemGeneric::ConstructL( aRect, aContainer, aSelectionRune );
       
   282     //
       
   283     _LIT( KTitle, "Connected Session List" );
       
   284     SetTitleL( KTitle );
       
   285     }
       
   286 
       
   287 
       
   288 TBool CMemSpyViewThreadInfoItemServerSessions::HandleCommandL( TInt aCommand )
       
   289     {
       
   290     TBool handled = CMemSpyViewBase::HandleCommandL( aCommand );
       
   291     return handled;
       
   292     }
       
   293 
       
   294 
       
   295 TMemSpyViewType CMemSpyViewThreadInfoItemServerSessions::ViewType() const
       
   296     {
       
   297     return EMemSpyViewTypeThreadInfoItemServerSessions;
       
   298     }
       
   299 
       
   300 
       
   301 CMemSpyViewBase* CMemSpyViewThreadInfoItemServerSessions::PrepareParentViewL()
       
   302     {
       
   303     CMemSpyViewThreadInfoItemServerDetails* parent = new(ELeave) CMemSpyViewThreadInfoItemServerDetails( iEngine, iObserver, iInfoItem->Container(), iInfoItemDetails );
       
   304     CleanupStack::PushL( parent );
       
   305     parent->ConstructL( Rect(), *Parent(), this );
       
   306     CleanupStack::Pop( parent );
       
   307     return parent;
       
   308     }
       
   309 
       
   310 
       
   311 void CMemSpyViewThreadInfoItemServerSessions::SetListBoxModelL()
       
   312     {
       
   313     CDesCArrayFlat* model = new(ELeave) CDesCArrayFlat(4);
       
   314     CleanupStack::PushL( model );
       
   315 
       
   316     // Get handles
       
   317     RArray<TMemSpyDriverServerSessionInfo> sessions;
       
   318     CleanupClosePushL( sessions );
       
   319     iEngine.HelperServer().GetServerSessionsL( iInfoItemDetails, sessions );
       
   320 
       
   321     // Prepare items
       
   322     TBuf<KMaxFullName + 1> item;
       
   323     const TInt count = sessions.Count();
       
   324     for( TInt i=0; i<count; i++ )
       
   325         {
       
   326         _LIT(KInsertTab, "\t");
       
   327 
       
   328         const TMemSpyDriverServerSessionInfo& session = sessions[ i ];
       
   329         item.Zero();
       
   330 
       
   331         if  ( session.iOwnerType == TMemSpyDriverServerSessionInfo::EOwnerThread )
       
   332             {
       
   333             // Find the thread object
       
   334             CMemSpyThread* thread = NULL;
       
   335             CMemSpyProcess* process = NULL;
       
   336             //
       
   337             const TInt error = iEngine.Container().ProcessAndThreadByThreadId( session.iOwnerId, process, thread );
       
   338             //
       
   339             if  ( error == KErrNone )
       
   340                 {
       
   341                 item.Append( process->Name() );
       
   342                 item.Append( KInsertTab );
       
   343                 item.Append( KInsertTab );
       
   344                 item.Append( thread->Name() );
       
   345                 }
       
   346             }
       
   347         else if ( session.iOwnerType == TMemSpyDriverServerSessionInfo::EOwnerProcess )
       
   348             {
       
   349             // Find the process object
       
   350             CMemSpyProcess* process = NULL;
       
   351             TRAPD( error, process = &iEngine.Container().ProcessByIdL( session.iOwnerId ) );
       
   352             if  ( error == KErrNone )
       
   353                 {
       
   354                 item.Append( process->Name() );
       
   355                 }
       
   356             }
       
   357 
       
   358         if  ( !item.Length() )
       
   359             {
       
   360             // Fall-back case
       
   361             item.Copy( session.iName );
       
   362             }
       
   363 
       
   364         // Add item
       
   365         item.Insert( 0, KInsertTab );
       
   366         model->AppendL( item );
       
   367         }
       
   368     CleanupStack::PopAndDestroy( &sessions );
       
   369 
       
   370     // Set up list box
       
   371     CAknSettingStyleListBox* listbox = static_cast< CAknSettingStyleListBox* >( iListBox );
       
   372     listbox->Model()->SetItemTextArray( model );
       
   373     listbox->Model()->SetOwnershipType( ELbmOwnsItemArray );
       
   374     CleanupStack::Pop( model );
       
   375     }
       
   376 
       
   377 
       
   378 
       
   379 
       
   380 
       
   381 
       
   382 
       
   383 
       
   384 
       
   385 
       
   386 
       
   387 
       
   388 
       
   389 
       
   390 
       
   391